private sealed class ExtraPropertyCustomTypeDescriptor : CustomTypeDescriptor
{
    private readonly IEnumerable<ExtraPropertyDescriptor<T>> _instanceExtraProperties;

    public ExtraPropertyCustomTypeDescriptor(ICustomTypeDescriptor defaultDescriptor, object instance)
        : base(defaultDescriptor)
    {
        _instanceExtraProperties = instance.ExtraPropertyList<T>();
    }

    public override PropertyDescriptorCollection GetProperties(Attribute[] attributes)
    {
        var properties = new PropertyDescriptorCollection(null);

        foreach (PropertyDescriptor property in base.GetProperties(attributes))
        {
            properties.Add(property);
        }

        foreach (var property in _instanceExtraProperties)
        {
            properties.Add(property);
        }

        return properties;
    }

    public override PropertyDescriptorCollection GetProperties()
    {
        return GetProperties(null);
    }
}

public static class ExtraProperties
{
    //...

    public static IEnumerable<ExtraPropertyDescriptor<T>> ExtraPropertyList<T>(this object instance) where T : class
    {
        if (!PropertyCache.TryGetValue(instance, out var properties))
            throw new KeyNotFoundException($"key: {instance.GetType().Name} was not found in dictionary");

        return properties.Select(p =>
            new ExtraPropertyDescriptor<T>(p.PropertyName, p.PropertyValueFunc, p.SetPropertyValueFunc,
                p.PropertyType,
                p.Attributes));
    }
}

public sealed class ExtraPropertyDescriptor<T> : PropertyDescriptor where T : class
{
    private readonly Func<object, object> _propertyValueFunc;
    private readonly Action<object, object> _setPropertyValueFunc;
    private readonly Type _propertyType;

    public ExtraPropertyDescriptor(
        string propertyName,
        Func<object, object> propertyValueFunc,
        Action<object, object> setPropertyValueFunc,
        Type propertyType,
        Attribute[] attributes) : base(propertyName, attributes)
    {
        _propertyValueFunc = propertyValueFunc;
        _setPropertyValueFunc = setPropertyValueFunc;
        _propertyType = propertyType;
    }

    public override void ResetValue(object component)
    {
    }

    public override bool CanResetValue(object component) => true;

    public override object GetValue(object component) => _propertyValueFunc(component);

    public override void SetValue(object component, object value) => _setPropertyValueFunc(component, value);

    public override bool ShouldSerializeValue(object component) => true;
    public override Type ComponentType => typeof(T);
    public override bool IsReadOnly => _setPropertyValueFunc == null;
    public override Type PropertyType => _propertyType;
}

[TypeDescriptionProvider(typeof(ExtraPropertyTypeDescriptionProvider<Person>))]
private class Person
{
    public string Name { get; set; }
    public string Family { get; set; }
}

[Test]
public void Should_TypeDescriptor_GetProperties_Returns_ExtraProperties_And_PredefinedProperties()
{
    //Arrange
    var rabbal = new Person {Name = "GholamReza", Family = "Rabbal"};
    const string propertyName = "Title";
    const string propertyValue = "Software Engineer";

    //Act
    rabbal.ExtraProperty(propertyName, propertyValue);
    var title = TypeDescriptor.GetProperties(rabbal).Find(propertyName, true);

    //Assert
    rabbal.ExtraProperty<string>(propertyName).ShouldBe(propertyValue);
    title.ShouldNotBeNull();
    title.GetValue(rabbal).ShouldBe(propertyValue);
}

namespace NHSample3.Domain
{
  public class Car
  {
      public virtual int Id { get; set; }
      public virtual string Name { get; set; }
      public virtual string Color { get; set; }
  }
}

using System.Collections.Generic;

namespace NHSample3.Domain
{
  public class Parking
  {
      public virtual int Id { get; set; }
      public virtual string Name { get; set; }
      public virtual string Location { get; set; }
      public virtual IList<Car> Cars { get; set; }

      public Parking()
      {
          Cars = new List<Car>();
      }
  }
}

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

