LINQ Basic To Advanced - MVC Demo Application

Introduction

Here, in this post, we are going to a see some basic and advanced LINQ queries. LINQ queries were introduced few years back to offer a consistent way for working with data across many datasources and formats. In LINQ queries, you will always work with objects, which makes it simple to write. I hope you would have already written lots of LINQ queries already, if you haven’t, I strongly reccommend you to read this blog where you can find the answer for, why do we need to use LINQ?. Here, I am going to create an MVC demo application. I hope you will like this. Now, let’s begin. You can always see this article in my blog here.

Download Source Code

• LINQ_B_To_A

Background

Whenever I got chance to write some Server side codes in C#, I always prefer using LINQ. A few weeks back, I was assigned to a training programme where my job was to teach LINQ, hence this post covers the the queries I have written for the training programme. Hope you will find these useful.

Using the code

A LINQ query can be written in two ways.

• Query Syntax
• Method Chain or Using dot(.) operator

There are so many LiNQ related articles available on the Internet but most of them don't cover the differences of writing the queries in two possible ways. The motif of this article is to write the queries in both ways, so that you can understand the differnces.

As I mentioned, we are going to create an MVC application, we need to create it first and then configure the entity. Let’s go and do that.

Create a database

To get started with, we need to configure our database first. To do so, either you can download the Wild World Importers from here or you can run the script file included in the downlaod link above.

Once after you have created the database, you can create your MVC application and Entity Data Model in it.

Configuring MVC application with Entity Data Model

By this time, I hope you would have configured your MVC application with Entity Data Model. Now it is time to create a controller and Entity object.

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Windows.Forms;
using LINQ_B_to_A.Models;
namespace LINQ_B_to_A.Controllers {
    public class HomeController: Controller {
        // GET: Home
        public MyDataModel DtContext {
            get;
            set;
        } = new MyDataModel();
    }
}

Now, we can write some LINQ queries as everything is set to get started.

Setting up the Index view with possible actions

This is just to call the actions we are going write. Let’s see the Index page now.

@ {
    ViewBag.Title = "Index";
    Layout = "~/Views/Shared/_Layout.cshtml";
} < h2 > Index < /h2> < input type = "button"
class = "btn-info"
onclick = "location.href='@Url.Action("
LoadAll ","
Home ")'"
value = "Load All - Query Expression" / > < input type = "button"
class = "btn-info"
onclick = "location.href='@Url.Action("
JoinWithWhere ","
Home ")'"
value = "Join With Where" / > < input type = "button"
class = "btn-info"
onclick = "location.href='@Url.Action("
LeftJoin ","
Home ")'"
value = "Left Join" / > < input type = "button"
class = "btn-info"
onclick = "location.href='@Url.Action("
DistinctSample ","
Home ")'"
value = "Distinct Sample" / > < input type = "button"
class = "btn-info"
onclick = "location.href='@Url.Action("
EqualsSamples ","
Home ")'"
value = "Equals Sample" / > < input type = "button"
class = "btn-info"
onclick = "location.href='@Url.Action("
NotEqualsSamples ","
Home ")'"
value = "Not Equals" / > < input type = "button"
class = "btn-info"
onclick = "location.href='@Url.Action("
PagingQueries ","
Home ")'"
value = "Paging Queries" / > < input type = "button"
class = "btn-info"
onclick = "location.href='@Url.Action("
MathQueries ","
Home ")'"
value = "Math Queries" / > < input type = "button"
class = "btn-info"
onclick = "location.href='@Url.Action("
StringQueries ","
Home ")'"
value = "String Queries" / > < input type = "button"
class = "btn-info"
onclick = "location.href='@Url.Action("
SelectMany ","
Home ")'"
value = "Select Many" / >

LINQ Basic to Advanced Index View

Normal Select Query With StartWith and Take

Let’s have a look at the preceding query.

/// <summary>
/// Linq query with Select
/// </summary>
/// <returns></returns>
public ActionResult LoadAll() {
    var loadAllData = (from d in DtContext.Cities where d.CityName.StartsWith("C") select d).Take(10);
    //Method Chain Format
    var loadAllData1 = DtContext.Cities.Where(d => d.CityName.StartsWith("C")).Take(10);
    return PartialView(loadAllData);
}

