LINQ Basic To Advanced – MVC Demo Application

LINQ Basic to Advanced Index View

[toc]

Introduction

Here, in this post we are going to a see some LINQ queries, which covers both basics and advanced. LINQ queries are 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 a MVC demo application. I hope you will like this. Now let’s begin.

Download Source Code

  • LINQ_B_To_A
  • Background

    Whenever I get a chance to write some server side codes in C#, I always write it using LINQ. And 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 it 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 articles available in the Internet on the topic LINQ, but most of them dont cover the differences of writing the queries in two possible ways, the motive 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 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.

    [csharp]
    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();
    }
    }
    [/csharp]

    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.

    [html]
    @{
    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" />
    [/html]

    LINQ Basic to Advanced Index View

    LINQ Basic to Advanced Index View

    Normal Select Query With StartWith and Take

    Let’s have a look at the preceding query.

    [csharp]
    /// <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);
    }
    [/csharp]

    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 which starts 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. How about you?

    [html]
    @model IQueryable<LINQ_B_to_A.Models.City>
    <style>
    dd, dt, pre {
    border: 1px solid #ccc;
    padding: 5px;
    margin: 5px;
    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>
    [/html]

    We are ready to see our first query in action now.

    Let’s creat a partial view now to show the data we fetched. LINQ Basic to Advanced Normal Select Query With StartsWith and Take

    JOIN Query

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

    [csharp]
    /// <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);
    }
    [/csharp]

    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.

    [csharp]
    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; }
    }
    }
    [/csharp]

    The view can be written as follows.

    [html]
    @model IEnumerable<LINQ_B_to_A.Models.OrderAndOrderLines>
    <style>
    td, th, thead,pre {
    border: 1px solid #ccc;
    padding: 5px;
    margin: 5px;
    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>
    [/html]

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

    LINQ Basic to Advanced Join With Where

    LINQ Basic to Advanced Join With Where

    Left JOIN Query

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

    [csharp]
    /// <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);
    }
    [/csharp]

    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.

    [html]
    @model IEnumerable<LINQ_B_to_A.Models.OrderAndOrderLines>
    <style>
    td, th, thead, pre {
    border: 1px solid #ccc;
    padding: 5px;
    margin: 5px;
    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>
    [/html]

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

    LINQ Basic to Advanced Left Join

    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.

    [csharp]
    /// <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);
    }
    [/csharp]

    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.

    [html]
    @model List<string>
    <style>
    dd, dt, pre {
    border: 1px solid #ccc;
    padding: 5px;
    margin: 5px;
    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>
    [/html]

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

    LINQ Basic to Advanced Distinct Query

    LINQ Basic to Advanced Distinct Query

    Equals and Not Equals Queries

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

    [csharp]
    /// <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);
    }
    [/csharp]

    The view can be written as follows.

    [html]
    @model IQueryable<LINQ_B_to_A.Models.City>
    <style>
    td, th, thead, pre {
    border: 1px solid #ccc;
    padding: 5px;
    margin: 5px;
    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>
    [/html]

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

    LINQ Basic to Advanced Equals and Not Equals

    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.

    [csharp]
    /// <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);
    }
    [/csharp]

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

    LINQ Basic to Advanced Paging Queries

    LINQ Basic to Advanced Paging Queries

    LINQ Math Queries

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

    [csharp]
    /// <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);
    }
    [/csharp]

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

    [csharp]
    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; }
    }
    }
    [/csharp]

    Let’s see the view now.

    [html]

    @model IQueryable<LINQ_B_to_A.Models.MathClass>
    <style>
    td, th, thead, pre {
    border: 1px solid #ccc;
    padding: 5px;
    margin: 5px;
    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>
    [/html]

    See the result now.

    LINQ Basic to Advanced Math Queries

    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.

    [csharp]
    /// <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);
    }
    [/csharp]

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

    [csharp]
    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; }
    }
    }
    [/csharp]

    Let’s see the view now.

    [html]

    @model IQueryable<LINQ_B_to_A.Models.StringClass>
    <style>
    td, th, thead, pre {
    border: 1px solid #ccc;
    padding: 5px;
    margin: 5px;
    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>
    [/html]

    Now see the result.

    LINQ Basic to Advanced String Queries

    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

    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

    LINQ Basic to Advanced Select Tooltip

    [csharp]
    /// <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);
    }
    [/csharp]

    Let’s see the view now.

    [html]
    @model IQueryable<LINQ_B_to_A.Models.Invoice>
    <style>
    td, th, thead, pre {
    border: 1px solid #ccc;
    padding: 5px;
    margin: 5px;
    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>
    [/html]

    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

    LINQ Basic to Advanced SelectMany

    Conclusion

    Did I miss anything that you may think which is needed? Could you find this post as useful? I hope you liked this article. Please share 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.

    Kindest Regards
    Sibeesh Venu

    Leave a Reply

    Your email address will not be published. Required fields are marked *

    Serverless 360