using System.Collections.Generic;
namespace CustomerOrdersSample.Domain
{
   public class Customer
   {
       public virtual int Id { get; set; }
       public virtual string Name { get; set; }
       public virtual IList<Order> Orders { get; set; }
   }
}

using System;
using System.Collections.Generic;
namespace CustomerOrdersSample.Domain
{
   public class Order
   {
       public virtual int Id { get; set; }
       public virtual DateTime OrderDate { set; get; }
       public virtual Customer Customer { get; set; }
       public virtual IList<OrderItem> OrderItems { set; get; }
   }
}

namespace CustomerOrdersSample.Domain
{
   public class OrderItem
   {
       public virtual int Id { get; set; }
       public virtual Product Product { get; set; }
       public virtual int Quntity { get; set; }
       public virtual Order Order { set; get; }
   }
}

namespace CustomerOrdersSample.Domain
{
   public class Product
   {
       public virtual int Id { set; get; }
       public virtual string Name { get; set; }
       public virtual decimal UnitPrice { get; set; }
   }
}

    create table Customers (
      CustomerId INT IDENTITY NOT NULL,
      Name NVARCHAR(255) null,
      primary key (CustomerId)
   )

   create table Orders (
      OrderId INT IDENTITY NOT NULL,
      OrderDate DATETIME null,
      CustomerId INT null,
      primary key (OrderId)
   )

   create table OrderItems (
      OrderItemId INT IDENTITY NOT NULL,
      Quntity INT null,
      ProductId INT null,
      OrderId INT null,
      primary key (OrderItemId)
   )

   create table Products (
      ProductId INT IDENTITY NOT NULL,
      Name NVARCHAR(255) null,
      UnitPrice NUMERIC(19,5) null,
      primary key (ProductId)
   )

   alter table Orders
       add constraint fk_Customer_Order
       foreign key (CustomerId)
       references Customers

   alter table OrderItems
       add constraint fk_Product_OrderItem
       foreign key (ProductId)
       references Products

   alter table OrderItems
       add constraint fk_Order_OrderItem
       foreign key (OrderId)
       references Orders

SET IDENTITY_INSERT [Customers] ON;
GO
INSERT INTO [Customers] ([CustomerId],[Name]) VALUES (1,N'Customer1');
GO
SET IDENTITY_INSERT [Customers] OFF;
GO
SET IDENTITY_INSERT [Products] ON;
GO
INSERT INTO [Products] ([ProductId],[Name],[UnitPrice]) VALUES (1,N'Product1',1000.00000);
GO
INSERT INTO [Products] ([ProductId],[Name],[UnitPrice]) VALUES (2,N'Product2',2000.00000);
GO
INSERT INTO [Products] ([ProductId],[Name],[UnitPrice]) VALUES (3,N'Product3',3000.00000);
GO
SET IDENTITY_INSERT [Products] OFF;
GO
SET IDENTITY_INSERT [Orders] ON;
GO
INSERT INTO [Orders] ([OrderId],[OrderDate],[CustomerId]) VALUES (1,{ts '2011-01-07 11:25:20.000'},1);
GO
SET IDENTITY_INSERT [Orders] OFF;
GO
SET IDENTITY_INSERT [OrderItems] ON;
GO
INSERT INTO [OrderItems] ([OrderItemId],[Quntity],[ProductId],[OrderId]) VALUES (1,10,1,1);
GO
INSERT INTO [OrderItems] ([OrderItemId],[Quntity],[ProductId],[OrderId]) VALUES (2,5,2,1);
GO
INSERT INTO [OrderItems] ([OrderItemId],[Quntity],[ProductId],[OrderId]) VALUES (3,20,3,1);
GO
SET IDENTITY_INSERT [OrderItems] OFF;
GO

var list = session.QueryOver<Customer>().List();

foreach (var customer in list)
{
      foreach (var order in customer.Orders)
      {
          foreach (var orderItem in order.OrderItems)
          {
                Console.WriteLine("{0}:{1}:{2}", customer.Name, order.OrderDate, orderItem.Product.Name);
           }
       }
}

Customer1:2011/01/07 11:25:20 :Product1
Customer1:2011/01/07 11:25:20 :Product2
Customer1:2011/01/07 11:25:20 :Product3

var list = session
                   .QueryOver<Customer>()
                   .Fetch(c => c.Orders).Eager
                   .Fetch(c => c.Orders.First().OrderItems).Eager
                   .Fetch(c => c.Orders.First().OrderItems.First().Product).Eager
                   .List();

foreach (var customer in list)
{
     foreach (var order in customer.Orders)
     {
           foreach (var orderItem in order.OrderItems)
           {
               Console.WriteLine("{0}:{1}:{2}", customer.Name, order.OrderDate, orderItem.Product.Name);
            }
      }
}

...
.TransformUsing(NHibernate.Transform.Transformers.DistinctRootEntity)
.List();

var list = session
                   .Query()
                   .FetchMany(c => c.Orders)
                   .ThenFetchMany(o => o.OrderItems)
                   .ThenFetch(p => p.Product)
                   .ToList();

namespace FsWeb.Repositories

open System.Data.Entity
open FsWeb.Models

type FsMvcAppEntities() = 
    inherit DbContext("FsMvcAppExample")

    do Database.SetInitializer(new CreateDatabaseIfNotExists<FsMvcAppEntities>())

    [<DefaultValue()>] val mutable books: IDbSet<Guitar>
    member x.Books with get() = x.books and set v = x.books <- v

namespace FsWeb.Repositories

type BooksRepository() =
    member x.GetAll () = 
        use context = new FsMvcAppEntities() 
        query { for g in context.Books do
                select g }
        |> Seq.toList

FSPowerPack.Linq.Community

query <@ seq { for g in context.Books -> g } @> |> Seq.toList

[<HandleError>]
type BooksController(repository : BooksRepository) =
    inherit Controller()
    new() = new BooksController(BooksRepository())
    member this.Index () =
        repository.GetAll()
        |> this.View

<add name="FsMvcAppExample"
     connectionString="YOUR CONNECTION STRING"
     providerName="System.Data.SqlClient" />

table#languages tbody td:first-child

table#languages tbody td:nth-child(1)

:nth-child(2)

:nth-child(3)
یا
:last-child

<html>
<head>
    <script type="text/javascript" src="Scripts/PersianDatePicker.min.js"></script>
    <link type="text/css" rel="stylesheet" href="Content/PersianDatePicker.min.css" />
</head>
<body>
    <input type="text" onclick="PersianDatePicker.Show(this, '1392/03/22');" />
</body>
</html>

• C# 8 Adds Ranges and Recursive Patterns
• Ranges easily define a sequence of data, replacing the Enumberable.Range()
• Recursive Patterns brings an F#-like construct to C#
• Recursive Patterns is an awesome feature, it giving you the flexibility to testing the data against a sequence of conditions and performing further computations based on the condition met.
• Ranges is very useful to generate sequences of numbers in the form of a collection or a list. 

      Senior Developer
      .Net Technologies
      Resume : ------------------------------------