As you can see, we are just fetching the data from Cities in both ways. And, we are using StartWith as a filter which actually looks for the city names starting with the letter C; and finally, we are taking 10 elements from it. The first query is the “Query syntax” and the second one is “Method chain”. Personally, I like the second way.

@model IQueryable < LINQ_B_to_A.Models.City > < style > dd, dt, pre {
    border: 1 px solid# ccc;
    padding: 5 px;
    margin: 5 px;
    width: auto;
    width: 20 % ;
}
dd {
    background - color: #a9a9a9
}
pre {
    width: auto;
} < /style> < dd > City Names < /dd>
@foreach(var ctyObj in Model) { < dt > @ctyObj.CityName < /dt>
} < pre > public ActionResult LoadAll() {
    var loadAllData = (from d in DtContext.Cities where d.CityName.StartsWith("C") select d).Take(10);
    //Method Chain Format
    var loadAllData1 = DtContext.Cities.Where(d => d.CityName.StartsWith("C")).Take(10);
    return PartialView(loadAllData);
} < /pre>

We are ready to see our first query in action now. Let’s creat a partial View now to show the data we fetched.

JOIN Query

To write a join, the query would be as preceding.

/// <summary>
/// Linq query with join and where
/// </summary>
/// <returns></returns>
public ActionResult JoinWithWhere() {
    var loadAllData = (from oOrders in DtContext.Orders join oOrderLines in DtContext.OrderLines on oOrders.OrderID equals oOrderLines.OrderID orderby oOrders.OrderID select new OrderAndOrderLines() {
        OrderId = oOrders.OrderID,
            Description = oOrderLines.Description,
            Quantity = oOrderLines.Quantity
    }).Take(10);
    //Method Chain Format
    var asMethodChain = DtContext.Orders.Join(DtContext.OrderLines, oOrders => oOrders.OrderID, oOrderLines => oOrderLines.OrderID, (oOrders, oOrderLines) => new {
        oOrders,
        oOrderLines
    }).OrderBy(@o => @o.oOrders.OrderID).Select(@s => new OrderAndOrderLines() {
        OrderId = @s.oOrders.OrderID,
            Description = @s.oOrderLines.Description,
            Quantity = @s.oOrderLines.Quantity
    }).Take(10);
    return PartialView(loadAllData);
}

In the above query, we are just joining the tables Order and OrderLines with OrderID and to select, we are using another custom model OrderAndOrderLines.

namespace LINQ_B_to_A.Models {
    public partial class OrderAndOrderLines {
        public int OrderId {
            get;
            set;
        }
        public string Description {
            get;
            set;
        }
        public int ? Quantity {
            get;
            set;
        }
    }
}

The View can be written as follows.

@model IEnumerable < LINQ_B_to_A.Models.OrderAndOrderLines > < style > td, th, thead, pre {
    border: 1 px solid# ccc;
    padding: 5 px;
    margin: 5 px;
    width: auto;
    width: 20 % ;
}
caption {
    background - color: #a9a9a9
}
pre {
    width: auto;
} < /style> < table > < caption > Order Details < /caption> < tr > < th > Order ID < /th> < th > Description < /th> < th > Quantity < /th> < /tr>
@foreach(var @item in Model) { < tr > < td > @item.OrderId < /td> < td > @item.Description < /td> < td > @item.Quantity < /td> < /tr>
} < /table> < pre > public ActionResult JoinWithWhere() {
    var loadAllData = (from oOrders in DtContext.Orders join oOrderLines in DtContext.OrderLines on oOrders.OrderID equals oOrderLines.OrderID orderby oOrders.OrderID select new OrderAndOrderLines() {
        OrderId = oOrders.OrderID,
            Description = oOrderLines.Description,
            Quantity = oOrderLines.Quantity
    }).Take(10);
    //Method Chain Format
    var asMethodChain = DtContext.Orders.Join(DtContext.OrderLines, oOrders => oOrders.OrderID, oOrderLines => oOrderLines.OrderID, (oOrders, oOrderLines) => new {
        oOrders,
        oOrderLines
    }).OrderBy(o => o.oOrders.OrderID).Select(s => new OrderAndOrderLines() {
        OrderId = s.oOrders.OrderID,
            Description = s.oOrderLines.Description,
            Quantity = s.oOrderLines.Quantity
    }).Take(10);
    return PartialView(loadAllData);
} < /pre>

