public void CheckSQLServerStat(Exception ex)
{
    try
    {
        SqlException ar = (SqlException) ex;
        switch (ar.Number)
        {
            case 2:
            case 11:
            case 17:
            case 40:
            case 4060:
            case 1326:
            case 17142:
            case 18456:
                HttpContext.Current.Response.Write("<br/>" + "اتصال با سرور اس کیوال قطع شده است. لطفا با مسئول مربوطه هماهنگ نمائید." + "<br/> SQLErr:" + ar.Number + "<br/>");
                break;
        }
    }catch{}
}

------------------------------
An exception occurred while executing a Transact-SQL statement or batch. (Microsoft.SqlServer.ConnectionInfo)
------------------------------
Database 'dbName' cannot be opened due to inaccessible files or insufficient memory or disk space.  See the SQL Server errorlog for details. (Microsoft SQL Server, Error: 945)
------------------------------

use master;
alter database dbName set OFFLINE;
alter database dbName set online;

namespace DomainEventsSample.Framework.Eventing.DomainEvents
{
    public interface IDomainEventHandler<in T> : ITransientDependency
        where T : IDomainEvent
    {
        bool IsAdvisable { get; }
        void Handle(T domainEvent);
    }
}

namespace DomainEventsSample.Framework.Domain.Events
{
    public abstract class EntityDomainEvent<TEntity> : IDomainEvent
        where TEntity : Entity
    {
        protected EntityDomainEvent(TEntity entity)
        {
            Entity = entity;
        }

        public TEntity Entity { get; }
    }
}

namespace DomainEventsSample.Framework.Domain.Events
{
    public class EntityCreatingEvent<TEntity> : EntityDomainEvent<TEntity>
        where TEntity : Entity
    {
        public EntityCreatingEvent(TEntity entity) : base(entity)
        {
        }
    }
}
namespace DomainEventsSample.Framework.Domain.Events
{
    public class EntityCreatedEvent<TEntity> : EntityDomainEvent<TEntity>
        where TEntity : Entity
    {
        public EntityCreatedEvent(TEntity entity) : base(entity)
        {
        }
    }
}

namespace DomainEventsSample.Framework.Domain.Events
{
    public class EntityEditingEvent<TEntity> : EntityDomainEvent<TEntity>
        where TEntity : Entity
    {
        public EntityEditingEvent(TEntity entity) : base(entity)
        {
        }
    }
}
namespace DomainEventsSample.Framework.Domain.Events
{
    public class EntityEditedEvent<TEntity> : EntityDomainEvent<TEntity>
        where TEntity : Entity
    {
        public EntityEditedEvent(TEntity entity) : base(entity)
        {
        }
    }
}

این رویدادها مربوط به زمان قبل و بعد از ویرایش یک Entity می‌باشند. 

namespace DomainEventsSample.Framework.Domain.Events
{
    public class EntityDeletingEvent<TEntity> : EntityDomainEvent<TEntity>
        where TEntity : Entity
    {
        public EntityDeletingEvent(TEntity entity) : base(entity)
        {
        }
    }
}
namespace DomainEventsSample.Framework.Domain.Events
{
    public class EntityDeletedEvent<TEntity> : EntityDomainEvent<TEntity>
        where TEntity : Entity
    {
        public EntityDeletedEvent(TEntity entity) : base(entity)
        {
        }
    }
}

این رویدادها مربوط به زمان قبل و بعد از حذف یک Entity می‌باشند.

namespace DomainEventsSample.Framework.Domain.Events
{
    public class EntitySavingEvent<TEntity> : EntityDomainEvent<TEntity>
        where TEntity : Entity
    {
        public EntitySavingEvent(TEntity entity) : base(entity)
        {
        }
    }
}

namespace DomainEventsSample.Framework.Domain.Events
{
    public class EntitySavedEvent<TEntity> : EntityDomainEvent<TEntity>
        where TEntity : Entity
    {
        public EntitySavedEvent(TEntity entity) : base(entity)
        {
        }
    }
}

این رویدادها مربوط به زمان قبل و بعد از ذخیره (ایجاد و ویرایش) یک Entity می‌باشند.

public class ProductCreatedEventHandler : IDomainEventHandler<EntityCreatedEvent<Product>>
{
    public bool IsAdvisable => false;

    public void Handle(EntityCreatedEvent<Product> domainEvent)
    {
        //todo: notify users
    }
}

