"ApplicationName": "Dependency Injection Demo",
"GreetingMessage": "Welcome to Dependency Injection Demo",
"AllowedHosts": "*",

"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft": "Warning",
"Microsoft.Hosting.Lifetime": "Information"
}
},

namespace AspNetCoreDependencyInjection.Configs
{
    public class AppConfig
    {
        public string ApplicationName { get; set; }
        public string GreetingMessage { get; set; }
        public string AllowedHosts { get; set; }
    }
}

public IWebHostEnvironment Environment { get; }
public IConfiguration Configuration { get; }
public IServiceCollection Services { get; set; }

public Startup(IWebHostEnvironment environment)
{
var builder = new ConfigurationBuilder()
        .SetBasePath(environment.ContentRootPath)
        .AddJsonFile("appsettings.json", optional: true)
        .AddEnvironmentVariables();
        this.Environment = environment;
        this.Configuration = builder.Build();
}

var appSettingsFile = environment.IsProduction() ? "appsettings.json" : "appsettings_dev.json";
var builder = new ConfigurationBuilder()
.SetBasePath(environment.ContentRootPath)
                .AddJsonFile( appSettingsFile , optional: true)
                .AddEnvironmentVariables();

services.AddSingleton(services => new AppConfig { 
    ApplicationName = this.Configuration["ApplicationName"],
    GreetingMessage = this.Configuration["GreetingMessage"],
    AllowedHosts = this.Configuration["AllowedHosts"]
});

public class AppSettingsController : Controller
{
        private readonly AppConfig _appConfig;
        public AppSettingsController(AppConfig appConfig)
        {
            _appConfig = appConfig;
        } 
 // codes here …
}

"UserOptionConfig": {
    "UsersAvatarsFolder": "avatars",
    "UserDefaultPhoto": "icon-user-default.png",
    "UserAvatarImageOptions": {
         "MaxWidth": 150,
         "MaxHeight": 150
    }
},

"LiteDbConfig": {
   "ConnectionString": "Filename=\\Data\\DependencyInjectionDemo.db;Connection=direct;Password=@123456;"
}

services.AddSingleton(services => new LiteDbConfig
{
    ConnectionString = this.Configuration["LiteDbConfig:ConnectionString"],
});

namespace AspNetCoreDependencyInjection.Configs
{
    public class UserOptionConfig
    {
        public string UsersAvatarsFolder { get; set; }
        public string UserDefaultPhoto { get; set; }
        public UserAvatarImageOptions UserAvatarImageOptions { get; set; }
    }

    public class UserAvatarImageOptions
    {
        public int MaxHeight { get; set; }
        public int MaxWidth { get; set; }
    }
}

services.Configure<UserOptionConfig>(this.Configuration.GetSection("UserOptionConfig"));

private readonly LiteDbConfig _liteDbConfig;
private readonly AppConfig _appConfig;
private readonly UserOptionConfig _userOptionConfig; 

public AppSettingsController(AppConfig appConfig ,
    LiteDbConfig liteDbConfig ,
    IOptionsMonitor<UserOptionConfig> userOptionConfig)
{
    _appConfig = appConfig;
    _liteDbConfig = liteDbConfig;
    _userOptionConfig = userOptionConfig.CurrentValue;
}

https://plus.google.com/u/0/userId/posts 

https://plus.google.com/_/stream/getactivities/?&sp=[1,2,"userId",null,null,null,null,"social.google.com",[]]

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net;
//needs a ref. to System.Web.Extensions asm.
using System.Web.Script.Serialization;

namespace GooglePlus
{
    [DebuggerDisplay("{DateTime}-{Title}-{Comment}-{Url}")]
    public class GooglePlusItem
    {
        public DateTime DateTime { set; get; }
        public string Url { set; get; }
        public string Title { set; get; }
        public string Comment { set; get; }
    }

    public static class Utils
    {
        public static DateTime ConvertFromUnixTimestamp(this long data)
        {
            return new DateTime(1970, 1, 1, 0, 0, 0, 0).AddSeconds(data);
        }

        public static string ToSafeString(this object data)
        {
            return data == null ? string.Empty : data.ToString();
        }
    }

    public class GooglePlusJsonParser
    {
        public static IList<GooglePlusItem> GetMyPublicItemsList(string userId)
        {
            var url = string.Format("https://plus.google.com/_/stream/getactivities/?&sp=[1,2,\"{0}\",null,null,null,null,\"social.google.com\",[]]", userId);
            var jsonData = new WebClient().DownloadString(url);
            return ParsePublicData(jsonData);
        }

        public static IList<GooglePlusItem> ParsePublicData(string jsonData)
        {
            jsonData = removeRedundantData(jsonData);
            var posts = parseJson(jsonData);
            return createItemsList(posts);
        }

