namespace Decision.DomainClasses.Entities
{
   

    /// <summary>
    /// انوع استعلام
    /// </summary>
    public class ResearchType:BaseEntity
    {
      

        /// <summary>
        /// نوع استعلام
        /// </summary>
        public int Title { get; set; }

        /// <summary>
        /// وضعیت نمایش
        /// </summary>
        public bool  IsActive { get; set; }


    }
    }

class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }

public override int GetHashCode() => HashCode.Combine(FirstName, LastName);
}

public class EditEmployeeModel 
{
    public string Email { get; set; }

    [CompareProperty("Email", 
        ErrorMessage = "Email and Confirm Email must match")]
    public string ConfirmEmail { get; set; }
}

public class ApiDependencyResolver : IDependencyResolver
    {
        public ApiDependencyResolver(IWindsorContainer container)
        {
            Container = container;
        }

        public IWindsorContainer Container
        {
            get;
            private set;
        }

        public object GetService(Type serviceType)
        {
            try
            {
                return Container.Kernel.HasComponent(serviceType) ? Container.Resolve(serviceType) : null;
            }
            catch (Kernel.ComponentNotFoundException)
            {
                return null;
            }
        }

        public IEnumerable<object> GetServices(Type serviceType)
        {
            try
            {
                return Container.ResolveAll(serviceType).Cast<object>();
            }
            catch (Kernel.ComponentNotFoundException)
            {
                return Enumerable.Empty<object>();
            }
        }
        public IDependencyScope BeginScope()
        {
            return new SharedDependencyResolver(Container);
        }

        public void Dispose()
        {
            Container.Dispose();
        }
    }

    public class SharedDependencyResolver : IDependencyScope
    {
        public SharedDependencyResolver(IWindsorContainer container)
        {
            Container = container;
            Scope = Container.BeginScope();
        }

        public IWindsorContainer Container
        {
            get;
            private set;
        }

        public IDisposable Scope
        {
            get;
            private set;
        }

        public object GetService(Type serviceType)
        {
            try
            {
                return Container.Kernel.HasComponent(serviceType) ? Container.Resolve(serviceType) : null;
            }
            catch (ComponentNotFoundException)
            {
                return null;
            }
        }

        public IEnumerable<object> GetServices(Type serviceType)
        {
            try
            {
                return Container.ResolveAll(serviceType).Cast<object>();
            }
            catch (ComponentNotFoundException)
            {
                return null;
            }
        }

        public void Dispose()
        {
            Scope.Dispose();
        }
    }

public IDependencyScope BeginScope()
{
    var child = container.CreateChildContainer();
    return new ApiDependencyResolver(child);
}

public class KernelInstaller : IWindsorInstaller
    {
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {          
           container.Register(Classes.FromThisAssembly().BasedOn<ApiController>().LifestyleTransient());         
            container.Kernel.Resolver.AddSubResolver(new CollectionResolver(container.Kernel, true));
        }
    }

public class Startup
    {
        public void Configuration( IAppBuilder appBuilder )
        {
           var container = new WindsorContainer();
            container.Install(new KernelInstaller());

            var config = new HttpConfiguration
            {
                 DependencyResolver = new ApiDependencyResolver(container)
            };                  

            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "Default" ,
                routeTemplate: "{controller}/{action}/{name}" ,
                defaults: new { name = RouteParameter.Optional }                
            );

            config.EnsureInitialized();          
         
            appBuilder.UseWebApi( config );
        }
    }

  [Moon.Web.Validation.RemoteValidator("IsUserExist", "Admin", HttpMethod = "POST", ErrorMessage = "نام کاربری قبلا ثبت شده است.")]
        public string Username { get; set; }

  @Html.EditorFor(model => model.Username)
  @Html.ValidationMessageFor(model => model.Username)

  [HttpPost]
        public ActionResult IsUserExist(string Username)
        {
            if (userSerive.isUser(Username)) return Json(true); 
            return Json(false);
        }

//StaticCache .cs
using System;
using System.Web;

namespace StaticContentCacheModule
{
   public class StaticCache : IHttpModule
   {
       public void Init(HttpApplication context)
       {
           context.PreSendRequestHeaders += context_PreSendRequestHeaders;
       }

       static void context_PreSendRequestHeaders(object sender, EventArgs e)
       {
           //capture the current Response 
           var currentResponse = ((HttpApplication)sender).Response;

           if (CacheManager.ShouldCache(currentResponse.ContentType))
           {
               currentResponse.AddHeader("cache-control", "public");
               currentResponse.AddHeader("Expires", DateTime.Now.Add(TimeSpan.FromDays(30)).ToString());
           }
       }

       public void Dispose() { }
   }
}

//CacheManager.cs
using System;

namespace StaticContentCacheModule
{
   class CacheManager
   {
       public static bool ShouldCache(string contentType)
       {
           contentType = contentType.ToLower();
           string[] parts =
               contentType.Split(
                   new[] { ';' },
                   StringSplitOptions.RemoveEmptyEntries
               );

           if (parts.Length > 0)
               contentType = parts[0];

           bool cache = false;

           switch (contentType)
           {
               case "text/css":
                   cache = true; break;
               case "text/javascript":
               case "text/jscript":
                   cache = true; break;
               case "image/jpeg":
                   cache = true; break;
               case "image/gif":
                   cache = true; break;
               case "application/octet-stream":
                   cache = true; break;
               default:
                   {
                       if (contentType.Contains("javascript"))
                           cache = true;
                       if (contentType.Contains("css"))
                           cache = true;
                       if (contentType.Contains("image"))
                           cache = true;
                       if (contentType.Contains("application"))
                           cache = true;
                   }
                   break;
           }

           return cache;
       }
   }
}

<httpModules>
     <add name="StaticContentCacheModule" type="StaticContentCacheModule.StaticCache, StaticContentCacheModule"/>
</httpModules>

<system.webServer>
<modules>
  <add name="StaticContentCacheModule" type="StaticContentCacheModule.StaticCache, StaticContentCacheModule"/>
</modules>

<property name="Text" lazy="true"/>

public class Post
{
       public virtual int Id { set; get; }
       public virtual string PostText { set; get; }
}

public class PostMappings : ClassMap<Post>
{
       public PostMappings()
       {           
           Id(p => p.Id, "PostId").GeneratedBy.Identity();
           Map(p => p.PostText).LazyLoad();
           //…
           Table("Posts");
       }
}

<property name="PostText" type="System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" lazy="true" />