در متد Create مربوط به ProductApplicationService و بعد از عملیات ذخیره سازی به شکل زیر می‌بایست عمل کرد:

public class ProductApplicationService : IProductApplicationService
{
    private readonly IDomainEventEngine _eventEngine;
    private readonly IUnitOfWork _unitOfWork;
    private readonly IMapper _mapper;

    public ProductApplicationService(IDomainEventEngine eventEngine,IMapper mapper,IUnitOfWork unitOfWork)
    {
        _eventEngine = eventEngine;
        _mapper=mapper;
        _unitOfWork=unitOfWork;
    }

    [Transactional]
    public void Create(ProductCreateViewModel model)
    {
         var entity=_mapper.Map<Product>(model);
        _unitOfWork.Set<Product>().Add(entity);
        _unitOfWork.SaveChanges();
        _eventEngine.Raise(new EntityCreatedEvent<Product>(entity));
    }
}

Host.CreateDefaultBuilder(args)

.ConfigureLogging(loggingBuilder  =>
{
    loggingBuilder.ClearProviders();
    loggingBuilder.AddApplicationInsights(); 
})

 {
  "inputs": [
    {
      "type": "ApplicationInsights"
    }
  ],
  "outputs": [
    {
      "type": "StdOutput" // console output
    }
  ],
  "schemaVersion": "2016-08-11"
}  

using (var pipeline = DiagnosticPipelineFactory.CreatePipeline("eventFlowConfig.json"))
{
    CreateHostBuilder(args, pipeline)
        .Build()
        .Run();
}  

public static IHostBuilder CreateHostBuilder(string[] args, DiagnosticPipeline pipeline) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureServices(services => services.AddSingleton<ITelemetryProcessorFactory>(sp => new EventFlowTelemetryProcessorFactory(pipeline)))
        .ConfigureLogging(logginBuilder =>
        {
            logginBuilder.ClearProviders();
            loggingBuilder.AddApplicationInsights(); 
        })
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });  

Unrecognised method call: System.String:Boolean StartsWith(System.String)
Unrecognised method call: System.String:Boolean Contains(System.String)

using NHibernate.Validator.Constraints;

namespace NH3Test.MappingDefinitions.Domain
{
  public class Account
  {
      public virtual int Id { get; set; }

      [NotNullNotEmpty]
      [Length(Min = 3, Max = 120, Message = "طول نام باید بین 3 و 120 کاراکتر باشد")]
      public virtual string Name { get; set; }

      [NotNull]
      public virtual int Balance { set; get; }
  }
}

var list = new[]  { 12,10};
var resultList = session.QueryOver<Account>()
                               .WhereRestrictionOn(p => p.Balance)
                               .IsIn(list)
                               .List();

SELECT
      this_.AccountId as AccountId0_0_,
      this_.Name as Name0_0_,
      this_.Balance as Balance0_0_
  FROM
      Accounts this_
  WHERE
      this_.Balance in (
          @p0 /* = 10 */, @p1 /* = 12 */
      )

var accountsContianX = session.QueryOver<Account>()
                                           .WhereRestrictionOn(x => x.Name)
                                           .IsLike("X", NHibernate.Criterion.MatchMode.Anywhere)
                                           .List();

SELECT
      this_.AccountId as AccountId0_0_,
      this_.Name as Name0_0_,
      this_.Balance as Balance0_0_
  FROM
      Accounts this_
  WHERE
      this_.Name like @p0 /* = %X% */

using NHibernate.Criterion;
...
var accountsContianX = session.QueryOver<Account>()
                                           .Where(x => x.Name.IsLike("%X%"))
                                           .List();

using System;
using System.Linq.Expressions;
using NHibernate;
using NHibernate.Criterion;
using NHibernate.Impl;

namespace NH3Test.ConsoleApplication
{
  public static class MyQueryOverExts
  {
      public static bool YearIs(this DateTime projection, int year)
      {
          throw new Exception("Not to be used directly - use inside QueryOver expression");
      }

      public static ICriterion ProcessAnsiYear(MethodCallExpression methodCallExpression)
      {
          string property = ExpressionProcessor.FindMemberExpression(methodCallExpression.Arguments[0]);
          object value = ExpressionProcessor.FindValue(methodCallExpression.Arguments[1]);
          return Restrictions.Eq(
              Projections.SqlFunction("year", NHibernateUtil.DateTime, Projections.Property(property)),
              value);
      }
  }

