//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>

 public class MyModel
    {
        public Person person { get; set; }
        public string Type{ get; set; }
    }
 public class Person 
   {
    Public string FirstName{get;set;}
    public string LastName{get;set;}
   }

@model myModel

@{
    ViewBag.Title = "View3";

}

<h2>View3</h2>


@using (Ajax.BeginForm() {

<section class="Simple Page">

       <div class="row-fluid">
            @Html.LabelFor(model => model.Type, new { @class = "span3" })

       <div class="input-control text span4">

            @Html.EditorFor(model => model.Type, new { @class = "span4 ", placeholder = Html.Encode("ResorceName") })
           </div>

        </div>

    </section>
}

 public class DiskSmtpClient : SmtpClient
    {
        public DiskSmtpClient(IOptionsSnapshot<MailKitOptions> mailOptionsSnapshot)
        {
            if (mailOptionsSnapshot.Value.SpecifiedPickupDirectory)
            {
                SpecifiedPickupDirectory = true;
                PickupDirectoryLocation = mailOptionsSnapshot.Value.PickupDirectoryLocation;
            }
            
        }
        public bool SpecifiedPickupDirectory { get; set; }
        public string PickupDirectoryLocation { get; set; }

        public override Task SendAsync(MimeMessage message, CancellationToken cancellationToken = new CancellationToken(),
            ITransferProgress progress = null)
        {
            if (!SpecifiedPickupDirectory)
                return base.SendAsync(message, cancellationToken, progress);
            return SaveToPickupDirectory(message, PickupDirectoryLocation);

        }

    



        private async Task SaveToPickupDirectory(MimeMessage message, string pickupDirectory)
        {
            using (var stream = new FileStream($@"{pickupDirectory}\email-{Guid.NewGuid().ToString("N")}.eml", FileMode.CreateNew))
            {
                await message.WriteToAsync(stream);
            }
        }

       

        public override Task ConnectAsync(string host, int port = 0, SecureSocketOptions options = SecureSocketOptions.Auto,
            CancellationToken cancellationToken = new CancellationToken())
        {
            if (!SpecifiedPickupDirectory)
                return base.ConnectAsync(host, port, options, cancellationToken);
            return Task.CompletedTask;
        }



        public override Task DisconnectAsync(bool quit, CancellationToken cancellationToken = new CancellationToken())
        {
            if (!SpecifiedPickupDirectory)
                return base.DisconnectAsync(quit, cancellationToken);

            return Task.CompletedTask;
        }
    }

 services.AddTransient<DiskSmtpClient>();

  var email = "mail@dotnettips.info";
            var subject = "subject";
            var message = "message";

            var emailMessage = new MimeMessage();

            emailMessage.From.Add(new MailboxAddress("DNT", "do-not-reply@dotnettips.info"));
            emailMessage.To.Add(new MailboxAddress("", email));
            emailMessage.Subject = subject;
            emailMessage.Body = new TextPart(TextFormat.Html)
            {
                Text = message
            };

            
                _client.SpecifiedPickupDirectory = true;
                _client.PickupDirectoryLocation = "c:\\mail";

                _client.LocalDomain = "dotnettips.info";
                await _client.ConnectAsync("smtp.relay.uri", 25, SecureSocketOptions.None).ConfigureAwait(false);
                await _client.SendAsync(emailMessage).ConfigureAwait(false);
                await _client.DisconnectAsync(true).ConfigureAwait(false);

services.Configure<MailKitOptions>(options => Configuration.GetSection("MailKitOptions").Bind(options));

  "MailKitOptions": {
    "SpecifiedPickupDirectory": true,
    "PickupDirectoryLocation": "c:\\mail"
  }

    public class MailKitOptions
    {
        public  bool SpecifiedPickupDirectory { get; set; }
        public  string PickupDirectoryLocation { get; set; }
    }

using System;
using System.Collections.Specialized;
using System.Reflection;
using System.Text.RegularExpressions;
using System.Web;
using Microsoft.Security.Application;


namespace AntiXssMdl
{
  public class AntiXssModule : IHttpModule
  {
      private static readonly Regex _cleanAllTags = new Regex("<[^>]+>", RegexOptions.Compiled);
      public void Init(HttpApplication context)
      {
          context.BeginRequest += CleanUpInput;
      }


      public void Dispose()
      { }


      private static void CleanUpInput(object sender, EventArgs e)
      {
          HttpRequest request = ((HttpApplication)sender).Request;
          if (request.QueryString.Count > 0)
          {
              //تمیزکاری مقادیر کلیه کوئری استرینگ‌ها پیش از استفاده در برنامه
              CleanUpAndEncode(request.QueryString, allowHtmltags: false);
          }


          if (request.HttpMethod == "POST")
          {
              //تمیزکاری کلیه مقادیر ارسالی به سرور
              if (request.Form.Count > 0)
              {
                  CleanUpAndEncode(request.Form, allowHtmltags: true);
              }
          }
      }


      private static void CleanUpAndEncode(NameValueCollection collection, bool allowHtmltags)
      {
          //اندکی دستکاری در سیستم داخلی دات نت
          PropertyInfo readonlyProperty = collection
                                              .GetType()
                                              .GetProperty("IsReadOnly",
                                                           BindingFlags.Instance | BindingFlags.NonPublic);
          readonlyProperty.SetValue(collection, false, null);//IsReadOnly=false


          for (int i = 0; i < collection.Count; i++)
          {
              if (string.IsNullOrWhiteSpace(collection[i])) continue;


              if (!allowHtmltags)
              {
                  //در حالت کوئری استرینگ دلیلی برای ارسال هیچ نوع تگی وجود ندارد
                  collection[collection.Keys[i]] =
                     AntiXss.HtmlEncode(_cleanAllTags.Replace(collection[i], string.Empty));
              }
              else
              {
                  //قصد تمیز سازی ویوو استیت را نداریم چون در این حالت وب فرم‌ها از کار می‌افتند
                  if (collection.Keys[i].StartsWith("__VIEWSTATE")) continue;
                  //در سایر موارد کاربران مجازند فقط تگ‌های سالم را ارسال کنند و مابقی حذف می‌شود
                  collection[collection.Keys[i]] = Sanitizer.GetSafeHtml(collection[i]);
              }
          }


          readonlyProperty.SetValue(collection, true, null);//IsReadOnly=true
      }
  }
}

<?xml version="1.0"?>
<configuration>
<system.web>
  <pages validateRequest="false" enableEventValidation="false" />
  <httpRuntime requestValidationMode="2.0" />
  <compilation debug="true" targetFramework="4.0" />
  <httpModules>
    <add name="AntiXssModule" type="AntiXssMdl.AntiXssModule"/>
  </httpModules>
</system.web>


<system.webServer>
  <validation validateIntegratedModeConfiguration="false"/>
  <modules>
    <add name="AntiXssModule" type="AntiXssMdl.AntiXssModule"/>
  </modules>
</system.webServer>
</configuration>

...
}
catch (Exception ex)
{
   Elmah.ErrorSignal.FromCurrentContext().Raise(ex);
... 

 Elmah.ErrorLog.GetDefault(null).Log(new Error(ex))

using System;
using System.Text;
using Elmah;

namespace Common.WebToolkit
{
    public static class ElmahLogEx
    {
        public static void LogException(this string ex)
        {
            if (string.IsNullOrWhiteSpace(ex))
                return;
            LogException(new Exception(ex));
        }

        public static void LogException(this Exception ex)
        {
            if (ex == null) return;
            try
            {
                ErrorSignal.FromCurrentContext().Raise(ex);
            }
            catch
            {
                ErrorLog.GetDefault(null).Log(new Error(ex));
            }
        }
    }
}