namespace NHSessionManager
{
  public class Config
  {
      public static FluentConfiguration GetConfig()
      {
          return
            Fluently.Configure()
                    .Database(
                       MsSqlConfiguration
                         .MsSql2008
                         .ConnectionString(x => x.FromConnectionStringWithKey("DbConnectionString"))                         
                        )
                      .ExposeConfiguration(
                           x => x.SetProperty("current_session_context_class", "managed_web")
                       )
                      .Mappings(
                        m => m.AutoMappings.Add(
                           new AutoPersistenceModel()
                               .Where(x => x.Namespace.EndsWith("Domain"))                               
                               .AddEntityAssembly(typeof(NHSample3.Domain.Car).Assembly))
                               );
      }

      public static void CreateDb()
      {
          bool script = false;//آیا خروجی در کنسول هم نمایش داده شود
          bool export = true;//آیا بر روی دیتابیس هم اجرا شود            
          bool dropTables = false;//آیا جداول موجود دراپ شوند
          new SchemaExport(GetConfig().BuildConfiguration()).Execute(script, export, dropTables);
      }
  }
}

<connectionStrings>
  <!--NHSessionManager-->
  <add name="DbConnectionString"
         connectionString="Data Source=(local);Initial Catalog=HelloNHibernate;Integrated Security = true" />
</connectionStrings>

using NHibernate;

namespace NHSessionManager
{
  /// <summary>
  /// lazy, lock-free, thread-safe singleton
  /// </summary>
  public class SingletonCore
  {
      private readonly ISessionFactory _sessionFactory;

      SingletonCore()
      {
          _sessionFactory = Config.GetConfig().BuildSessionFactory();
      }

      public static SingletonCore Instance
      {
          get
          {
              return Nested.instance;
          }
      }

      public static ISession GetCurrentSession()
      {
          return Instance._sessionFactory.GetCurrentSession();
      }

      public static ISessionFactory SessionFactory
      {
          get { return Instance._sessionFactory; }
      }

      class Nested
      {
          // Explicit static constructor to tell C# compiler
          // not to mark type as beforefieldinit
          static Nested()
          {
          }

          internal static readonly SingletonCore instance = new SingletonCore();
      }
  }
}

using System;
using System.Web;
using NHibernate;
using NHibernate.Context;

namespace NHSessionManager
{
  public class SessionModule : IHttpModule
  {
      public void Dispose()
      { }

      public void Init(HttpApplication context)
      {
          if (context == null)
              throw new ArgumentNullException("context");

          context.BeginRequest += Application_BeginRequest;
          context.EndRequest += Application_EndRequest;
      }

      private void Application_BeginRequest(object sender, EventArgs e)
      {
          ISession session = SingletonCore.SessionFactory.OpenSession();
          ManagedWebSessionContext.Bind(HttpContext.Current, session);
          session.BeginTransaction();
      }

      private void Application_EndRequest(object sender, EventArgs e)
      {
          ISession session = ManagedWebSessionContext.Unbind(
              HttpContext.Current, SingletonCore.SessionFactory);
          if (session == null) return;

          try
          {
              if (session.Transaction != null &&
                  !session.Transaction.WasCommitted &&
                  !session.Transaction.WasRolledBack)
              {
                  session.Transaction.Commit();
              }
              else
              {
                  session.Flush();
              }
          }
          catch (Exception)
          {
              session.Transaction.Rollback();
          }
          finally
          {
              if (session != null && session.IsOpen)
              {
                  session.Close();
                  session.Dispose();
              }
          }
      }
  }
}

  <httpModules>
    <!--NHSessionManager-->
    <add name="SessionModule" type="NHSessionManager.SessionModule"/>
  </httpModules>

using System.Linq;
using NHibernate;
using NHibernate.Linq;
using NHSample3.Domain;