  public class QueryOverExtsRegistry
  {
      public static void RegistrMyQueryOverExts()
      {
          ExpressionProcessor.RegisterCustomMethodCall(
              () => MyQueryOverExts.YearIs(DateTime.Now, 0),
              MyQueryOverExts.ProcessAnsiYear);
      }
  }
}

QueryOverExtsRegistry.RegistrMyQueryOverExts(); //یکبار در ابتدای اجرای برنامه باید ثبت شود
...
var data = session.QueryOver<Account>()
                                     .Where(x => x.AddDate.YearIs(2010))
                                     .List();

SELECT
      this_.AccountId as AccountId0_0_,
      this_.Name as Name0_0_,
      this_.Balance as Balance0_0_,
      this_.AddDate as AddDate0_0_
  FROM
      Accounts this_
  WHERE
      strftime("%Y", this_.AddDate) = @p0 /* =2010 */

    public abstract class LongPollingAsyncResult<TResult> : IAsyncResult where TResult : class
    {
        #region - Fields -

        private AsyncCallback _callback;
        private TimeSpan _timoutSpan;
        private TimeSpan _intervalWaitSpan;

        #endregion

        #region - Properties -
        public Exception Exception { get; private set; }
    
        public TResult Result { get; private set; }
     
        public object SyncRoot { get; private set; }

        #endregion

        #region - Ctor -
      
        public LongPollingAsyncResult(AsyncCallback callback, object asyncState, int timeoutSeconds = 300, int intervalWaitMilliseconds = 500)
        {
            SyncRoot = new object();
            _callback = callback;
            AsyncState = asyncState;
            AsyncWaitHandle = new ManualResetEvent(IsCompleted);
            _timoutSpan = TimeSpan.FromSeconds(timeoutSeconds);
            _intervalWaitSpan = TimeSpan.FromMilliseconds(intervalWaitMilliseconds);

            ThreadPool.QueueUserWorkItem(new WaitCallback(LoopWithIntervalAndTimeout));
        }

        #endregion

        #region - Private Helper Methods -

        private void LoopWithIntervalAndTimeout(object input)
        {
            try
            {
                Stopwatch stopwatch = new Stopwatch();
                stopwatch.Start();
                while (!IsCompleted)
                {
                    if (stopwatch.Elapsed > _timoutSpan)
                        throw new TimeoutException();
                    
                    DoWork();

                    if (!IsCompleted)
                        Thread.Sleep(_intervalWaitSpan);
                }
            }
            catch (Exception e)
            {
                Complete(null, e);
            }
        }

        #endregion

        #region - Protected/Abstract Methods -
        protected void Complete(TResult result, Exception e = null, bool completedSynchronously = false)
        {
            lock (SyncRoot)
            {
                CompletedSynchronously = completedSynchronously;
                Result = result;
                Exception = e;
                IsCompleted = true;

                if (_callback != null)
                    _callback(this);
            }
        }
       
        protected abstract void DoWork();

        #endregion

        #region - Public Methods -
        
        public TResult WaitForResult()
        {
            if (!IsCompleted)
                AsyncWaitHandle.WaitOne();

            if (Exception != null)
            {
                if (Exception is TimeoutException && WebOperationContext.Current != null)
                    WebOperationContext.Current.OutgoingResponse.StatusCode = HttpStatusCode.RequestTimeout;

                throw Exception;
            }

            return Result;
        }

        #endregion

        #region - IAsyncResult Implementation -

        public object AsyncState { get; private set; }
        
        public WaitHandle AsyncWaitHandle { get; private set; }

        public bool CompletedSynchronously { get; private set; }
       
        public bool IsCompleted { get; private set; }

        #endregion
    }

[OperationContract]
public string GetNotification();

[OperationContract(AsyncPattern = true)]
public IAsyncResult BeginWaitNotification(AsyncCallback callback, object state);
 
public string EndWaitNotification(IAsyncResult result);

public class MyNotificationResult : LongPollingAsyncResult<string>
{
   protected override DoWork()
    {
        کد‌های مورد نظر را اینجا قرار دهید
        base.Complete(...)
    }
}

public IAsyncResult BeginWaitNotification(AsyncCallback callback, object state)
{
    return new MyNotificationResult(callback, state);
}
 
public string EndWaitNotification(IAsyncResult result)
{
    MyNotificationResult myResult = result as MyNotificationResult;
    if(myResult == null)
        throw new ArgumentException("result was of the wrong type!");
 
    myResult.WaitForResult();
    return myResult.Result;
}

