namespace NHSample2.Domain
{
  public class User
  {
      public virtual int Id { get; set; }
      public virtual string UserName { get; set; }
      public virtual string Password { get; set; }
  }
}

namespace NHSample2.Domain
{
  public class Category
  {
      public virtual int Id { get; set; }
      public virtual string CategoryName { get; set; }
  }
}

using System;

namespace NHSample2.Domain
{
  public class News
  {
      public virtual Guid Id { get; set; }
      public virtual string Subject { get; set; }
      public virtual string NewsText { get; set; }
      public virtual DateTime DateEntered { get; set; }
      public virtual Category Category { get; set; }
      public virtual User User { get; set; }
  }
}

using FluentNHibernate.Automapping;
using FluentNHibernate.Cfg;
using FluentNHibernate.Cfg.Db;
using NHibernate;
using NHibernate.Cfg;
using NHibernate.Tool.hbm2ddl;

namespace NHSample2
{
  class Config
  {
      public static Configuration GenerateMapping(IPersistenceConfigurer dbType)
      {
          var cfg = dbType.ConfigureProperties(new Configuration());

          new AutoPersistenceModel()
              .Where(x => x.Namespace.EndsWith("Domain"))
              .AddEntityAssembly(typeof(NHSample2.Domain.News).Assembly).Configure(cfg);

          return cfg;
      }

      public static void GenerateDbScript(Configuration config, string filePath)
      {
          bool script = true;//فقط اسکریپت دیتابیس تولید گردد
          bool export = false;//نیازی نیست بر روی دیتابیس هم اجرا شود
          new SchemaExport(config).SetOutputFile(filePath).Create(script, export);
      }

      public static void BuildDbSchema(Configuration config)
      {
          bool script = false;//آیا خروجی در کنسول هم نمایش داده شود
          bool export = true;//آیا بر روی دیتابیس هم اجرا شود
          bool drop = false;//آیا اطلاعات موجود دراپ شوند
          new SchemaExport(config).Execute(script, export, drop);
      }

      public static void CreateSQL2008DbPlusScript(string connectionString, string filePath)
      {
          Configuration cfg =
              GenerateMapping(
              MsSqlConfiguration
              .MsSql2008
              .ConnectionString(connectionString)
              .ShowSql()
              );
          GenerateDbScript(cfg, filePath);
          BuildDbSchema(cfg);
      }

      public static ISessionFactory CreateSessionFactory(IPersistenceConfigurer dbType)
      {
          return
             Fluently.Configure().Database(dbType)
              .Mappings(m => m.AutoMappings
                         .Add(
                             new AutoPersistenceModel()
                                 .Where(x => x.Namespace.EndsWith("Domain"))
                                 .AddEntityAssembly(typeof(NHSample2.Domain.News).Assembly))
                                 )
               .BuildSessionFactory();
      }
  }
}

using System;

namespace NHSample2
{
  class Program
  {
      static void Main(string[] args)
      {
         Config.CreateSQL2008DbPlusScript(
              "Data Source=(local);Initial Catalog=HelloNHibernate;Integrated Security = true",
              "db.sql");

          Console.WriteLine("Press a key...");
          Console.ReadKey();
      }
  }
}

  create table [Category] (
      Id INT IDENTITY NOT NULL,
     CategoryName NVARCHAR(255) null,
     primary key (Id)
  )

  create table [User] (
      Id INT IDENTITY NOT NULL,
     UserName NVARCHAR(255) null,
     Password NVARCHAR(255) null,
     primary key (Id)
  )

  create table [News] (
      Id UNIQUEIDENTIFIER not null,
     Subject NVARCHAR(255) null,
     NewsText NVARCHAR(255) null,
     DateEntered DATETIME null,
     Category_id INT null,
     User_id INT null,
     primary key (Id)
  )

  alter table [News]
      add constraint FKE660F9E1C9CF79
      foreign key (Category_id)
      references [Category]

  alter table [News]
      add constraint FKE660F95C1A3C92
      foreign key (User_id)

      references [User]

using System;
using FluentNHibernate.Cfg.Db;
using NHibernate;
using NHSample2.Domain;