        private static IList<GooglePlusItem> createItemsList(object[] posts)
        {
            var result = new List<GooglePlusItem>();
            foreach (object[] post in posts)
            {
                var items = (object[])((object[])post[66])[0];
                result.Add(new GooglePlusItem
                {
                    DateTime = (((Int64)post[5]) / 1000).ConvertFromUnixTimestamp(),
                    Title = items[3].ToSafeString(),
                    Url = items[1].ToSafeString(),
                    Comment = post[4].ToSafeString()
                });
            }
            return result;
        }

        private static object[] parseJson(string jsonData)
        {
            var jsonObject = new JavaScriptSerializer().Deserialize<object[]>(jsonData);
            var posts = (object[])(((object[])jsonObject[1])[0]);
            return posts;
        }

        private static string removeRedundantData(string jsonData)
        {
            return jsonData.Replace(")]}'", string.Empty)
                           .Replace("[,", "[\"\",")
                           .Replace(",,", ",\"\",")
                           .Replace(",,", ",\"\",");
        }
    }
}

namespace MyShop.Models
{
    // You can add profile data for the user by adding more properties to your ApplicationUser class, please visit http://go.microsoft.com/fwlink/?LinkID=317594 to learn more.
    public class ApplicationUser : IdentityUser
    {
    }

    public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
    {
        public ApplicationDbContext()
            : base("DefaultConnection")
        {
        }
      
}

namespace MyShop.Models
{
    public class AuthorProduct
    {
        [Key]
        public int AuthorProductId { get; set; }
       /* public int UserId { get; set; }*/

        [Display(Name = "User")]
        public string ApplicationUserId { get; set; }

        public int ProductID { get; set; }

        public virtual Product Product { get; set; }
    
        public virtual ApplicationUser ApplicationUser { get; set; }
    }
}

            if (!context.Users.Where(u => u.UserName == "Admin").Any())
            {
                var roleStore = new RoleStore<IdentityRole>(context);
                var rolemanager = new RoleManager<IdentityRole>(roleStore);

                var userstore = new UserStore<ApplicationUser>(context);
                var usermanager = new UserManager<ApplicationUser>(userstore);
                
                var user = new ApplicationUser {UserName = "Admin"};
                
                usermanager.Create(user, "121212");
                rolemanager.Create(new IdentityRole {Name = "admin"});
                
                usermanager.AddToRole(user.Id, "admin");
            }

MySharedLocalizer from MyCustomBaseView: @MySharedLocalizer["About Title"]

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 class SingletonClassCreator<T> where T:class , new()
    {
        private static T _singletoneInstance;
        private static readonly object Lock = new object();

        public static T SingletoneInstance
        {
            get
            {
                lock (Lock)
                {
                    if (_singletoneInstance == null)
                    {
                        _singletoneInstance = new T();                        
                    }
                }
                return _singletoneInstance;
            }            
        }

        private SingletonClassCreator()
        {            
        }
    }

public class FirstSingleton
    {
        public int Square(int input)
        {
            return input*input;
        }
    }

using System;
using System.Threading;
using System.Threading.Tasks;
 
namespace MyApp
{
    public class AsyncLock : IDisposable
    {
        private SemaphoreSlim _semaphoreSlim = new SemaphoreSlim(1, 1);
 
        public async Task<AsyncLock> LockAsync()
        {
            await _semaphoreSlim.WaitAsync();
            return this;
        }
 
        public void Dispose()
        {
            _semaphoreSlim.Release();
        }
    }
}

private static readonly AsyncLock _mutex = new AsyncLock();
 
using(await _mutex.LockAsync())
{
    // Critical section... You can await here!
}

• NotNull/NotEmpty
  
• Matches 
  
• InclusiveBetween 
  
• CreditCard 
  
• Email 
  
• EqualTo 
  
• Length 

public ActionResult Save([CustomizeValidator(RuleSet="MyRuleset")] Customer cust) {
  // ...
}

public interface IValidatorFactory {
   IValidator<T> GetValidator<T>();
   IValidator GetValidator(Type type);
}

ObjectFactory.Configure(cfg => cfg.AddRegistry(new MyRegistry()));
 
public class MyRegistry : Registry {
    public MyRegistry() {
        For<IValidator<Person>>()
    .Singleton()
    .Use<PersonValidator>();
    }
}

public class MyRegistry : Registry {
   public MyRegistry() {
 
     AssemblyScanner.FindValidatorsInAssemblyContaining<MyValidator>()
       .ForEach(result => {
            For(result.InterfaceType)
               .Singleton()
               .Use(result.ValidatorType);
       });
   }
}

protected void Application_Start() {
    RegisterRoutes(RouteTable.Routes);
 
    //Configure structuremap
    ObjectFactory.Configure(cfg => cfg.AddRegistry(new MyRegistry()));
    ControllerBuilder.Current.SetControllerFactory(new StructureMapControllerFactory());
 
    //Configure FV to use StructureMap
    var factory = new StructureMapValidatorFactory();
 
    //Tell MVC to use FV for validation
    ModelValidatorProviders.Providers.Add(new FluentValidationModelValidatorProvider(factory));        
    DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = false;
}