try
            {
               var application = (Microsoft.Office.Interop.Excel.Application)Activator.CreateInstance(Type.GetTypeFromProgID("Excel.Application"));  
               Workbook  wrkBook;
                var  wbk = application.Workbooks;
                 wrkBook = wbk.Add();
                wrkBook.Activate();
                application.Visible = true;
             }
            catch (Exception ex)
            {
                Error(ex.Message);
            }

            string strEVersionSubKey = "\\Excel.Application\\CurVer";       
            string strValue = null; //Value Present In Above Key
            string strVersion = null; //Determines Excel Version 
            RegistryKey rkVersion = null; //Registry Key To Determine Excel Version 
            rkVersion = Registry.ClassesRoot.OpenSubKey(strEVersionSubKey, false); //Open Registry Key 
            if ((rkVersion != null)) //If Key Exists
            {
                strValue = (string)rkVersion.GetValue(string.Empty); //Get Value 
                strValue = strValue.Substring(strValue.LastIndexOf(".") + 1); //Store Value 
                switch (strValue) //Determine Version
                {
                    case "11":
                        strVersion = "2003";
                        break;
 
                    case "12":
                        strVersion = "2007";
                        break;
 
                    case "14":
                        strVersion = "2010";
                        break;
 
                }

if (strVersion == "2007")
                {
                    string strAssemblyOff2007 =
                        "Microsoft.Office.Interop.Excel, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c";
                    try
                    {
                        Assembly xslExcelAssembly = Assembly.Load(strAssemblyOff2007); //Load Assembly
                        Type type = xslExcelAssembly.GetTypes().Single(t => t.Name == "ApplicationClass");
                        dynamic application = Activator.CreateInstance(type);
                        var workbooks = application.Workbooks;
                        var workbook = workbooks.Add();
                        var worksheet = workbook.Worksheets[1];
                        workbook.Activate();
                        application.Visible = true;
                    }
                    catch (Exception ex)
                    {
                    }
                }

using System.Data;
using System.Data.Objects;
using System.Linq;
using System.Reflection;

namespace EfExt
{
   public static class CorrectYeKe
   {
       public static void ApplyCorrectYeKe(this ObjectContext ctx)
       {
           if (ctx == null)
               return;

           //پیدا کردن موجودیت‌های تغییر کرده
           var changedEntities = ctx.ObjectStateManager.GetObjectStateEntries(
               EntityState.Added | EntityState.Modified
               );

           foreach (var entity in changedEntities)
           {
               if (entity.Entity == null) continue;

               //یافتن خواص قابل تنظیم و رشته‌ای این موجودیت‌ها
               var propertyInfos = entity.Entity.GetType().GetProperties(
                   BindingFlags.Public | BindingFlags.Instance
                   ).Where(p => p.CanRead && p.CanWrite && p.PropertyType == typeof(string));

               var pr = new PropertyReflector();

               //اعمال یکپارچگی نهایی
               foreach (var propertyInfo in propertyInfos)
               {
                   var propName = propertyInfo.Name;
                   var val = pr.GetValue(entity.Entity, propName);
                   if (val != null)
                   {
                       pr.SetValue(
                           entity.Entity,
                           propName,
                           val.ToString().ApplyUnifiedYeKe());
                   }
               }
           }
       }
   }
}

["Adventure Works","Contoso"] 

a) AjaxHelper 
b) XDocument 
c) JsonResult
d) DataContractJsonSerializer

a) Use the Html.RenderPartial extension method
b) Use the Html.RenderAction extension method
c) Use the PartialViewResult class
d) Use the ContentResult class

public class Player
{
   public String Name { get; set; }
   public int LastScore { get; set; }
   public int HighScore { get; set; }
}

[UIHint("Score")]

[Display(Name="LastScore", ShortName="Score")]

a) [Authorize(Users = "")]
b) [Authorize(Roles = "")]
c) [Authorize(Users = "*")]
d) [Authorize(Roles = "*")]

<span id="ref">
<a name=Reference>Check out</a>
the FAQ on
<a href="http://www.contoso.com">
Contoso</a>'s web site for more information:
<a href="http://www.contoso.com/faq">FAQ</a>.
</span>
<a href="http://www.contoso.com/home">Home</a>

a) $("#ref").filter("a[href]").bold();
b) $("ref").filter("a").css("bold");
c) $("a").css({fontWeight:"bold"});
d) $("#ref a[href]").css({fontWeight:"bold"});