Once you run the action, you can see the result as follows.

LINQ Basic to Advanced Join With Where

Left JOIN Query

To write a Left join, the query would be as preceding.

/// <summary>
/// Linq query with Left Join
/// </summary>
/// <returns></returns>
public ActionResult LeftJoin() {
    var loadAllData = (from oOrder in DtContext.Orders join oOrderLine in DtContext.OrderLines on oOrder.OrderID equals oOrderLine.OrderID into lftOrder from afterJoined in lftOrder.DefaultIfEmpty() orderby oOrder.OrderID descending select new OrderAndOrderLines() {
        OrderId = oOrder.OrderID,
            Description = afterJoined.Description
    }).Take(10).ToList();
    //Method Chain Format
    var lftJoinMethodChain = (DtContext.Orders.GroupJoin(DtContext.OrderLines, oOrder => oOrder.OrderID, oOrderLine => oOrderLine.OrderID, (oOrder, lftJoin) => new {
        oOrder,
        lftJoin
    }).SelectMany(@sm => @sm.lftJoin.DefaultIfEmpty(), (@sm, afterJoin) => new {
        @sm,
        afterJoin
    }).OrderByDescending(@o => @o.sm.oOrder.OrderID).Select(@s => new OrderAndOrderLines() {
        OrderId = @s.sm.oOrder.OrderID,
            Description = @s.afterJoin.Description
    })).Take(10).ToList();
    return PartialView(loadAllData);
}

In the above query, we are just joining the tables Order and OrderLines with OrderID and to select we are using an another custom model OrderAndOrderLines as our previous query. The differences you could find here are, using an ‘into’ and ‘DefaultIfEmpty’ statements. The DefaultIfEmpty is making sure that it returns empty if there is no appropriate rows found in the second table.

The View can be written as follows.

@model IEnumerable < LINQ_B_to_A.Models.OrderAndOrderLines > < style > td, th, thead, pre {
    border: 1 px solid# ccc;
    padding: 5 px;
    margin: 5 px;
    width: auto;
    width: 20 % ;
}
caption {
    background - color: #a9a9a9
}
pre {
    width: auto;
} < /style> < table > < caption > Order Details < /caption> < tr > < th > Order ID < /th> < th > Description < /th> < th > Quantity < /th> < /tr>
@foreach(var @item in Model) { < tr > < td > @item.OrderId < /td> < td > @item.Description < /td> < td > @item.Quantity < /td> < /tr>
} < /table> < pre > public ActionResult LeftJoin() {
    var loadAllData = (from oOrder in DtContext.Orders join oOrderLine in DtContext.OrderLines on oOrder.OrderID equals oOrderLine.OrderID into lftOrder from afterJoined in lftOrder.DefaultIfEmpty() orderby oOrder.OrderID descending select new OrderAndOrderLines() {
        OrderId = oOrder.OrderID,
            Description = afterJoined.Description
    }).Take(10).ToList();
    //Method Chain Format
    var lftJoinMethodChain = (DtContext.Orders.GroupJoin(DtContext.OrderLines, oOrder => oOrder.OrderID, oOrderLine => oOrderLine.OrderID, (oOrder, lftJoin) => new {
        oOrder,
        lftJoin
    }).SelectMany(sm => sm.lftJoin.DefaultIfEmpty(), (sm, afterJoin) => new {
        sm,
        afterJoin
    }).OrderByDescending(o => o.sm.oOrder.OrderID).Select(s => new OrderAndOrderLines() {
        OrderId = s.sm.oOrder.OrderID,
            Description = s.afterJoin.Description
    })).Take(10).ToList();
    return PartialView(loadAllData);
} < /pre>

Once you run the action, you can see the result as follows.

LINQ Basic to Advanced Left Join

As you can see in the image, the order id 200000 doesn’t has any appropriate rows in the second table, so it shows as empty.