namespace NHSample2
{
  class Program
  {
      static void Main(string[] args)
      {
          using (ISessionFactory sessionFactory = Config.CreateSessionFactory(
                  MsSqlConfiguration
                      .MsSql2008
                      .ConnectionString("Data Source=(local);Initial Catalog=HelloNHibernate;Integrated Security = true")
                      .ShowSql()
                  ))
          {
              using (ISession session = sessionFactory.OpenSession())
              {
                  using (ITransaction transaction = session.BeginTransaction())
                  {
                      //با توجه به کلیدهای خارجی تعریف شده ابتدا باید گروه‌ها را اضافه کرد
                      Category ca = new Category() {  CategoryName = "Sport" };
                      session.Save(ca);
                      Category ca2 = new Category() { CategoryName = "IT" };
                      session.Save(ca2);
                      Category ca3 = new Category() { CategoryName = "Business" };
                      session.Save(ca3);

                      //سپس یک کاربر را به دیتابیس اضافه می‌کنیم
                      User u = new User() {  Password = "123$5@1", UserName = "VahidNasiri" };
                      session.Save(u);

                      //اکنون می‌توان یک خبر جدید را ثبت کرد

                      News news = new News()
                      {
                          Category = ca,
                          User = u,
                          DateEntered = DateTime.Now,
                          Id = Guid.NewGuid(),
                          NewsText = "متن خبر جدید",
                          Subject = "عنوانی دلخواه"
                      };
                      session.Save(news);

                      transaction.Commit(); //پایان تراکنش
                  }
              }
          }

          Console.WriteLine("Press a key...");
          Console.ReadKey();
      }
  }
}

using System.Linq;
using NHibernate;
using NHibernate.Linq;
using NHSample2.Domain;

namespace NHSample2
{
  class NewsContext : NHibernateContext
  {
      public NewsContext(ISession session)
         : base(session)
     { }

     public IOrderedQueryable<News> News
     {
         get { return Session.Linq<News>(); }
     }

     public IOrderedQueryable<Category> Categories
     {
         get { return Session.Linq<Category>(); }
     }

     public IOrderedQueryable<User> Users
     {
         get { return Session.Linq<User>(); }
     }
  }
}

using System;
using FluentNHibernate.Cfg.Db;
using NHibernate;
using System.Linq;
using NHSample2.Domain;

namespace NHSample2
{
  class Program
  {
      static void Main(string[] args)
      {
          using (ISessionFactory sessionFactory = Config.CreateSessionFactory(
                  MsSqlConfiguration
                      .MsSql2008
                      .ConnectionString("Data Source=(local);Initial Catalog=HelloNHibernate;Integrated Security = true")
                      .ShowSql()
                  ))
          {
              using (ISession session = sessionFactory.OpenSession())
              {
                  using (ITransaction transaction = session.BeginTransaction())
                  {
                      using (NewsContext db = new NewsContext(session))
                      {
                          var query = from x in db.Users
                                      where x.UserName == "VahidNasiri"
                                      select x;

                          //اگر چیزی یافت شد
                          if (query.Any())
                          {
                              User vahid = query.First();
                              //نمایش اطلاعات کاربر
                              Console.WriteLine("Id: {0}, UserName: {0}", vahid.Id, vahid.UserName);
                              //به روز رسانی نام کاربر
                              vahid.UserName = "Vahid";
                              session.Update(vahid);

                              transaction.Commit(); //پایان تراکنش
                          }
                      }
                  }
              }
          }

          Console.WriteLine("Press a key...");
          Console.ReadKey();
      }
  }
}

      using FluentNHibernate.Conventions.Helpers;

      public static Configuration GenerateMapping(IPersistenceConfigurer dbType)
      {
          var cfg = dbType.ConfigureProperties(new Configuration());

          new AutoPersistenceModel()
          .Conventions.Add()
              .Where(x => x.Namespace.EndsWith("Domain"))
               .Conventions.Add(
                 PrimaryKey.Name.Is(x => "ID"),
                 DefaultLazy.Always(),
                 ForeignKey.EndsWith("ID"),
                 Table.Is(t => "tbl" + t.EntityType.Name)                 
                 )
              .AddEntityAssembly(typeof(NHSample2.Domain.News).Assembly)
              .Configure(cfg);

          return cfg;
      }

using FluentNHibernate.Conventions;
using FluentNHibernate.Conventions.Instances;

namespace NHSample2.Conventions
{
  class MyStringLengthConvention : IPropertyConvention
  {
      public void Apply(IPropertyInstance instance)
      {
          instance.Length(500);
      }
  }
}

      public static Configuration GenerateMapping(IPersistenceConfigurer dbType)
      {
          var cfg = dbType.ConfigureProperties(new Configuration());

          new AutoPersistenceModel()
          .Conventions.Add()
              .Where(x => x.Namespace.EndsWith("Domain"))
               .Conventions.Add<MyStringLengthConvention>()
              .AddEntityAssembly(typeof(NHSample2.Domain.News).Assembly)
              .Configure(cfg);

          return cfg;
      }

[MessageContract]
public class MyFile
{
    [MessageHeader] 
    public String Filename { get; set; }