namespace NHSample3
{
  public class ParkingContext : NHibernateContext
  {
      public ParkingContext(ISession session)
          : base(session)
      { }

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

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

using System;
using System.Collections.Generic;
using System.Linq;
using NHibernate;
using NHSample3.Domain;
using NHSessionManager;

namespace NHSample3
{
  public partial class _Default : System.Web.UI.Page
  {
      protected void Page_Load(object sender, EventArgs e)
      {
          //ایجاد دیتابیس در صورت نیاز
          //Config.CreateDb();

          //ثبت یک سری رکورد در دیتابیس
          ISession session = SingletonCore.GetCurrentSession();

          Car car1 = new Car() { Name = "رنو", Color = "مشکلی" };
          session.Save(car1);
          Car car2 = new Car() { Name = "پژو", Color = "سفید" };
          session.Save(car2);

          Parking parking1 = new Parking()
          {
              Location = "آدرس پارکینگ مورد نظر",
              Name = "پارکینگ یک",
              Cars = new List<Car> { car1, car2 }
          };

          session.Save(parking1);

          //نمایش حاصل در یک گرید ویوو
          ParkingContext db = new ParkingContext(session);
          var query = from x in db.Cars select new { CarName = x.Name, CarColor = x.Color };
          GridView1.DataSource = query.ToList();
          GridView1.DataBind();
      }
  }
}

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

public class Student
{
    public int Id { set; get; }
    public string Name { set; get; }

    //هر دانشجو چند ترم در دانشگاه خواهد بود
    public virtual ICollection<Semester> Semesters { set; get; }
    //هر دانشجو چندین واحد دارد
    public virtual ICollection<Unit> Units { set; get; }
}

public class Semester
{
    public int Id { set; get; }
    public string Name { set; get; }
    public int Average { set; get; }

    [ForeignKey("StudentId")]
    public virtual Student Student { set; get; }
    public int StudentId { set; get; }
}

public class Unit
{
    public int Id { set; get; }
    public string Name { set; get; }
    public string UnitType { set; get; }
    public int NumberOfUnits { set; get; }

    [ForeignKey("StudentId")]
    public virtual Student Student { set; get; }
    public int StudentId { set; get; }
}

FirstName

firstName

strFirstName
lblFirstName

<Company>.<Technology|Produt|Project>[.<Feature>][.<SubNamespace>]

Microsoft.Reporting.WebForms
Kara.Support.Manager.Enums
Kara.CSS.HQ.WebUI.Configuration

PackageManager , PacakgeConfigGenerator
Circle , Utility , Package

CreateConfig , classdata
CManager , ClsPackage , Config_Creator , Config1389

CenterCollection , PackageCollection

public delegate void Logger (string log);
public delegate void LoggingCallback (object sender, string reason);

AddEventArgs , EditEventArgs , DeleteEventArgs

Adding , Add , Added

public delegate void <EventName>EventHandler  (object sender, <EventName>EventArgs e);

public event EventHandler <AddEventArgs> Adding;

DisplayNameAttribute , MessageTypeAttribute

IComponent  (اسم)
IConnectionProvider (موصوف)
ICloneable (صفت)

public enum FileMode {
    Append,
    Read, …
}

[Flag]
public enum KeyModifiers {
    Alt = 1, 
    Control = 2,
    Shift = 4
}

public enum OperationState {
    DoneState, 
    FaultState,
    RollbackState
}

AddDays , Save , DeleteRow , BindData , Close , Open

Radius , ReportType , DataSource , Mode , CurrentCenterId

public CenterCollection Centers { get; set; }

if (list.Contains(item))
if (regularExpression.Matches(text))
if (stream.CanSeek)
if (context.Created)
if (form.Enabled)

if (list.IsContains(item))
if (regularExpression.Match(text))
if (stream.Seekable)
if (context.IsCreated)
if (form.IsEnabled)

public Color Color { get; set; }

firstName , e , id , packageId , centerName , name

public static MyType operator +(MyType left, MyType right)
public static bool operator ==(MyType left, MyType right)

public static MyType operator ++(MyType value)

public static MyType operator /(MyType dividend, MyType divisor)

public static MyType operator -(MyType d1, MyType d2) // incorrect!

Area , DataBinder , PublicCacheName

_centersList
_firstName
_currentCenter

parameterType , packageOperationTypeId

lblName (Label)
txtHeader (TextBox)
btnSave (Button)

ArgumentNullException , InvalidOperaionException

System.Data

<Company>.<Component>.dll
<Company>.<Project|Product|Technology>.<Component>.dll

Microsoft.CSharp.dll , Kara.CSS.Manager.dll

public int IComparer<T> {…}
public delegate bool Predicate<T> (T item)

public int ISessionChannel<TSession> {…}
public delegate TOutput Converter<TInput, TOutput> (TInput from)
public class Nullable<T> {…}
public class List<T> {…}

ArgumentExceptionIllegalCharacters
ArgumentExceptionInvalidName
ArgumentExceptionFileNotFound

public class Color {
    …
    public static Color FromArgb(…)
    { … }
}

پوشه Contracts شامل واسط‌های مورد نیاز برای repository logic می‌باشد:

namespace ASPCoreGraphQL.Contracts
{
    public interface IOwnerRepository
    {
    }
}

namespace ASPCoreGraphQL.Contracts
{
    public interface IAccountRepository
    {
    }
}

return-type method-name<type-parameters>(parameters)

public T1 PrintValue<T1, T2>(T1 param1, T2 param2)
{
    Console.WriteLine("values are: parameter 1 = " + param1 + " and parameter 2 = " + param2);

    return param1;
}

public void MyMethod< T >()
       where T : struct
{
  ...
}

interface I {}
class J<T>
  where T : class, I

interface I {}
class J<T, U>
  where T : class, I
  where U : I, new() {}

//this method returns if both the parameters are equal 
public static bool Equals< T > (T t1, Tt2) 
{ 
  return (t1 == t2); 
}

class Program
{
    public static void Main(string[] args)
    {
        DebuggerStepThroughMethod1();
    }

