[SanitizeInput] public IActionResult Add (string address)

public class Account
{
       public virtual int Id { get; set; }

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

public class Category
{
       public virtual int Id { get; set; }

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

public class Payee
{
       public virtual int Id { get; set; }

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

public class Bill
{
       public virtual int Id { get; set; }

       [NotNull]
       public virtual Account Account { get; set; }

       [NotNull]
       public virtual Category Category { get; set; }

       [NotNull]
       public virtual Payee Payee { get; set; }

       [NotNull]
       public virtual decimal Amount { set; get; }

       [NotNull]
       public virtual DateTime BillDate { set; get; }

       [NotNullNotEmpty]
       [Length(Min = 1, Max = 500, Message = "طول توضیحات باید بین 1 و 500 کاراکتر باشد")]
       public virtual string Description { get; set; } 
}

    create table Accounts (
       AccountId INT IDENTITY NOT NULL,
      Name NVARCHAR(120) not null,
      primary key (AccountId)
   )

   create table Bills (
       BillId INT IDENTITY NOT NULL,
      Amount DECIMAL(19,5) not null,
      BillDate DATETIME not null,
      Description NVARCHAR(500) not null,
      AccountId INT not null,
      CategoryId INT not null,
      PayeeId INT not null,
      primary key (BillId)
   )

   create table Categories (
       CategoryId INT IDENTITY NOT NULL,
      Name NVARCHAR(130) not null,
      primary key (CategoryId)
   )

   create table Payees (
       PayeeId INT IDENTITY NOT NULL,
      Name NVARCHAR(120) not null,
      primary key (PayeeId)
   )

   alter table Bills
       add constraint fk_Account_Bill
       foreign key (AccountId)
       references Accounts

   alter table Bills
       add constraint fk_Category_Bill
       foreign key (CategoryId)
       references Categories