Distinct Query

The below query shows how we can write simple distinct query.

/// <summary>
/// Linq query Distinct sample
/// </summary>
/// <returns></returns>
public ActionResult DistinctSample() {
    var distictSample = (from oOrder in DtContext.OrderLines select oOrder.Description).Distinct().Take(10).ToList();
    //Method Chain Format
    var distictAsMethodChain = (DtContext.OrderLines.Select(oOrder => oOrder.Description)).Distinct().Take(10).ToList();
    return PartialView(distictSample);
}

In the above query, we use Distinct to make sure that only distict items are selected from the result. The View can be written as follows.

@model List < string > < style > dd, dt, pre {
    border: 1 px solid# ccc;
    padding: 5 px;
    margin: 5 px;
    width: auto;
    width: 20 % ;
}
dd {
    background - color: #a9a9a9
}
pre {
    width: auto;
} < /style> < dd > Order Descriptions < /dd>
@foreach(var orderLinesyObj in Model) { < dt > @orderLinesyObj < /dt>
} < pre > public ActionResult DistinctSample() {
    var distictSample = (from oOrder in DtContext.OrderLines select oOrder.Description).Distinct().Take(10).ToList();
    //Method Chain Format
    var distictAsMethodChain = (DtContext.OrderLines.Select(oOrder => oOrder.Description)).Distinct().Take(10).ToList();
    return PartialView(distictSample);
} < /pre>

Once you run the action, you can see the result as follows.

LINQ Basic to Advanced Distinct Query

Equals and Not Equals Queries

We can write the equals and not equals query as preceding.

/// <summary>
/// Linq query Equals sample
/// </summary>
/// <returns></returns>
public ActionResult EqualsSamples() {
    var objEquals = (from objCity in DtContext.Cities where objCity.CityName.Equals("Troy") select objCity).Take(2);
    //Method Chain Format
    var objEquals1 = DtContext.Cities.Where(d => d.CityName.Equals("Troy")).Take(2);
    return PartialView("OperatorSamples", objEquals);
}
/// <summary>
/// Linq query Not Equals sample
/// </summary>
/// <returns></returns>
public ActionResult NotEqualsSamples() {
    var objNotEquals = (from objCity in DtContext.Cities where objCity.CityName != "Troy"
        select objCity).Take(5);
    var objNotEquals1 = (from objCity in DtContext.Cities where!objCity.CityName.Equals("Troy") select objCity).Take(5);
    //Method Chain Format
    var objNotEquals2 = DtContext.Cities.Where(d => d.CityName != "Troy").Take(2);
    var objNotEquals3 = DtContext.Cities.Where(d => !d.CityName.Equals("Troy")).Take(2);
    return PartialView("OperatorSamples", objNotEquals);
}

The view can be written as follows.

@model IQueryable < LINQ_B_to_A.Models.City > < style > td, th, thead, pre {
    border: 1 px solid# ccc;
    padding: 5 px;
    margin: 5 px;
    width: auto;
    width: 20 % ;
}
caption {
    background - color: #a9a9a9
}
pre {
    width: auto;
} < /style> < table > < caption > City Details < /caption> < tr > < th > City ID < /th> < th > City Name < /th> < th > City Location < /th> < /tr>
@foreach(var @item in Model) { < tr > < td > @item.CityID < /td> < td > @item.CityName < /td> < td > @item.Location < /td> < /tr>
} < /table> < caption > Equals Oerator < /caption> < pre > public ActionResult EqualsSamples() {
    var objEquals = (from objCity in DtContext.Cities where objCity.CityName.Equals("Troy") select objCity).Take(2);
    //Method Chain Format
    var objEquals1 = DtContext.Cities.Where(d => d.CityName.Equals("Troy")).Take(2);
    return PartialView("OperatorSamples", objEquals);
}
public ActionResult NotEqualsSamples() {
    var objNotEquals = (from objCity in DtContext.Cities where objCity.CityName != "Troy"
        select objCity).Take(5);
    var objNotEquals1 = (from objCity in DtContext.Cities where!objCity.CityName.Equals("Troy") select objCity).Take(5);
    //Method Chain Format
    var objNotEquals2 = DtContext.Cities.Where(d => d.CityName != "Troy").Take(2);
    var objNotEquals3 = DtContext.Cities.Where(d => !d.CityName.Equals("Troy")).Take(2);
    return PartialView("OperatorSamples", objNotEquals);
}
public ActionResult PagingQueries() {
    var objNotEquals = (from objCity in DtContext.Cities where objCity.CityName != "Troy"
        orderby objCity.CityName ascending select objCity).Skip(5).Take(5);
    //Method Chain Format
    var objNotEquals2 = DtContext.Cities.Where(d => d.CityName != "Troy").Skip(5).Take(5);
    return PartialView("OperatorSamples", objNotEquals);
} < /pre>