    [MessageBodyMember]    
    public Byte[] Contents { get; set; } 
}

<bindings> 
    <wsHttpBinding>
        <binding name="WsHttpMtomBinding" messageEncoding="Mtom" /> 
    </wsHttpBinding>
 </bindings>

DECLARE @doc XML 
SET @doc ='
<p:people xmlns:p="http://www.people.com">
 <p:person name="Vahid" /> 
 <p:person name="Farid" />
</p:people>
'
SELECT @doc.query('/people/person')

 SELECT @doc.query('/p:people/p:person')

 SELECT @doc.query('
declare default element namespace "http://www.people.com";
/people/person
')

 SELECT @doc.query('
declare namespace aa="http://www.people.com";
/aa:people/aa:person
')

 WITH XMLNAMESPACES(DEFAULT 'http://www.people.com')
SELECT @doc.query('/people/person')

 WITH XMLNAMESPACES('http://www.people.com' AS aa)
SELECT @doc.query('/aa:people/aa:person')

 SELECT @data.query('
 (: FLOWE :)
 for $p in /people/person
 where $p/age > 30
 return $p
 ')

SELECT @data.query('
(: XPath :)
/people/person[age>30]
')

DECLARE @doc XML 
SET @doc='
<Team name="Project 1" xmlns:a="urn:annotations">
  <Employee id="544" years="6.5">
    <Name>User 1</Name>
<Title>Architect</Title>
<Expertise>Games</Expertise>
<Expertise>Puzzles</Expertise>
<Employee id="101" years="7.1" a:assigned-to="C1">
 <Name>User 2</Name>
 <Title>Dev lead</Title>
 <Expertise>Video Games</Expertise>
 <Employee id="50" years="2.3" a:assigned-to="C2">
 <Name>User 3</Name>
 <Title>Developer</Title>
 <Expertise>Hardware</Expertise>
 <Expertise>Entertainment</Expertise>
</Employee>
</Employee> 
  </Employee>
</Team>
'

 SELECT @doc.query('/Team/Employee/Name')

 SELECT @doc.query('/Team/Employee/child::Name')

 <Name>User 1</Name>

 SELECT @doc.query('//Employee/Name')

 <Name>User 1</Name>
<Name>User 2</Name>
<Name>User 3</Name>

 SELECT @doc.query('
declare namespace a = "urn:annotations";
//Employee[@a:assigned-to]/Name
')

 SELECT @doc.query('
declare namespace a = "urn:annotations";
//Employee[attribute::a:assigned-to]/Name
')

 SELECT @doc.query('
declare namespace a = "urn:annotations";
//Employee[not(@a:assigned-to)]/Name
')

 <Name>User 1</Name>

 SELECT @doc.query('count(//Employee[Name="User 1"]/Employee)')

 SELECT @doc.query('//Employee[../Name="User 1"]')

 Select p.name, p.job
from people as p
where p.age > 30
order by p.age

 for $p in /people/person
where $p.age > 30
order by $p.age[1]
return ($p/name, $p/job)

 let $p := /people/person
return $p

 DECLARE @x XML = '';
SELECT @x.query('
for $i in (1,2,3)
return $i
');

SELECT @x.query('
let $i := (1,2,3)
return $i
');

 DECLARE @x XML = '';
SELECT @x.query('
for $i in (1,2,3)
order by $i descending
return $i
');

SELECT @x.query('
let $i := (1,2,3)
order by $i descending
return $i
');

DECLARE @doc XML  =' 
<people>
 <person>
  <name>
<givenName>name1</givenName>
<familyName>lname1</familyName>
  </name>
  <age>33</age>
  <height>short</height>
 </person>
 <person>
  <name>
<givenName>name2</givenName>
<familyName>lname2</familyName>
  </name>
  <age>40</age>
  <height>short</height>
 </person>
 <person>
  <name>
<givenName>name3</givenName>
<familyName>lname3</familyName>
  </name>
  <age>30</age>
  <height>medium</height>
 </person>
</people>
'

 SELECT @doc.query('
for $p in /people/person
return <person>
{$p/name[1]/givenName[1]/text()}
</person>
');

 <person>name1</person>
<person>name2</person>
<person>name3</person>

 SELECT @doc.query('
<root>
{
for $p in /people/person
return <person>
{$p/name[1]/givenName[1]/text()}
</person>
}
</root>
');

 <root>
  <person>name1</person>
  <person>name2</person>
  <person>name3</person>
</root>

 SELECT @doc.query('some $emp in //Employee satisfies $emp/@years >5')
-- true

SELECT @doc.query('every $emp in //Employee satisfies $emp/@years >5')
-- false

           string source =
           @"
               namespace Foo
               {
                    public class Bar
                    {
                        static void Main(string[] args)
                        {
                            Bar.SayHello();
                        }

                        public static void SayHello()
                        {
                            System.Console.WriteLine(""Hello World"");
                        }
                    }
               }
            ";

using System;
using System.Collections.Generic;
//دو فضای نامی که برای این منظور اضافه شده‌اند
using Microsoft.CSharp;
using System.CodeDom.Compiler;

namespace compilerTest
{
   class Program
   {
       static void compileIt1()
       {
           //سورس کد ما جهت کامپایل
           string source =
           @"
               namespace Foo
               {
                    public class Bar
                    {
                        static void Main(string[] args)
                        {
                            Bar.SayHello();
                        }

                        public static void SayHello()
                        {
                            System.Console.WriteLine(""Hello World"");
                        }
                    }
               }
            ";

           //تعیین نگارش کامپایلر مورد استفاده
           Dictionary<string, string> providerOptions = new Dictionary<string, string>
                {
                    {"CompilerVersion", "v3.5"}
                };
           //تعیین اینکه کد ما سی شارپ است
           CSharpCodeProvider provider = new CSharpCodeProvider(providerOptions);

           //تعیین اینکه خروجی یک فایل اجرایی است بعلاوه مشخص سازی محل ذخیره سازی فایل نهایی
           CompilerParameters compilerParams = new CompilerParameters
           {
               OutputAssembly = "D:\\Foo.EXE",
               GenerateExecutable = true
           };

           //عملیات کامپایل در اینجا صورت می‌گیرد
           CompilerResults results = provider.CompileAssemblyFromSource(compilerParams, source);

           //اگر خطایی وجود داشته باشد نمایش داده خواهد شد
           Console.WriteLine("Number of Errors: {0}", results.Errors.Count);
           foreach (CompilerError err in results.Errors)
           {
               Console.WriteLine("ERROR {0}", err.ErrorText);
           }
       }

       static void Main(string[] args)
       {
           compileIt1();

           Console.WriteLine("Press a key...");
           Console.ReadKey();
       }
   }
}

using System;
using System.Collections.Generic;
using Microsoft.CSharp;
using System.CodeDom.Compiler;
using System.Reflection;

namespace compilerTest
{
   class Program
   {
       static void compileIt2()
       {
           //سورس کد ما جهت کامپایل
           string source =
           @"
               namespace Foo
               {
                    public class Bar
                    {
                        static void Main(string[] args)
                        {
                            Bar.SayHello();
                        }

                        public static void SayHello()
                        {
                            System.Console.WriteLine(""Hello World"");
                        }
                    }
               }
            ";

           //تعیین نگارش کامپایلر مورد استفاده
           Dictionary<string, string> providerOptions = new Dictionary<string, string>
                {
                    {"CompilerVersion", "v3.5"}
                };
           //تعیین اینکه کد ما سی شارپ است
           CSharpCodeProvider provider = new CSharpCodeProvider(providerOptions);

           //نحوه تعیین مشخص سازی کامپایل در حافظه
           CompilerParameters compilerParams = new CompilerParameters
           {
               GenerateInMemory = true,
               GenerateExecutable = false
           };

           //عملیات کامپایل در اینجا صورت می‌گیرد
           CompilerResults results = provider.CompileAssemblyFromSource(compilerParams, source);

           // اگر خطایی در کامپایل وجود نداشت متد دلخواه را فراخوانی می‌کنیم
           if (results.Errors.Count == 0)
           {
               //استفاده از ریفلکشن برای دسترسی به متد و فراخوانی آن
               Type type = results.CompiledAssembly.GetType("Foo.Bar");
               MethodInfo method = type.GetMethod("SayHello");
               method.Invoke(null, null);
           }
       }


       static void Main(string[] args)
       {
           compileIt2();

           Console.WriteLine("Press a key...");
           Console.ReadKey();
       }
   }
}

           string source =
           @"
             namespace Foo
             {
            
                 public class Bar
                 {
                     static void Main(string[] args)
                     {
                         Bar.SayHello();
                     }
            
                     public static void SayHello()
                     {
                         System.Console.WriteLine(""Hello World"");
                         var r = new System.Drawing.Rectangle(0,0,100,100);
                         System.Console.WriteLine(r);             
                     }
                 }
             }
            ";

Number of Errors: 1
ERROR The type or namespace name 'Drawing' does not exist in the namespace 'System' (are you missing an assembly reference?)

compilerParams.ReferencedAssemblies.Add("System.Drawing.Dll");