   alter table Bills
       add constraint fk_Payee_Bill
       foreign key (PayeeId)
       references Payees

var newBill = new Bill
                   {
                       Account = accountRepository.GetByKey(1),
                       Amount = 1,
                       BillDate = DateTime.Now,
                       Category = categoryRepository.GetByKey(1),
                       Description = "testestest...",
                       Payee = payeeRepository.GetByKey(1)
                   };

SELECT account0_.AccountId as AccountId0_0_, account0_.Name as Name0_0_
FROM Accounts account0_ WHERE account0_.AccountId=@p0;@p0 = 1 [Type: Int32 (0)]

SELECT category0_.CategoryId as CategoryId2_0_, category0_.Name as Name2_0_
FROM Categories category0_ WHERE category0_.CategoryId=@p0;@p0 = 1 [Type: Int32 (0)]

SELECT payee0_.PayeeId as PayeeId3_0_, payee0_.Name as Name3_0_
FROM Payees payee0_ WHERE payee0_.PayeeId=@p0;@p0 = 1 [Type: Int32 (0)]

INSERT INTO Bills (Amount, BillDate, Description, AccountId, CategoryId, PayeeId)
VALUES (@p0, @p1, @p2, @p3, @p4, @p5);
select SCOPE_IDENTITY();
@p0 = 1 [Type: Decimal (0)],
@p1 = 2010/12/27 11:48:33 ق.ظ [Type: DateTime (0)],
@p2 = 'testestest...' [Type: String (500)],
@p3 = 1 [Type: Int32 (0)],
@p4 = 1 [Type: Int32 (0)],
@p5 = 1 [Type: Int32 (0)]

INSERT INTO Bills (Amount, BillDate, Description, AccountId, CategoryId, PayeeId)
VALUES (@p0, @p1, @p2, @p3, @p4, @p5);
select SCOPE_IDENTITY();
@p0 = 1 [Type: Decimal (0)],
@p1 = 2010/12/27 11:58:22 ق.ظ [Type: DateTime (0)],
@p2 = 'testestest...' [Type: String (500)],
@p3 = 1 [Type: Int32 (0)],
@p4 = 1 [Type: Int32 (0)],
@p5 = 1 [Type: Int32 (0)]

public partial class Bill : EntityObject
{
       public global::System.Int32 BillId {set;get;}
       public global::System.Decimal Amount {set;get;}
       public global::System.DateTime BillDate {set;get;}
       public global::System.String Description {set;get;}
       public global::System.Int32 AccountId {set;get;}
       public global::System.Int32 CategoryId {set;get;}
       public global::System.Int32 PayeeId {set;get;}
       public Account Account {set;get;}
       public Category Category {set;get;}
}

public interface IRoleService
    {
        bool IsUserInRole(string username, string roleName);
        string[] GetRolesForUser(string username);
        void AddUsersToRoles(string[] usernames, string[] roleNames);
        string ApplicationName { get; set; }
        void CreateRole(string roleName);
        bool DeleteRole(string roleName, bool throwOnPopulatedRole);
        string[] FindUsersInRole(string roleName, string usernameToMatch);
        string[] GetAllRoles();
        string[] GetUsersInRole(string roleName);
        void RemoveUsersFromRoles(string[] usernames, string[] roleNames);
        bool RoleExists(string roleName);
    }

public class RoleService: IRoleService
{
        private readonly IDbSet<Role> _role;
        private readonly IUnitOfWork _uow;
        public RoleService(IUnitOfWork uow)
        {
            _uow = uow;
            _role = uow.Set<Role>();
        }
        public bool IsUserInRole(string username, string roleName)
        {
            throw new NotImplementedException();
        }
        public string[] GetRolesForUser(string username)
        {
            throw new NotImplementedException();
        }
//...
}

1. [CallerFilePath]:مسیر کد فراخواننده را نگه می‌دارد.
   
2. [CallerLineNumber]: شماره خط کد فراخواننده را  نگه می‌دارد.
   
3. [CallerMemberName] : نام کد فراخوان را نگه می‌دارد .
   

using System;
using System.Runtime.CompilerServices; 
namespace ConsoleApplication8
{ 
  class Program
    {
        static void Main(string[] args)
        {
            Test();
            Console.Read();
        }
        static void Test(
                [CallerMemberName] string memberName = null,
                [CallerFilePath] string filePath = null,
                [CallerLineNumber] int lineNumber = 0)
        {
            Console.WriteLine(memberName);
            Console.WriteLine(filePath);
            Console.WriteLine(lineNumber);
        }
    }
}

Main          
c:\Pojects\ConsoleApplication8\Program.cs       
9                

Bag=IList
Set=Iesi.Collections.ISet
List=IList
Map=IDictionary

using System.Collections.Generic;

namespace Test1.Model12
{
   public class User
   {
       public virtual int Id { set; get; }
       public virtual string Name { get; set; }
       public virtual IDictionary<string, string> Preferences { get; set; }
   }
}

using FluentNHibernate.Automapping;
using FluentNHibernate.Automapping.Alterations;

namespace Test1.Model12
{
   public class UserMapping : IAutoMappingOverride<User>
   {
       public void Override(AutoMapping<User> mapping)
       {
           mapping.Id(x => x.Id);
           mapping.HasMany(x => x.Preferences)
               .AsMap<string>("FieldKey")
               .Element("FieldValue", x => x.Type<string>().Length(500));
       }
   }
}

create table "User" (
      Id INT IDENTITY NOT NULL,
      Name NVARCHAR(255) null,
      primary key (Id)
   )

create table Preferences (
      User_id INT not null,
      FieldValue NVARCHAR(500) null,
      FieldKey NVARCHAR(255) not null,
      primary key (User_id, FieldKey)
   )

alter table Preferences
       add constraint FKD6CB18523B1FD789
       foreign key (User_id)
       references "User"

using System.Collections.Generic;

namespace Test1.Model13
{
   public class User
   {
       public virtual int Id { get; set; }
       public virtual string Name { get; set; }
       public virtual IDictionary<string, Property> Properties { get; set; }
   }

   public class Property
   {
       public virtual int Id { get; set; }
       public virtual string Name { get; set; }
       public virtual string Value { get; set; }
       public virtual User User { get; set; }
   }
}

using FluentNHibernate.Automapping;
using FluentNHibernate.Automapping.Alterations;

namespace Test1.Model13
{
   public class UserMapping : IAutoMappingOverride<User>
   {
       public void Override(AutoMapping<User> mapping)
       {
           mapping.Id(x => x.Id);
           mapping.HasMany<Property>(x => x.Properties)
               .AsMap<string>("FieldKey")
               .Component(x => x.Map(c => c.Id));
       }
   }
}

create table "Property" (
      Id INT IDENTITY NOT NULL,
      Name NVARCHAR(255) null,
      Value NVARCHAR(255) null,
      User_id INT null,
      primary key (Id)
   )

create table "User" (
      Id INT IDENTITY NOT NULL,
      Name NVARCHAR(255) null,
      primary key (Id)
   )

create table Properties (
      User_id INT not null,
      Id INT null,
      FieldKey NVARCHAR(255) not null,
      primary key (User_id, FieldKey)
   )

alter table "Property"
       add constraint FKF9F4D85A3B1FD7A2
       foreign key (User_id)
       references "User"

alter table Properties
       add constraint FK63646D853B1FD7A2
       foreign key (User_id)
       references "User"

using System;
using System.Collections.Generic;

namespace Test1.Model14
{
   public class FormData
   {
       public virtual int Id { get; set; }
       public virtual DateTime? DateTime { get; set; }
       public virtual IDictionary<FormField, string> FormPropertyValues { get; set; }
   }