Once you run the action you can see the result as follows.

LINQ Basic to Advanced Equals and Not Equals

LINQ Paging Queries

Paging queries are always important as we work in some grid controls, with LINQ those are very easy. Let’s see one of that query.

/// <summary>
/// Linq Paging Queries
/// </summary>
/// <returns></returns>
public ActionResult PagingQueries() {
    var objNotEquals = (from objCity in DtContext.Cities where objCity.CityName != "Troy"
        orderby objCity.CityName ascending select objCity).Skip(5).Take(5);
    //Method Chain Format
    var objNotEquals2 = DtContext.Cities.Where(d => d.CityName != "Troy").Skip(5).Take(5);
    return PartialView("OperatorSamples", objNotEquals);
}

Once you run the action, you can see the result as follows.

LINQ Basic to Advanced Paging Queries

LINQ Math Queries

Here, we are going to write the possible Math functions in our LINQ query.

/// <summary>
/// Math Queries
/// </summary>
/// <returns></returns>
public ActionResult MathQueries() {
    var objMath = (from objInv in DtContext.InvoiceLines where objInv.ExtendedPrice > 10 && objInv.Quantity < 15 orderby objInv.InvoiceLineID descending select new MathClass() {
        Actual = objInv.ExtendedPrice,
            Round = Math.Round(objInv.ExtendedPrice),
            Floor = Math.Floor(objInv.ExtendedPrice),
            Ceiling = Math.Ceiling(objInv.ExtendedPrice),
            Abs = Math.Abs(objInv.ExtendedPrice)
    }).Take(10);
    //Method Chain Format
    var objMath2 = DtContext.InvoiceLines.Where(objInv => objInv.ExtendedPrice > 10 && objInv.Quantity < 15).OrderByDescending(o => o.InvoiceLineID).Select(objInv => new MathClass() {
        Actual = objInv.ExtendedPrice,
            Round = Math.Round(objInv.ExtendedPrice),
            Floor = Math.Floor(objInv.ExtendedPrice),
            Ceiling = Math.Ceiling(objInv.ExtendedPrice),
            Abs = Math.Abs(objInv.ExtendedPrice)
    }).Take(10);
    return PartialView("MathQueries", objMath);
}

As you can see, we have written most of the possible Math functions in our query and selecting with a custome model MathClass.

namespace LINQ_B_to_A.Models {
    public partial class MathClass {
        public decimal Actual {
            get;
            set;
        }
        public decimal Round {
            get;
            set;
        }
        public decimal Floor {
            get;
            set;
        }
        public decimal Ceiling {
            get;
            set;
        }
        public decimal Abs {
            get;
            set;
        }
    }
}

Let’s see the View now.