    [DebuggerStepThrough]
    public static void DebuggerStepThroughMethod1()
    {
        Console.WriteLine( "Method 1" );
        DebuggerStepThroughMethod2();
    }

    [DebuggerStepThrough]
    public static void DebuggerStepThroughMethod2()
    {
        Console.WriteLine( "Method 2" );
    }
}

class Program
{
    public static void Main(string[] args)
    {
        DebugMode();
    }

    [Conditional("DEBUG")]
    public static void DebugMode()
    {
        Console.WriteLine( "Debug mode" );
    }
}

app.controller(‘ThingController’, [ ‘$scope’, function($scope) {
   $scope.thingOne = ‘one’;
   $scope.thingTwo = ‘two’;
   $scope.getThings = function() { 
       return $scope.thingOne + ‘ ‘ + $scope.thingTwo; 
   };
}]);

app.controller(‘ThingController’, [ ‘$scope’, function($scope) {
    angular.extend($scope, {
        thingOne: ‘one’,
        thingTwo: ‘two’,
        getThings: function() { 
            return $scope.thingOne + ‘ ‘ + $scope.thingTwo; 
        }
    });
}]);

app.controller(‘ThingController’, [ ‘$scope’, function($scope) {
    // models
    angular.extend($scope, {
        thingOne: ‘one’,
        thingTwo: ‘two’
    });

    // methods
    angular.extend($scope, {
      // in HTML template, something like {{ getThings() }}
       getThings: function() { 
            return $scope.thingOne + ‘ ‘ + $scope.thingTwo; 
        }
    });
}]);

app.controller(‘ThingController’, [ ‘$scope’, function($scope) {
    // private
    var _thingOne = ‘one’,
        _thingTwo = ‘two’;

    // models
    angular.extend($scope, {
        get thingOne() {
        return _thingOne;
        },
        set thingOne(value) {
           if (value !== ‘one’ && value !== ‘two’) {
             throw new Error(‘Invalid value (‘+value+‘) for thingOne’);
        },
        get thingTwo() {
        return _thingTwo;
        },
        set thingTwo(value) {
           if (value !== ‘two’ && value !== ‘three’) {
             throw new Error(‘Invalid value (‘+value+‘) for thingTwo’);
        }
   });

    // methods
    angular.extend($scope, {
       // in HTML template, something like {{ things }}
       get things() { 
            return _thingOne + ‘ ‘ + _thingTwo; 
        }
    });
}]);