   public class FormField
   {
       public virtual int Id { get; set; }
       public virtual string Name { get; set; }
   }
}

using FluentNHibernate.Automapping;
using FluentNHibernate.Automapping.Alterations;

namespace Test1.Model14
{
   public class FormDataMapping : IAutoMappingOverride<FormData>
   {
       public void Override(AutoMapping<FormData> mapping)
       {
           mapping.Id(x => x.Id);
           mapping.HasMany<FormField>(x => x.FormPropertyValues)
                  .AsEntityMap("FieldId")
                  .Element("FieldValue", x => x.Type<string>().Length(500))
                  .Cascade.All();
       }
   }
}

create table "FormData" (
      Id INT IDENTITY NOT NULL,
      DateTime DATETIME null,
      primary key (Id)
   )

create table FormPropertyValues (
      FormData_id INT not null,
      FieldValue NVARCHAR(500) null,
      FieldId INT not null,
      primary key (FormData_id, FieldId)
   )

create table "FormField" (
      Id INT IDENTITY NOT NULL,
      Name NVARCHAR(255) null,
      primary key (Id)
   )

alter table FormPropertyValues
       add constraint FKB807B9C090849E
       foreign key (FormData_id)
       references "FormData"

alter table FormPropertyValues
       add constraint FKB807B97165898A
       foreign key (FieldId)
       references "FormField"

public class Service
{
   public virtual int Id { get; set; }
   public virtual string Name { get; set; }
   public virtual IList<ServiceFormField> Fields { get; set; }
   public virtual IList<ServiceFormData> Forms { get; set; }
}

public class ServiceFormField
{
   public virtual int Id { get; set; }
   public virtual string Name { get; set; }
   public virtual bool IsRequired { get; set; }
   public virtual Service Service { get; set; }
}

public class ServiceFormData
{
   public virtual int Id { get; set; }
   public virtual IDictionary<ServiceFormField, string> FormPropertyValues { get; set; }       
   public virtual DateTime? DateTime { get; set; }
   public virtual Service Service { get; set; }
}

private static readonly Regex RegexBetweenTags = new Regex(@">\s+<", RegexOptions.Compiled);
        private static readonly Regex RegexLineBreaks = new Regex(@"\r\s+", RegexOptions.Compiled);

        protected override void Render(HtmlTextWriter writer)
        {
            using (var htmlwriter = new HtmlTextWriter(new System.IO.StringWriter()))
            {
                base.Render(htmlwriter);
                var html = htmlwriter.InnerWriter.ToString();

                html = RegexBetweenTags.Replace(html, "> <");
                html = RegexLineBreaks.Replace(html, string.Empty);
                html = html.Replace("//<![CDATA[", "").Replace("//]]>", "");
                html = html.Replace("// <![CDATA[", "").Replace("// ]]>", "");

                writer.Write(html.Trim());
            }
        }

using System;
using System.IO;
using System.IO.Compression;
using System.Text;
using System.Text.RegularExpressions;
using System.Web;
using System.Web.Mvc;

namespace PWS.Common.ActionFilters
{
    public class CompressAttribute : ActionFilterAttribute
    {
         #region Methods (2) 

        // Public Methods (1) 

        /// <summary>
        /// Called by the ASP.NET MVC framework before the action method executes.
        /// </summary>
        /// <param name="filterContext">The filter context.</param>
        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            var response = filterContext.HttpContext.Response;
            if (IsGZipSupported(filterContext.HttpContext.Request))
            {
                String acceptEncoding = filterContext.HttpContext.Request.Headers["Accept-Encoding"];
                if (acceptEncoding.Contains("gzip"))
                {
                    response.Filter = new GZipStream(response.Filter, CompressionMode.Compress);
                    response.AppendHeader("Content-Encoding", "gzip");
                }
                else
                {
                    response.Filter = new DeflateStream(response.Filter, CompressionMode.Compress);
                    response.AppendHeader("Content-Encoding", "deflate");
                }
            }
            // Allow proxy servers to cache encoded and unencoded versions separately
            response.AppendHeader("Vary", "Content-Encoding");
           //حذف فضاهای خالی





            response.Filter = new WhitespaceFilter(response.Filter);
        }
        // Private Methods (1) 

        /// <summary>
        /// Determines whether [is G zip supported] [the specified request].
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns></returns>
        private Boolean IsGZipSupported(HttpRequestBase request)
        {
            String acceptEncoding = request.Headers["Accept-Encoding"];

            if (acceptEncoding == null) return false;
            return !String.IsNullOrEmpty(acceptEncoding) && acceptEncoding.Contains("gzip") || acceptEncoding.Contains("deflate");
        }

#endregion Methods 
    }