@model IQueryable < LINQ_B_to_A.Models.MathClass > < style > td, th, thead, pre {
    border: 1 px solid# ccc;
    padding: 5 px;
    margin: 5 px;
    width: auto;
    width: 20 % ;
}
caption {
    background - color: #a9a9a9
}
pre {
    width: auto;
} < /style> < table > < caption > Math Operators < /caption> < tr > < /tr>
@foreach(var @item in Model) { < tr > < td > Actual: @item.Actual < /td> < td > Round: @item.Round < /td> < td > Floor: @item.Floor < /td> < td > Ceiling: @item.Ceiling < /td> < td > Abs: @item.Abs < /td> < /tr>
} < /table> < pre > public ActionResult MathQueries() {
    var objMath = (from objInv in DtContext.InvoiceLines where objInv.ExtendedPrice > 10 && objInv.Quantity < 15 orderby objInv.InvoiceLineID descending select new MathClass() {
        Actual = objInv.ExtendedPrice,
            Round = Math.Round(objInv.ExtendedPrice),
            Floor = Math.Floor(objInv.ExtendedPrice),
            Ceiling = Math.Ceiling(objInv.ExtendedPrice),
            Abs = Math.Abs(objInv.ExtendedPrice)
    }).Take(10);
    //Method Chain Format
    var objMath2 = DtContext.InvoiceLines.Where(objInv => objInv.ExtendedPrice > 10 && objInv.Quantity < 15).OrderByDescending(o => o.InvoiceLineID).Select(objInv => new MathClass() {
        Actual = objInv.ExtendedPrice,
            Round = Math.Round(objInv.ExtendedPrice),
            Floor = Math.Floor(objInv.ExtendedPrice),
            Ceiling = Math.Ceiling(objInv.ExtendedPrice),
            Abs = Math.Abs(objInv.ExtendedPrice)
    }).Take(10);
    return PartialView("MathQueries", objMath);
} < /pre>

See the result now.

LINQ Basic to Advanced Math Queries

LINQ String Queries

As we saw the Math queries, here, we are going to write the possible String functions in our LINQ query.

/// <summary>
/// String Queries
/// </summary>
/// <returns></returns>
public ActionResult StringQueries() {
    var objString = (from objInv in DtContext.InvoiceLines where objInv.ExtendedPrice > 10 && objInv.Quantity < 15 orderby objInv.InvoiceLineID descending select new StringClass() {
        Actual = objInv.Description,
            Insert = objInv.Description.Insert(2, "SibeeshPassion"),
            Remove = objInv.Description.Remove(1, 1),
            Substring = objInv.Description.Substring(2, 3),
            ToLower = objInv.Description.ToLower(),
            ToUpper = objInv.Description.ToUpper(),
            TrimEnd = objInv.Description.TrimEnd(),
            TrimStart = objInv.Description.TrimStart()
    }).Take(2);
    //Method Chain Format
    var objString2 = DtContext.InvoiceLines.Where(objInv => objInv.ExtendedPrice > 10 && objInv.Quantity < 15).OrderByDescending(o => o.InvoiceLineID).Select(objInv => new StringClass() {
        Actual = objInv.Description,
            Insert = objInv.Description.Insert(2, "SibeeshPassion"),
            Remove = objInv.Description.Remove(1, 1),
            Substring = objInv.Description.Substring(2, 3),
            ToLower = objInv.Description.ToLower(),
            ToUpper = objInv.Description.ToUpper(),
            TrimEnd = objInv.Description.TrimEnd(),
            TrimStart = objInv.Description.TrimStart()
    }).Take(2);
    return PartialView("StringQueries", objString);
}

As you can see, here we are using a custom model StringClass.

namespace LINQ_B_to_A.Models {
    public partial class StringClass {
        public string Actual {
            get;
            set;
        }
        public string Insert {
            get;
            set;
        }
        public string Remove {
            get;
            set;
        }
        public string Substring {
            get;
            set;
        }
        public string ToUpper {
            get;
            set;
        }
        public string ToLower {
            get;
            set;
        }
        public string TrimStart {
            get;
            set;
        }
        public string TrimEnd {
            get;
            set;
        }
    }
}

Let’s see the view now.