    /// <summary>
    /// Whitespace Filter
    /// </summary>
    public class WhitespaceFilter : Stream
    {
#region Fields (3) 

        private readonly Stream _filter;
        /// <summary>
        /// 
        /// </summary>
        private static readonly Regex RegexAll = new Regex(@"\s+|\t\s+|\n\s+|\r\s+", RegexOptions.Compiled);
        /// <summary>
        /// 
        /// </summary>
        private static readonly Regex RegexTags = new Regex(@">\s+<", RegexOptions.Compiled);

#endregion Fields 

#region Constructors (1) 

        /// <summary>
        /// Initializes a new instance of the <see cref="WhitespaceFilter" /> class.
        /// </summary>
        /// <param name="filter">The filter.</param>
        public WhitespaceFilter(Stream filter)
        {
            _filter = filter;
        }

#endregion Constructors 

#region Properties (5) 

        //methods that need to be overridden from stream
        /// <summary>
        /// When overridden in a derived class, gets a value indicating whether the current stream supports reading.
        /// </summary>
        /// <returns>true if the stream supports reading; otherwise, false.</returns>
        public override bool CanRead
        {
            get { return true; }
        }

        /// <summary>
        /// When overridden in a derived class, gets a value indicating whether the current stream supports seeking.
        /// </summary>
        /// <returns>true if the stream supports seeking; otherwise, false.</returns>
        public override bool CanSeek
        {
            get { return true; }
        }

        /// <summary>
        /// When overridden in a derived class, gets a value indicating whether the current stream supports writing.
        /// </summary>
        /// <returns>true if the stream supports writing; otherwise, false.</returns>
        public override bool CanWrite
        {
            get { return true; }
        }

        /// <summary>
        /// When overridden in a derived class, gets the length in bytes of the stream.
        /// </summary>
        /// <returns>A long value representing the length of the stream in bytes.</returns>
        public override long Length
        {
            get { return 0; }
        }

        /// <summary>
        /// When overridden in a derived class, gets or sets the position within the current stream.
        /// </summary>
        /// <returns>The current position within the stream.</returns>
        public override long Position { get; set; }

#endregion Properties 

#region Methods (6) 

// Public Methods (6) 

        /// <summary>
        /// Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. Instead of calling this method, ensure that the stream is properly disposed.
        /// </summary>
        public override void Close()
        {
            _filter.Close();
        }

        /// <summary>
        /// When overridden in a derived class, clears all buffers for this stream and causes any buffered data to be written to the underlying device.
        /// </summary>
        public override void Flush()
        {
            _filter.Flush();
        }

        /// <summary>
        /// When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.
        /// </summary>
        /// <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values between <paramref name="offset" /> and (<paramref name="offset" /> + <paramref name="count" /> - 1) replaced by the bytes read from the current source.</param>
        /// <param name="offset">The zero-based byte offset in <paramref name="buffer" /> at which to begin storing the data read from the current stream.</param>
        /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
        /// <returns>
        /// The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.
        /// </returns>
        public override int Read(byte[] buffer, int offset, int count)
        {
            return _filter.Read(buffer, offset, count);
        }

        /// <summary>
        /// When overridden in a derived class, sets the position within the current stream.
        /// </summary>
        /// <param name="offset">A byte offset relative to the <paramref name="origin" /> parameter.</param>
        /// <param name="origin">A value of type <see cref="T:System.IO.SeekOrigin" /> indicating the reference point used to obtain the new position.</param>
        /// <returns>
        /// The new position within the current stream.
        /// </returns>
        public override long Seek(long offset, SeekOrigin origin)
        {
            return _filter.Seek(offset, origin);
        }

        /// <summary>
        /// When overridden in a derived class, sets the length of the current stream.
        /// </summary>
        /// <param name="value">The desired length of the current stream in bytes.</param>
        public override void SetLength(long value)
        {
            _filter.SetLength(value);
        }

        /// <summary>
        /// When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.
        /// </summary>
        /// <param name="buffer">An array of bytes. This method copies <paramref name="count" /> bytes from <paramref name="buffer" /> to the current stream.</param>
        /// <param name="offset">The zero-based byte offset in <paramref name="buffer" /> at which to begin copying bytes to the current stream.</param>
        /// <param name="count">The number of bytes to be written to the current stream.</param>
        public override void Write(byte[] buffer, int offset, int count)
        {
            string html = Encoding.Default.GetString(buffer);

            //remove whitespace
            html = RegexTags.Replace(html, "> <");
            html = RegexAll.Replace(html, " ");

            byte[] outdata = Encoding.Default.GetBytes(html);

            //write bytes to stream
            _filter.Write(outdata, 0, outdata.GetLength(0));
        }

#endregion Methods 
     }
}

GlobalFilters.Filters.Add(new CompressAttribute());