@model IQueryable < LINQ_B_to_A.Models.StringClass > < style > td, th, thead, pre {
    border: 1 px solid# ccc;
    padding: 5 px;
    margin: 5 px;
    width: auto;
    width: 20 % ;
}
caption {
    background - color: #a9a9a9
}
pre {
    width: auto;
} < /style> < table > < caption > String Operators < /caption> < tr > < /tr>
@foreach(var @item in Model) { < tr > < td > Actual: @item.Actual < /td> < td > Insert: @item.Insert < /td> < td > Remove: @item.Remove < /td> < td > Substring: @item.Substring < /td> < td > ToLower: @item.ToLower < /td> < td > ToUpper: @item.ToUpper < /td> < td > TrimEnd: @item.TrimEnd < /td> < td > TrimStart: @item.TrimStart < /td> < /tr>
} < /table> < pre > public ActionResult StringQueries() {
    var objString = (from objInv in DtContext.InvoiceLines where objInv.ExtendedPrice > 10 && objInv.Quantity < 15 orderby objInv.InvoiceLineID descending select new StringClass() {
        Actual = objInv.Description,
            Insert = objInv.Description.Insert(2, "SibeeshPassion"),
            Remove = objInv.Description.Remove(1, 1),
            Substring = objInv.Description.Substring(2, 3),
            ToLower = objInv.Description.ToLower(),
            ToUpper = objInv.Description.ToUpper(),
            TrimEnd = objInv.Description.TrimEnd(),
            TrimStart = objInv.Description.TrimStart()
    }).Take(2);
    //Method Chain Format
    var objString2 = DtContext.InvoiceLines.Where(objInv => objInv.ExtendedPrice > 10 && objInv.Quantity < 15).OrderByDescending(o => o.InvoiceLineID).Select(objInv => new StringClass() {
        Actual = objInv.Description,
            Insert = objInv.Description.Insert(2, "SibeeshPassion"),
            Remove = objInv.Description.Remove(1, 1),
            Substring = objInv.Description.Substring(2, 3),
            ToLower = objInv.Description.ToLower(),
            ToUpper = objInv.Description.ToUpper(),
            TrimEnd = objInv.Description.TrimEnd(),
            TrimStart = objInv.Description.TrimStart()
    }).Take(2);
    return PartialView("StringQueries", objString);
} < /pre>

Now see the result.

LINQ Basic to Advanced String Queries

SelectMany Query

A SelectMany query flattern the result to a single dimentional collection, so to loop through the result we just need only one loop.

LINQ Basic to Advanced SelectMany Tooltip

If you use the normal Select, you will be getting a list of lists, thus you will have to use two loops to get the datas.

LINQ Basic to Advanced Select Tooltip

/// <summary>
/// Linq query with SelectMany
/// </summary>
/// <returns></returns>
public ActionResult SelectMany() {
    var selectMany = DtContext.Orders.SelectMany(order => order.Invoices).Take(10);
    var select = DtContext.Orders.Select(order => order.Invoices).Take(10);
    return PartialView("SelectMany", selectMany);
}

Let’s see the view now.

@model IQueryable < LINQ_B_to_A.Models.Invoice > < style > td, th, thead, pre {
    border: 1 px solid# ccc;
    padding: 5 px;
    margin: 5 px;
    width: auto;
    width: 20 % ;
}
caption {
    background - color: #a9a9a9
}
pre {
    width: auto;
} < /style> < table > < caption > Invoice Details < /caption> < tr > < th > Order ID < /th> < th > Invoice ID < /th> < th > Invoice Date < /th> < /tr>
@foreach(var @item in Model) { < tr > < td > @item.OrderID < /td> < td > @item.InvoiceID < /td> < td > @item.InvoiceDate < /td> < /tr>
    } < /table> < caption > Select Many < /caption> < pre >
    /// <summary>
    /// Linq query with SelectMany
    /// </summary>
    /// <returns></returns>
    public ActionResult SelectMany() {
        var selectMany = DtContext.Orders.SelectMany(order => order.Invoices).Take(10);
        var select = DtContext.Orders.Select(order => order.Invoices).Take(10);
        return PartialView("SelectMany", selectMany);
    } < /pre>

Now, see the result.

That’s all for today. I will come with another set of LINQ queries in the next part. Till then, bye.

LINQ Basic to Advanced SelectMany

Conclusion

Did I miss anything that you may think is needed? Did you find this post useful? I hope you liked this article. Please share with me your valuable suggestions and feedback.

Your turn. What do you think?

A blog isn’t a blog without comments, but do try to stay on topic. If you have a question unrelated to this post, you’re better off posting it on C# Corner, Code Project, Stack Overflow, Asp.Net Forum instead of commenting here. Tweet or email me a link to your question there and I’ll definitely try to help if I can.