@using MyProject.Models

Project   
- Controllers
- Models
- Services
- ViewModels
- Views

using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc.Razor;
namespace Core1RtmEmptyTest.StartupCustomizations
{ public class FeatureLocationExpander : IViewLocationExpander {
   public void PopulateValues(ViewLocationExpanderContext context)
   {
    context.Values["customviewlocation"] = nameof(FeatureLocationExpander);
   }
   public IEnumerable<string> ExpandViewLocations(
    ViewLocationExpanderContext context, IEnumerable<string> viewLocations)
   {
    return new[]
    { "/Features/{1}/{0}.cshtml", "/Features/Shared/{0}.cshtml"
    };
   } }
}

public void ConfigureServices(IServiceCollection services)
{ services.AddMvc(); services.Configure<RazorViewEngineOptions>(options => {
   options.ViewLocationExpanders.Add(new FeatureLocationExpander()); });

"publishOptions": {
 "include": [
  "wwwroot",
  "Features",
  "appsettings.json",
  "web.config"
 ]
},

{ "dependencies": {
        //same as before
   "Microsoft.Extensions.FileProviders.Embedded": "1.0.0" },

services.AddMvc();
services.Configure<RazorViewEngineOptions>(options =>
{ options.ViewLocationExpanders.Add(new FeatureLocationExpander()); var thisAssembly = typeof(Startup).GetTypeInfo().Assembly;  options.FileProviders.Clear(); options.FileProviders.Add(new EmbeddedFileProvider(thisAssembly, baseNamespace: "Core1RtmEmptyTest"));
});

"buildOptions": { "emitEntryPoint": true, "preserveCompilationContext": true, "embed": "Features/**/*.cshtml"
},

using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc.Razor;
namespace Core1RtmEmptyTest.StartupCustomizations
{    public abstract class MyCustomBaseView<TModel> : RazorPage<TModel>    {        public bool IsAuthenticated()        {            return Context.User.Identity.IsAuthenticated;        }
#pragma warning disable 1998        public override async Task ExecuteAsync()        {        }
#pragma warning restore 1998    }
}

@inherits Core1RtmEmptyTest.StartupCustomizations.MyCustomBaseView<TModel>

 Is Current User Authenticated? @IsAuthenticated()

@functions {    public string Test()    {        return message;    }    readonly string message = "test";
}

 @Test()<br />
@message

 @inject Microsoft.AspNetCore.Hosting.IHostingEnvironment Host;

 [Microsoft.AspNetCore.Mvc.Razor.Internal.RazorInjectAttribute]
public Microsoft.AspNetCore.Hosting.IHostingEnvironment Host { get; private set; }

 @inject IOptions<SmtpConfig> Settings;

 @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers

{    "dependencies": {
         //same as before
         "Microsoft.AspNetCore.Mvc.TagHelpers": "1.0.0",
         "Microsoft.AspNetCore.Razor.Runtime": "1.0.0",        "Microsoft.AspNetCore.Razor.Tools": {            "version": "1.0.0-preview2-final",            "type": "build"        }    },    "tools": {
         //same as before        "Microsoft.AspNetCore.Razor.Tools": "1.0.0-preview2-final"    } 
}

<a asp-controller="Home" asp-action="Index" asp-route-id="123">Home</a>

<a asp-route="login">Login</a>

<a asp-controller="Account"
   asp-action="Register"
   asp-protocol="https"
   asp-host="asepecificdomain.com"
   asp-fragment="fragment">Register</a>

<form asp-controller="Account"
      asp-action="Login"
      asp-route-returnurl="@ViewBag.ReturnUrl"
      method="post" ></form>

<form action="/Account/Login?returnurl=%2FHome%2FAbout" method="post">

<form asp-route="login"
      asp-route-returnurl="@ViewBag.ReturnUrl"
      method="post" ></form>

<script asp-src-include="~/app/**/*.js"></script>

<script src="/app/app.js"></script><script src="/app/controllers/controller1.js"></script><script src="/app/controllers/controller2.js"></script><script src="/app/controllers/controller3.js"></script><script src="/app/controllers/controller4.js"></script><script src="/app/services/service1.js"></script><script src="/app/services/service2.js"></script>

<script asp-src-include="~/app/**/*.js"
        asp-src-exclude="~/app/services/**/*.js"></script>

<link rel="stylesheet" href="//ajax.aspnetcdn.com/ajax/bootstrap/3.0.0/css/bootstrap.min.css"
      asp-fallback-href="~/lib/bootstrap/css/bootstrap.min.css"
      asp-fallback-test-class="hidden"
      asp-fallback-test-property="visibility"
      asp-fallback-test-value="hidden" /><script src="//ajax.aspnetcdn.com/ajax/bootstrap/3.0.0/bootstrap.min.js"
        asp-fallback-src="~/lib/bootstrap/js/bootstrap.min.js"
        asp-fallback-test="window.jQuery"></script>

<link rel="stylesheet" href="~/css/site.min.css" asp-file-version="true"/>

<link rel="stylesheet" href="/css/site.min.css?v=UdxKHVNJA5vb1EsG9O9uURFDfEE3j1E3DgwL6NiDGMc" />

<img src="~/images/logo.png"
     alt="company logo"
     asp-file-version="true" />

<img src="/images/logo.png?v=W2F5D366_nQ2fQqUk3URdgWy2ZekXjHzHJaY5yaiOOk"
     alt="company logo"/>

<environment names="Development">    <link rel="stylesheet" href="~/css/site1.css" /><link rel="stylesheet" href="~/css/site2.css" /></environment><environment names="Staging,Production"><link rel="stylesheet" href="~/css/site.min.css" asp-file-version="true"/></environment>

public class CustomerViewModel
{
   public string Vehicle { get; set; }  
   public List<SelectListItem> Vehicles { get; set; }

<select asp-for="Vehicle" asp-items="Model.Vehicles"></select>

    public partial class SidebarMenuController : Controller
    {
        const int Min15 = 900;

        [ChildActionOnly]
        [OutputCache(Duration = Min15)]
        public virtual ActionResult Index()
        {
            return PartialView("_SidebarMenu");
        }
    }

using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Core1RtmEmptyTest.Services;
namespace Core1RtmEmptyTest.ViewComponents
{    public class SiteCopyright : ViewComponent    {        private readonly IMessagesService _messagesService;        public SiteCopyright(IMessagesService messagesService)        {            _messagesService = messagesService;        }        public IViewComponentResult Invoke(int numberToTake)        {            var name = _messagesService.GetSiteName();            return View(viewName: "Default", model: name);        }        //public async Task<IViewComponentResult> InvokeAsync(int numberToTake)        //{        //    return View();        //}    }
}

 /Views/Shared/Components/[NameOfComponent]/Default.cshtml

 /Views/[CurrentController]/Components/[NameOfComponent]/Default.cshtml

<footer><p>@await Component.InvokeAsync("SiteCopyright", new { numberToTake = 5 })</p></footer>

[ViewComponent]
public abstract class ViewComponent
{
   protected ViewComponent();
   public HttpContext HttpContext { get; }
   public ModelStateDictionary ModelState { get; }
   public HttpRequest Request { get; }
   public RouteData RouteData { get; }
   public IUrlHelper Url { get; set; }
   public IPrincipal User { get; }

   [Dynamic]  
   public dynamic ViewBag { get; }
   [ViewComponentContext]
   public ViewComponentContext ViewComponentContext { get; set; }
   public ViewContext ViewContext { get; }
   public ViewDataDictionary ViewData { get; }
   public ICompositeViewEngine ViewEngine { get; set; }

   //...
}

public IActionResult AddURLTest()
{
   return ViewComponent("AddURL");
}

$(document).ready (function(){
    $("#LoadSignIn").click(function(){
         $('#UserControl').load("/Home/AddURLTest");
    });
});

"dependencies": {
   "NETStandard.Library": "1.6.0",
   "Microsoft.AspNetCore.Mvc": "1.0.0",
   "Microsoft.AspNetCore.Razor.Tools": {
   "version": "1.0.0-preview2-final",
   "type": "build"
  }
},
"tools": {
   "Microsoft.AspNetCore.Razor.Tools": "1.0.0-preview2-final"
}

"buildOptions": {
   "embed": "Views/**/*.cshtml"
}

public void ConfigureServices(IServiceCollection services)
{
   services.AddMvc();
   //Get a reference to the assembly that contains the view components
   var assembly = typeof(ViewComponentLibrary.ViewComponents.SimpleViewComponent).GetTypeInfo().Assembly;
   //Create an EmbeddedFileProvider for that assembly
   var embeddedFileProvider = new EmbeddedFileProvider(assembly,"ViewComponentLibrary");
   //Add the file provider to the Razor view engine
   services.Configure<RazorViewEngineOptions>(options =>
   {
      options.FileProviders.Add(embeddedFileProvider);
   });

 [ViewComponent(Name = "ViewComponentLibrary.Simple")]
public class SimpleViewComponent : ViewComponent

 @await Component.InvokeAsync("ViewComponentLibrary.Simple", new { number = 5 })

 {
  "name": "asp.net",
  "private": true,
  "dependencies": {
"bootstrap": "3.3.6",
"jquery": "2.2.0",
"jquery-validation": "1.14.0",
"jquery-validation-unobtrusive": "3.2.6"
  }
}

    <script src="~/bower_components/jquery/dist/jquery.min.js"></script>    <script src="~/bower_components/jquery-validation/dist/jquery.validate.min.js"></script>    <script src="~/bower_components/jquery-validation-unobtrusive/jquery.validate.unobtrusive.min.js"></script>    @RenderSection("scripts", required: false)</body></html>

// Serve wwwroot as root
app.UseFileServer();
// Serve /bower_components as a separate root
app.UseFileServer(new FileServerOptions
{    // Set root of file server    FileProvider = new PhysicalFileProvider(Path.Combine(Directory.GetCurrentDirectory(), "bower_components")),    // Only react to requests that match this path    RequestPath = "/bower_components",    // Don't expose file system    EnableDirectoryBrowsing = false
});

<environment name="Development"><script src="~/bower_components/jquery/dist/jquery.min.js"></script><script src="~/bower_components/jquery-validation/dist/jquery.validate.min.js"></script><script src="~/bower_components/jquery-validation-unobtrusive/jquery.validate.unobtrusive.min.js"></script></environment>

<environment names="Staging, Production"><script src="https://ajax.aspnetcdn.com/ajax/jquery/jquery-2.1.4.min.js"
asp-fallback-src="/bower_components/jquery/dist/jquery.min.js"
asp-fallback-test="window.jQuery"></script><script src="https://ajax.aspnetcdn.com/ajax/jquery.validate/1.14.0/jquery.validate.min.js"
asp-fallback-src="bower_components/jquery-validation/dist/jquery.validate.min.js"
asp-fallback-test="window.jQuery && window.jQuery.validator"></script><script src="https://ajax.aspnetcdn.com/ajax/mvc/5.2.3/jquery.validate.unobtrusive.min.js"
asp-fallback-src="/bower_components/jquery-validation-unobtrusive/jquery.validate.unobtrusive.min.js"
asp-fallback-test="window.jQuery && window.jQuery.validator && window.jQuery.validator.unobtrusive"></script></environment>

@Html.ValidationSummary(false)

<div asp-validation-summary="All"></div>

@Html.ValidationSummary(true)

<div asp-validation-summary="ModelOnly"></div>

@Html.ValidationMessageFor(m => m.UserName, "", new { @class = "text-danger" })

[ResponseCache(Duration = 60)]
public IActionResult Contact()
{
   ViewData["Message"] = "Your contact page.";
   return View();
}

 Cache-Control: public,max-age=60

[ResponseCache(Duration = 60, Location = ResponseCacheLocation.Client)]

[ResponseCache(Location = ResponseCacheLocation.None, NoStore = true)]
public IActionResult Error()
{
   return View();
}

Cache-Control: no-store,no-cache
Pragma: no-cache

public void ConfigureServices(IServiceCollection services)
{    services.AddMvc(options =>    {        options.CacheProfiles.Add("PrivateCache",            new CacheProfile            {                Duration = 60,                Location = ResponseCacheLocation.Client            });     });

[ResponseCache(CacheProfileName = "PrivateCache")]

{
    "dependencies": {
      //same as before
      "Microsoft.Extensions.Caching.Memory": "1.0.0"
 },

public void ConfigureServices(IServiceCollection services)
{
  services.AddMemoryCache();

[Route("DNT/[controller]")]
public class AboutController : Controller
{    private readonly IMemoryCache _memoryCache;    public AboutController(IMemoryCache memoryCache)    {        _memoryCache = memoryCache;    }    [Route("")]    public ActionResult Hello()    {        string cacheKey = "my-cache-key";        string greeting;        if (!_memoryCache.TryGetValue(cacheKey, out greeting))        {
             greeting = "Hello";            // store in the cache            _memoryCache.Set(cacheKey, greeting,                new MemoryCacheEntryOptions()                .SetAbsoluteExpiration(TimeSpan.FromMinutes(1)));        }        return Content($"{greeting} from DNT!");    }

 new MemoryCacheEntryOptions()
  .SetSlidingExpiration(TimeSpan.FromMinutes(5))

 new MemoryCacheEntryOptions()
  .SetSlidingExpiration(TimeSpan.FromMinutes(5))
  .SetAbsoluteExpiration(TimeSpan.FromHours(1))

 new MemoryCacheEntryOptions()
  .SetPriority(CacheItemPriority.NeverRemove))

<cache expires-after="@TimeSpan.FromMinutes(10)">
    @Html.Partial("_WhatsNew")
    *last updated  @DateTime.Now.ToLongTimeString()</cache>

<cache expires-after="@TimeSpan.FromSeconds(5)"><!--View Component or something that gets data from the database-->
    *last updated  @DateTime.Now.ToLongTimeString()</cache>

<cache expires-on="@DateTime.Today.AddDays(1).AddTicks(-1)"><!--View Component or something that gets data from the database-->
 *last updated  @DateTime.Now.ToLongTimeString()</cache>

<cache expires-sliding="@TimeSpan.FromMinutes(5)"><!--View Component or something that gets data from the database-->
    *last updated  @DateTime.Now.ToLongTimeString()</cache>

<cache vary-by-user="true"><!--View Component or something that gets data from the database-->
    *last updated @DateTime.Now.ToLongTimeString()</cache>

<cache vary-by-route="id"><!--View Component or something that gets data from the database-->
    *last updated  @DateTime.Now.ToLongTimeString()</cache>

<cache vary-by-query="search"><!--View Component or something that gets data from the database-->
    *last updated  @DateTime.Now.ToLongTimeString()</cache>

<cache vary-by-cookie="MyAppCookie"><!--View Component or something that gets data from the database-->
    *last updated  @DateTime.Now.ToLongTimeString()</cache>

<cache vary-by-header="User-Agent"><!--View Component or something that gets data from the database-->
    *last updated  @DateTime.Now.ToLongTimeString()</cache>

<cache vary-by="@ViewBag.ProductId"><!--View Component or something that gets data from the database-->
    *last updated  @DateTime.Now.ToLongTimeString()</cache>

<cache vary-by-user="true" vary-by-route="id"><!--View Component or something that gets data from the database-->
    *last updated  @DateTime.Now.ToLongTimeString()</cache>

<cache expires-sliding="@TimeSpan.FromMinutes(10)"
priority="@Microsoft.Extensions.Caching.Memory.CacheItemPriority.NeverRemove"><!--View Component or something that gets data from the database-->
    *last updated  @DateTime.Now.ToLongTimeString()</cache>

app.Use(async (context, next) =>
{
   context.Items["isVerified"] = true;
   await next.Invoke();
});

app.Run(async (context) =>
{
   await context.Response.WriteAsync("Verified request? " + context.Items["isVerified"]);
});

{
    "dependencies": {
      //same as before
      "Microsoft.AspNetCore.Session": "1.0.0"
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddSession();

public void Configure(IApplicationBuilder app)
{
    app.UseSession();

app.UseSession(options: new SessionOptions
{
    IdleTimeout = TimeSpan.FromMinutes(30),
    CookieName = ".MyApplication"
});

public ActionResult TestSession()
{
   this.HttpContext.Session.Set("key-1", BitConverter.GetBytes(DateTime.Now.Ticks));
   this.HttpContext.Session.SetInt32("key-2", 1);
   this.HttpContext.Session.SetString("key-3", "DNT");
   return Content("OK!");
}

 public IActionResult Index()
{
   byte[] key1 = this.HttpContext.Session.Get("key-1");
   long key1Value = BitConverter.ToInt64(key1, 0);
   int? key2Value = this.HttpContext.Session.GetInt32("key-2");
   string key3Value = this.HttpContext.Session.GetString("key-3");
   return Content("OK!");
}

using System;
using Microsoft.AspNetCore.Http;
using Newtonsoft.Json;
namespace Core1RtmEmptyTest.StartupCustomizations
{    public static class SessionExts    {        public static void SetDateTime(this ISession collection, string key, DateTime value)        {            collection.Set(key, BitConverter.GetBytes(value.Ticks));        }        public static DateTime? GetDateTime(this ISession collection, string key)        {            var data = collection.Get(key);            if (data == null)            {                return null;            }            var dateInt = BitConverter.ToInt64(data, 0);            return new DateTime(dateInt);        }        public static void SetObject(this ISession session, string key, object value)        {            var stringValue = JsonConvert.SerializeObject(value);            session.SetString(key, stringValue);        }        public static T GetObject<T>(this ISession session, string key)        {            var stringValue = session.GetString(key);            return JsonConvert.DeserializeObject<T>(stringValue);        }    }
}

{
    "dependencies": {
     //same as before
     "Microsoft.Extensions.Configuration.Json": "1.0.0"
   }
}

public void Configure(ILoggerFactory loggerFactory, IApplicationBuilder app, IHostingEnvironment env)
{
   loggerFactory.AddConsole(Configuration.GetSection("Logging"));
   loggerFactory.AddDebug();

{    "Logging": {        "IncludeScopes": false,        "LogLevel": {            "Default": "Debug",            "System": "Information",            "Microsoft": "Information"        }    }
}

{    "dependencies": {
        //same as before         "Microsoft.Extensions.Logging": "1.0.0",        "Microsoft.Extensions.Logging.Console": "1.0.0",        "Microsoft.Extensions.Logging.Debug": "1.0.0"     }
}

[Route("[controller]")]
public class AboutController : Controller
{    private readonly ILogger<AboutController> _logger;    public AboutController(ILogger<AboutController> logger)    {        _logger = logger;    }    [Route("")]    public ActionResult Hello()    {        _logger.LogInformation("Running Hello");        return Content("Hello from DNT!");    }

 loggerFactory.AddDebug(minLevel: LogLevel.Information);

  public enum LogLevel
  {
    Trace,
    Debug,
    Information,
    Warning,
    Error,
    Critical,
    None,
  }

[Route("api/[controller]")] // http://localhost:7742/api/test
public class TestController : Controller
{    private readonly ILogger<TestController> _logger;    public TestController(ILogger<TestController> logger)    {        _logger = logger;    }

[Route("api/[controller]")] // http://localhost:7742/api/test
public class TestController : Controller
{    private readonly ILogger<TestController> _logger;    public TestController(ILogger<TestController> logger)    {        _logger = logger;    }    [HttpGet]    public IEnumerable<string> Get() // http://localhost:7742/api/test    {        return new [] { "value1", "value2" };    }    [HttpGet("{page:int}")]    public IActionResult Get(int page) // http://localhost:7742/api/test/1    {        return Json(new[] { "value3", "value4" });    }    [HttpGet("/api/path1")]    public IActionResult GetEpisodes1() // http://localhost:7742/api/path1    {        return Json(new[] { "value5", "value6" });    }    [HttpGet("/api/path2")]    public IActionResult GetEpisodes2() // http://localhost:7742/api/path2    {        try        {            // get data from the DB ...            return Ok(new[] { "value7", "value8" });        }        catch (Exception ex)        {            _logger.LogError("Failed to get data from the API", ex);            return BadRequest();        }    } 
}

    [Route("api/[controller]")]
    public class ValuesController : Controller
    {
        // GET: api/values
        [HttpGet]
        public IEnumerable<string> Get()
        {
            return new string[] { "value1", "value2" };
        }
// GET api/values/5
        [HttpGet("{id}")]
        public string Get(int id)
        {
            return "value";
        }
// POST api/values
        [HttpPost]
        public void Post([FromBody]string value)
        {
        }
// PUT api/values/5
        [HttpPut("{id}")]
        public void Put(int id, [FromBody]string value)
        {
        }
// DELETE api/values/5
        [HttpDelete("{id}")]
        public void Delete(int id)
        {
        }
    }
}

 [Produces("application/json")]
[Route("api/[controller]")] // http://localhost:7742/api/test
public class TestController : Controller

namespace Core1RtmEmptyTest.Models
{    public class Person    {        public string FirstName { get; set; }        public string LastName { get; set; }        public int Age { get; set; }    }
}

using Core1RtmEmptyTest.Models;
using Microsoft.AspNetCore.Mvc;
namespace Core1RtmEmptyTest.Controllers
{    public class PersonController : Controller    {        public IActionResult Index()        {            return View();        }        [HttpPost]        public IActionResult Index(Person person)        {            return Json(person);        }    }
}

@section scripts
{    <script type="text/javascript">        $(function () {            $.ajax({                type: 'POST',                url: '/Person/Index',                dataType: 'json',                contentType: 'application/json; charset=utf-8',                data: JSON.stringify({                    FirstName: 'F1',                    LastName: 'L1',                    Age: 23                }),                success: function (result) {                    console.log('Data received: ');                    console.log(result);                }            });        });    </script>
}

 public IActionResult Index([FromBody]Person person)

  var dataType = 'application/x-www-form-urlencoded; charset=utf-8';
 var data = $('form').serialize();

 [HttpPost]
public IActionResult Index([FromForm]Person person)

public class ProductModel
{
    public ProductModel(IProductService prodService)
    {
        Value = prodService.Get(productId);
    }
    public IProduct Value { get; private set; }
}

 public async Task<IActionResult> GetProduct([FromServices]ProductModel product)
{
}

public void ConfigureServices(IServiceCollection services)
{    services.AddMvc(options =>    {        options.FormatterMappings.SetMediaTypeMappingForFormat("xml", new MediaTypeHeaderValue("application/xml"));     }).AddJsonOptions(options =>    {        options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();        options.SerializerSettings.DefaultValueHandling = DefaultValueHandling.Include;        options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;    });

<system.web><globalization uiCulture="fa-IR" culture="fa-IR" /></system.web>

protected void Application_BeginRequest()
{
   Thread.CurrentThread.CurrentCulture = new CultureInfo("fa-IR");
   Thread.CurrentThread.CurrentUICulture = new CultureInfo("fa-IR");
}

public void Configure(IApplicationBuilder app)
{    app.UseRequestLocalization(new RequestLocalizationOptions    {        DefaultRequestCulture = new RequestCulture(new CultureInfo("fa-IR")),        SupportedCultures = new[]        {            new CultureInfo("en-US"),            new CultureInfo("fa-IR")        },        SupportedUICultures = new[]        {            new CultureInfo("en-US"),            new CultureInfo("fa-IR")        }    });

 c='en-UK'|uic='en-US'

public IActionResult SetFaLanguage()
{    Response.Cookies.Append(        CookieRequestCultureProvider.DefaultCookieName,        CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(new CultureInfo("fa-IR"))),        new CookieOptions { Expires = DateTimeOffset.UtcNow.AddYears(1) }    );    return RedirectToAction("GetTitle");
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddLocalization(options => options.ResourcesPath = "Resources");
    services.AddMvc()
        .AddViewLocalization(LanguageViewLocationExpanderFormat.Suffix)
        .AddDataAnnotationsLocalization();

using System;
using System.Globalization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Localization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Localization;
using Microsoft.Extensions.Localization;
namespace Core1RtmEmptyTest.Controllers
{    public class TestLocalController : Controller    {        private readonly IStringLocalizer<TestLocalController> _stringLocalizer;        private readonly IHtmlLocalizer<TestLocalController> _htmlLocalizer;        public TestLocalController(            IStringLocalizer<TestLocalController> stringLocalizer,            IHtmlLocalizer<TestLocalController> htmlLocalizer)        {            _stringLocalizer = stringLocalizer;            _htmlLocalizer = htmlLocalizer;        }        public IActionResult Index()        {            var name = "DNT";            var message = _htmlLocalizer["<b>Hello</b><i> {0}</i>", name];            ViewData["Message"] = message;            return View();        }        [HttpGet]        public string GetTitle()        {            var about = _stringLocalizer["About Title"];            return about;        }        public IActionResult SetFaLanguage()        {            Response.Cookies.Append(                CookieRequestCultureProvider.DefaultCookieName,                CookieRequestCultureProvider.MakeCookieValue(new RequestCulture(new CultureInfo("fa-IR"))),                new CookieOptions { Expires = DateTimeOffset.UtcNow.AddYears(1) }            );            return RedirectToAction("GetTitle");        }    }
}

@using Microsoft.AspNetCore.Mvc.Localization
@inject IViewLocalizer Localizer
@{
}
Message @ViewData["Message"]<br/>
@Localizer["<b>Hello</b><i> {0}</i>", "DNT"]<br/>
@Localizer["About Title"]

using System.ComponentModel.DataAnnotations;
namespace Core1RtmEmptyTest.ViewModels.Account
{    public class RegisterViewModel    {        [Required(ErrorMessage = "EmailReq")]        [EmailAddress(ErrorMessage = "EmailType")]        [Display(Name = "Email")]        public string Email { get; set; }    }
}

// Dummy class to group shared resources
namespace Core1RtmEmptyTest
{
   public class SharedResource
   {
   }
}

 IStringLocalizer<SharedResource> sharedLocalizer

 @inject IHtmlLocalizer<SharedResource> SharedLocalizer

namespace FiltersSample.Filters
{
    public class SampleActionFilter : IActionFilter
    {
        public void OnActionExecuting(ActionExecutingContext context)
        {
            // انجام کاری پیش از اجرای اکشن متد
        }

        public void OnActionExecuted(ActionExecutedContext context)
        {
            // انجام کاری پس از اجرای اکشن متد
        }
    }
}

namespace FiltersSample.Filters
{
    public class SampleAsyncActionFilter : IAsyncActionFilter
    {
        public async Task OnActionExecutionAsync(
            ActionExecutingContext context,
            ActionExecutionDelegate next)
        {
            // انجام کاری پیش از اجرای اکشن متد
            await next();
            // انجام کاری پس از اجرای اکشن متد
        }
    }
}

using Microsoft.AspNetCore.Mvc.Filters;
namespace FiltersSample.Filters
{
    public class AddHeaderAttribute : ResultFilterAttribute
    {
        private readonly string _name;
        private readonly string _value;
        public AddHeaderAttribute(string name, string value)
        {
            _name = name;
            _value = value;
        }

        public override void OnResultExecuting(ResultExecutingContext context)
        {
            context.HttpContext.Response.Headers.Add(
                _name, new string[] { _value });
            base.OnResultExecuting(context);
        }
    }
}

[AddHeader("Author", "DNT")]
public class SampleController : Controller
{
    public IActionResult Index()
    {
        return Content("با فایرباگ هدر خروجی را بررسی کنید");
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc(options =>
    {
        options.Filters.Add(typeof(SampleActionFilter)); // by type
        options.Filters.Add(new SampleGlobalActionFilter()); // an instance
    });
}

 [MyFilter(Name = "Method Level Attribute", Order=-1)]

[ServiceFilter(typeof(AddHeaderFilterWithDi))]
public IActionResult Index()
{
   return View();
}

 services.AddScoped<AddHeaderFilterWithDi>();

 System.InvalidOperationException: No service for type 'FiltersSample.Filters.AddHeaderFilterWithDI' has been registered.

[TypeFilter(typeof(AddHeaderAttribute),  Arguments = new object[] { "Author", "DNT" })]
public IActionResult Hi(string name)
{
   return Content($"Hi {name}");
}

using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.Extensions.Logging;
namespace Core1RtmEmptyTest.StartupCustomizations
{    public class CustomExceptionLoggingFilterAttribute : ExceptionFilterAttribute    {        private readonly ILogger<CustomExceptionLoggingFilterAttribute> _logger;        public CustomExceptionLoggingFilterAttribute(ILogger<CustomExceptionLoggingFilterAttribute> logger)        {            _logger = logger;        }        public override void OnException(ExceptionContext context)        {            _logger.LogInformation($"OnException: {context.Exception}");            base.OnException(context);        }    }
}

public void ConfigureServices(IServiceCollection services)
{    services.AddMvc(options =>    {        options.Filters.Add(typeof(CustomExceptionLoggingFilterAttribute));

public void Configure(ILoggerFactory loggerFactory)
{
   loggerFactory.AddDebug(minLevel: LogLevel.Debug);

public IActionResult GetData()
{
  throw new Exception("throwing an exception!");
}

"tools": {
    "BundlerMinifier.Core": "2.1.258"
},

No executable found matching command "dotnet-bundle"
Version for package `BundlerMinifier.Core` could not be resolved.

[    {        "outputFileName": "wwwroot/css/site.min.css",        "inputFiles": [            "wwwroot/css/site.css"        ]    },    {        "outputFileName": "wwwroot/js/site.min.js",        "inputFiles": [            "bower_components/jquery/dist/jquery.min.js",            "bower_components/jquery-validation/dist/jquery.validate.min.js",            "bower_components/jquery-validation-unobtrusive/jquery.validate.unobtrusive.min.js"        ],        "minify": {            "enabled": true,            "renameLocals": true        },        "sourceMap": false    }
]

"scripts": {    "precompile": [        "dotnet bundle"    ],    "prepublish": [        "bower install"    ],    "postpublish": [ "dotnet publish-iis --publish-folder %publish:OutputPath% --framework %publish:FullTargetFramework%" ]
}

<script src="~/js/site.min.js" asp-append-version="true" type="text/javascript"></script>

<?xml version="1.0" encoding="utf-8"?><configuration>  <system.webServer>    <handlers>      <add name="aspNetCore" path="*" verb="*"           modules="AspNetCoreModule" resourceType="Unspecified"/>    </handlers>    <aspNetCore processPath="%LAUNCHER_PATH%"                arguments="%LAUNCHER_ARGS%" stdoutLogEnabled="false"                stdoutLogFile=".\logs\stdout" forwardWindowsAuthToken="false"/>  </system.webServer></configuration>

 dotnet publish --framework netcoreapp1.0 --output "c:\temp\mysite" --configuration Release

{    "publishOptions": {        "include": [            "wwwroot",            "Features",            "appsettings.json",            "web.config"        ]    },    "scripts": {        "precompile": [            "dotnet bundle"        ],        "prepublish": [            //"bower install"        ],        "postpublish": [ "dotnet publish-iis --publish-folder %publish:OutputPath% --framework %publish:FullTargetFramework%" ]    }
}

<?xml version="1.0" encoding="utf-8"?><configuration><system.webServer><handlers><add name="aspNetCore" path="*" verb="*" modules="AspNetCoreModule" resourceType="Unspecified" /></handlers><aspNetCore processPath="dotnet" arguments=".\Core1RtmEmptyTest.dll" stdoutLogEnabled="true" stdoutLogFile=".\logs\stdout" forwardWindowsAuthToken="false" /></system.webServer></configuration>

 Warning: Could not create stdoutLogFile \\?\D:\Prog\1395\Core1RtmEmptyTest\src\Core1RtmEmptyTest\bin\Release\PublishOutput\logs\stdout_10064_201672893654.log, ErrorCode = -2147024893.

• All .NET application (Console, ASP.NET 4, WinForms, WPF)
 • Mac and Linux applications (Mono)
 • UWP (Universal Windows Platform)
 • ASP.NET Core applications
 • Can use EF Core in Windows phone and Windows store app

PM> Install-Package Microsoft.EntityFrameworkCore.SqlServer
PM> Install-Package Microsoft.EntityFrameworkCore.Tools -Pre
PM> Install-Package Microsoft.EntityFrameworkCore.SqlServer.Design

{
    "dependencies": {
       // same as before
        "Microsoft.EntityFrameworkCore.SqlServer": "1.0.0",
        "Microsoft.EntityFrameworkCore.Tools": "1.0.0-preview2-final",
        "Microsoft.EntityFrameworkCore.SqlServer.Design": "1.0.0"
    }
}

{
    "dependencies": {
       // same as before
        "Microsoft.EntityFrameworkCore.SqlServer": "1.0.0",
        "Microsoft.EntityFrameworkCore.Tools": {
            "version": "1.0.0-preview2-final",
            "type": "build"
        },
        "Microsoft.EntityFrameworkCore.SqlServer.Design": {
            "version": "1.0.0",
            "type": "build"
        }
    },

    "tools": {
       // same as before
        "Microsoft.EntityFrameworkCore.Tools": {
            "version": "1.0.0-preview2-final",
            "imports": [
                "portable-net45+win8"
            ]
        }   
   }
}

{
    "dependencies": {
       // same as before
        "Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore": "1.0.0"
    }
}

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
   if (env.IsDevelopment())
   {
      app.UseDatabaseErrorPage();
   }

namespace Core1RtmEmptyTest.Entities
{
    public class Person
    {
        public int PersonId { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
    }
}

using Microsoft.EntityFrameworkCore;

namespace Core1RtmEmptyTest.Entities
{
    public class ApplicationDbContext : DbContext
    {
        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
        {
        }

        public DbSet<Person> Persons { get; set; }
    }
}

protected DbContext()
   : this((DbContextOptions) new DbContextOptions<DbContext>())
{
}

public DbContext([NotNull] DbContextOptions options)
{
  // …
}

using Microsoft.EntityFrameworkCore;

namespace Core1RtmEmptyTest.Entities
{
    public class ApplicationDbContext : DbContext
    {
        public DbSet<Person> Persons { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlServer(@"... connection string ...");
        }
    }
}

{
    "ConnectionStrings": {
        "ApplicationDbContextConnection": "Data Source=(local);Initial Catalog=TestDbCore2016;Integrated Security = true"
    }
}

    public class Startup
    {
        public IConfigurationRoot Configuration { set; get; }

        public Startup(IHostingEnvironment env)
        {
            var builder = new ConfigurationBuilder()
                                .SetBasePath(env.ContentRootPath)
                                .AddJsonFile("appsettings.json", reloadOnChange: true, optional: false)
                                .AddJsonFile($"appsettings.{env}.json", optional: true);
            Configuration = builder.Build();
        }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddSingleton<IConfigurationRoot>(provider => { return Configuration; });
            services.AddDbContext<ApplicationDbContext>(options =>
            {
                options.UseSqlServer(Configuration["ConnectionStrings:ApplicationDbContextConnection"]);
            });

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;

namespace Core1RtmEmptyTest.Entities
{
    public class ApplicationDbContext : DbContext
    {
        private readonly IConfigurationRoot _configuration;

        public ApplicationDbContext(IConfigurationRoot configuration)
        {
            _configuration = configuration;
        }

        //public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
        //{
        //}

        public DbSet<Person> Persons { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlServer(_configuration["ConnectionStrings:ApplicationDbContextConnection"]);
        }
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>();

using System.Linq;
using Core1RtmEmptyTest.Entities;
using Microsoft.AspNetCore.Mvc;

namespace Core1RtmEmptyTest.Controllers
{
    public class TestDBController : Controller
    {
        private readonly ApplicationDbContext _ctx;

        public TestDBController(ApplicationDbContext ctx)
        {
            _ctx = ctx;
        }

        public IActionResult Index()
        {
            var name = _ctx.Persons.First().FirstName;
            return Json(new { firstName = name });
        }
    }
}

D:\Prog\1395\Core1RtmEmptyTest\src\Core1RtmEmptyTest>dotnet ef
                     _/\__
               ---==/    \\
         ___  ___   |.    \|\
        | __|| __|  |  )   \\\
        | _| | _|   \_/ |  //|\\
        |___||_|       /   \\\/\\
Entity Framework .NET Core CLI Commands 1.0.0-preview2-21431
Usage: dotnet ef [options] [command]
Options:
  -h|--help                      Show help information
  -v|--verbose                   Enable verbose output
  --version                      Show version information
  --assembly <ASSEMBLY>          The assembly file to load.
  --startup-assembly <ASSEMBLY>  The assembly file containing the startup class.
  --data-dir <DIR>               The folder used as the data directory (defaults to current working directory).
  --project-dir <DIR>            The folder used as the project directory (defaults to current working directory).
  --content-root-path <DIR>      The folder used as the content root path for the application (defaults to application base directory).
  --root-namespace <NAMESPACE>   The root namespace of the target project (defaults to the project assembly name).
Commands:
  database    Commands to manage your database
  dbcontext   Commands to manage your DbContext types
  migrations  Commands to manage your migrations
Use "dotnet ef [command] --help" for more information about a command.

 D:\Prog\1395\Core1RtmEmptyTest\src\Core1RtmEmptyTest>dotnet ef migrations add InitialDatabase

 D:\Prog\1395\Core1RtmEmptyTest\src\Core1RtmEmptyTest>dotnet ef database update
Applying migration '13950526050417_InitialDatabase'.
Done.

using System.Collections.Generic;
using System.Linq;
using Core1RtmEmptyTest.Entities;
using Microsoft.Extensions.DependencyInjection;

namespace Core1RtmEmptyTest.Migrations
{
    public static class ApplicationDbContextSeedData
    {
        public static void SeedData(this IServiceScopeFactory scopeFactory)
        {
            using (var serviceScope = scopeFactory.CreateScope())
            {
                var context = serviceScope.ServiceProvider.GetService<ApplicationDbContext>();
                if (!context.Persons.Any())
                {
                    var persons = new List<Person>
                    {
                        new Person
                        {
                            FirstName = "Admin",
                            LastName = "User"
                        }
                    };
                    context.AddRange(persons);
                    context.SaveChanges();
                }
            }
        }
    }
}

public void Configure(IServiceScopeFactory scopeFactory)
{
    scopeFactory.SeedData();

public void ConfigureServices(IServiceCollection services)
{
   services.AddDbContext<ApplicationDbContext>(ServiceLifetime.Scoped);

namespace Core1RtmEmptyTest.Entities
{
    public class Person
    {
        public int PersonId { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }

        public int Age { get; set; }
    }
}

 An unhandled exception occurred while processing the request.
SqlException: Invalid column name 'Age'.

D:\Prog\1395\Core1RtmEmptyTest\src\Core1RtmEmptyTest>dotnet ef migrations add v2
D:\Prog\1395\Core1RtmEmptyTest\src\Core1RtmEmptyTest>dotnet ef database update

 D:\Prog\1395\Core1RtmEmptyTest\src\Core1RtmEmptyTest>dotnet ef migrations script -o v2.sql

public Configuration()
{
   AutomaticMigrationsEnabled = true;
}

using Core1RtmEmptyTest.Entities;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;

namespace Core1RtmEmptyTest.Migrations
{
    public static class DbInitialization
    {
        public static void Initialize(this IServiceScopeFactory scopeFactory)
        {
            using (var serviceScope = scopeFactory.CreateScope())
            {
                var context = serviceScope.ServiceProvider.GetService<ApplicationDbContext>();
                // Applies any pending migrations for the context to the database.
                // Will create the database if it does not already exist.
                context.Database.Migrate();
            }
        }
    }
}

{
  "version": "1.0.0-*",

    "dependencies": {
        "Core1RtmEmptyTest.Entities": "1.0.0-*",
        "Microsoft.EntityFrameworkCore": "1.0.0",
        "Microsoft.EntityFrameworkCore.SqlServer": "1.0.0",
        "Microsoft.Extensions.Configuration.Abstractions": "1.0.0",
        "NETStandard.Library": "1.6.0"
    },

  "frameworks": {
    "netstandard1.6": {
      "imports": "dnxcore50"
    }
  }
}

{
    "dependencies": {
        // same as before
        "Core1RtmEmptyTest.Entities": "1.0.0-*",
        "Core1RtmEmptyTest.DataLayer": "1.0.0-*"
    }
}

D:\Prog\1395\Core1RtmEmptyTest\src\Core1RtmEmptyTest>dotnet ef migrations add InitialDatabase
Your target project 'Core1RtmEmptyTest' doesn't match your migrations assembly 'Core1RtmEmptyTest.DataLayer'.
Either change your target project or change your migrations assembly.

D:\Prog\1395\Core1RtmEmptyTest\src\Core1RtmEmptyTest.DataLayer>dotnet ef migrations add InitialDatabase
No executable found matching command "dotnet-ef"

{
     // same as before

    "tools": {
        "Microsoft.EntityFrameworkCore.Tools": {
            "version": "1.0.0-preview2-final",
            "imports": [
                "portable-net45+win8"
            ]
        }
    },

     // same as before
}

D:\Prog\1395\Core1RtmEmptyTest\src\Core1RtmEmptyTest.DataLayer>dotnet ef migrations add InitialDatabase
Could not invoke this command on the startup project 'Core1RtmEmptyTest.DataLayer'.
This preview of Entity Framework tools does not support commands on class library projects in ASP.NET Core and .NET Core applications.

 D:\Prog\1395\Core1RtmEmptyTest\src\Core1RtmEmptyTest.DataLayer>dotnet ef --startup-project ../Core1RtmEmptyTest/ migrations add InitialDatabase
Done. To undo this action, use 'dotnet ef migrations remove'

D:\Prog\1395\Core1RtmEmptyTest\src\Core1RtmEmptyTest.DataLayer>dotnet ef --startup-project ../Core1RtmEmptyTest/ database update
Applying migration '13950527070105_InitialDatabase'.
Done.

CREATE DATABASE [BloggingCore2016]
GO

USE [BloggingCore2016]
GO

CREATE TABLE [Blog] (
    [BlogId] int NOT NULL IDENTITY,
    [Url] nvarchar(max) NOT NULL,
    CONSTRAINT [PK_Blog] PRIMARY KEY ([BlogId])
);
GO

CREATE TABLE [Post] (
    [PostId] int NOT NULL IDENTITY,
    [BlogId] int NOT NULL,
    [Content] nvarchar(max),
    [Title] nvarchar(max),
    CONSTRAINT [PK_Post] PRIMARY KEY ([PostId]),
    CONSTRAINT [FK_Post_Blog_BlogId] FOREIGN KEY ([BlogId]) REFERENCES [Blog] ([BlogId]) ON DELETE CASCADE
);
GO

INSERT INTO [Blog] (Url) VALUES 
('http://www.dotnettips.info/'), 
('http://blogs.msdn.com/dotnet'), 
('http://blogs.msdn.com/webdev'), 
('http://blogs.msdn.com/visualstudio')
GO

 dotnet ef dbcontext scaffold "Data Source=(local);Initial Catalog=BloggingCore2016;Integrated Security = true" Microsoft.EntityFrameworkCore.SqlServer -o Entities --context MyDBDataContext --verbose

    public partial class MyDBDataContext : DbContext
    {
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlServer(@"Data Source=(local);Initial Catalog=BloggingCore2016;Integrated Security = true");
        }

 Usage: dotnet ef dbcontext scaffold [arguments] [options]
Arguments:
  [connection]  The connection string of the database
  [provider] The provider to use. For example, Microsoft.EntityFrameworkCore.SqlServer
Options:
  -a|--data-annotations   Use DataAnnotation attributes to configure the model where possible. If omitted, the output code will use only the fluent API.
  -c|--context <name> Name of the generated DbContext class.
  -f|--force Force scaffolding to overwrite existing files. Otherwise, the code will only proceed if no output files would be overwritten.
  -o|--output-dir <path> Directory of the project where the classes should be output. If omitted, the top-level project directory is used.
  --schema <schema> Selects a schema for which to generate classes.
  -t|--table <schema.table> Selects a table for which to generate classes.
  -e|--environment <environment>  The environment to use. If omitted, "Development" is used.
  -h|--help   Show help information
  -v|--verbose   Enable verbose output

 dotnet ef dbcontext scaffold "Data Source=(local);Initial Catalog=BloggingCore2016;Integrated Security = true" Microsoft.EntityFrameworkCore.SqlServer -o Entities --context MyDBDataContext --verbose --force --data-annotations

dotnet ef migrations add InitialDatabase

using Microsoft.EntityFrameworkCore.Migrations;

namespace Core1RtmEmptyTest.DataLayer.Migrations
{
    public partial class InitialDatabase : Migration
    {
        protected override void Up(MigrationBuilder migrationBuilder)
        {
        }

        protected override void Down(MigrationBuilder migrationBuilder)
        {
        }
    }
}

dotnet ef database update

dotnet ef migrations add v2
dotnet ef database update

public class Car
{
    public string Id { get; set; }

public class Car
{
   public string CarId { get; set; }

public class Car
{
   [Key]
   public string LicensePlate { get; set; }

public class MyContext : DbContext
{
    public DbSet<Car> Cars { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
         modelBuilder.Entity<Car>()
                 .HasKey(c => c.LicensePlate);
    }
 }

{
   "dependencies": {
          "System.ComponentModel.Annotations": "4.1.0"
   }
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
   modelBuilder.Entity<Car>()
                       .HasKey(c => new { c.State, c.LicensePlate });
}

public class Blog
{
    [DatabaseGenerated(DatabaseGeneratedOption.None)]
    public int BlogId { get; set; }

    public string Url { get; set; }
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
           .Property(b => b.BlogId)
           .ValueGeneratedNever();
}

public class Blog
{
   public int BlogId { get; set; }
   public string Url { get; set; }

   [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
   public DateTime Inserted { get; set; }
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
           .Property(b => b.Inserted)
           .ValueGeneratedOnAdd();
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .Property(b => b.Inserted)
        .HasDefaultValueSql("getdate()");
}

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    [DatabaseGenerated(DatabaseGeneratedOption.Computed)]
    public DateTime LastUpdated { get; set; }
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
       .Property(b => b.LastUpdated)
       .ValueGeneratedOnAddOrUpdate();
}

public class Person
{
    public int PersonId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string DisplayName { get; set; }
}

public class MyContext : DbContext
{
    public DbSet<Person> People { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
          modelBuilder.Entity<Person>()
              .Property(p => p.DisplayName)
               .HasComputedColumnSql("[LastName] + ', ' + [FirstName]");
     }
 }

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
     modelBuilder.HasSequence<int>("OrderNumbers", schema: "shared") 
           .StartsAt(1000).IncrementsBy(5);

     modelBuilder.Entity<Order>()
         .Property(o => o.OrderNo)
         .HasDefaultValueSql("NEXT VALUE FOR shared.OrderNumbers");
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.HasSequence<int>("PrimaryKeyWithSequenceSequence");
    modelBuilder.Entity<PrimaryKeyWithSequence>(entity =>
     {
       entity.Property(e => e.PrimaryKeyWithSequenceId).HasDefaultValueSql("NEXT VALUE FOR [PrimaryKeyWithSequenceSequence]");
     });
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
      modelBuilder.Entity<Blog>()
          .HasIndex(b => b.Url)
          .HasName("Index_Url");

 modelBuilder.Entity<Blog>().HasIndex(b => b.Url).HasName("Index_Url").IsUnique();

modelBuilder.Entity<Person>()
   .HasIndex(idx => new { idx.FirstName, idx.LastName })
   .IsUnique();

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
   modelBuilder.Entity<Car>()
     .HasAlternateKey(c => c.LicensePlate)
     .HasName("AlteranteKey_LicensePlate");
}

modelBuilder.Entity<Person>()
     .HasAlternateKey(x => new { x.FirstName, x.LastName });

 table.UniqueConstraint("AK_Persons_FirstName_LastName", x => new { x.FirstName, x.LastName });

 string, int?, byte[]

 int, decimal, bool, DateTime

 [Required]
public string Url { get; set; }

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
   modelBuilder.Entity<Blog>()
              .Property(b => b.Url)
              .IsRequired();
}

public string FirstName { get; set; }

  [StringLength(450)]
  public string FirstName { get; set; }

  [MaxLength(450)]
  public string LastName { get; set; }

  [MaxLength]
  public string Address { get; set; }

modelBuilder.Entity<Person>()
   .Property(x => x.Address)
   .HasMaxLength(450);

modelBuilder.Entity<Person>()
   .Property(x => x.Address)
   .HasColumnType("nvarchar(max)");

   [Column(TypeName = "varchar")]
  [MaxLength]
  public string Address { get; set; }

 Data type 'varchar' is not supported in this form. Either specify the length explicitly in the type name, for example as 'varchar(16)',
or remove the data type and use APIs such as HasMaxLength to allow EF choose the data type.

   [Column(TypeName = "varchar(max)")]

    public class Person 
    {
        public int Id { set; get; }

        public DateTime? DateAdded { set; get; }

        public DateTime? DateUpdated { set; get; }

        [StringLength(450)]
        public string FirstName { get; set; }

        [MaxLength(450)]
        public string LastName { get; set; }

        //[Column(TypeName = "varchar")]
        [MaxLength]
        public string Address { get; set; }


        //bit
        public bool IsActive { get; set; }

        //tiny Int
        public byte Age { get; set; }

        //small Int
        public short Short { get; set; }

        //int
        public int Int32 { get; set; }

        //Big int
        public long Long { get; set; }
    }

 CREATE TABLE [dbo].[Persons](
 [DateAdded] [datetime2](7) NULL,
 [DateUpdated] [datetime2](7) NULL,

 [ConcurrencyCheck]
public string Name { set; get; }

modelBuilder.Entity<Person>()
    .Property(p => p.Name)
    .IsConcurrencyToken();

 [Timestamp]
 public byte[] Timestamp { get; set; }

modelBuilder.Entity<Blog>()
   .Property(p => p.Timestamp)
   .ValueGeneratedOnAddOrUpdate()
   .IsConcurrencyToken();

 dotnet ef dbcontext scaffold "Data Source=(local);Initial Catalog=BloggingCore2016;Integrated Security = true" Microsoft.EntityFrameworkCore.SqlServer -o Entities --context MyDBDataContext --verbose

using System;
using System.Collections.Generic;

namespace Core1RtmEmptyTest.Entities
{
    public partial class Blog
    {
        public Blog()
        {
            Post = new HashSet<Post>();
        }

        public int BlogId { get; set; }
        public string Url { get; set; }

        public virtual ICollection<Post> Post { get; set; }
    }
}

using System;
using System.Collections.Generic;

namespace Core1RtmEmptyTest.Entities
{
    public partial class Post
    {
        public int PostId { get; set; }
        public string Content { get; set; }
        public string Title { get; set; }

        public virtual Blog Blog { get; set; }
        public int BlogId { get; set; }
    }
}

using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;

namespace Core1RtmEmptyTest.Entities
{
    public partial class MyDBDataContext : DbContext
    {
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlServer(@"Data Source=(local);Initial Catalog=BloggingCore2016;Integrated Security = true");
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Blog>(entity =>
            {
                entity.Property(e => e.Url).IsRequired();
            });

            modelBuilder.Entity<Post>(entity =>
            {
                entity.HasOne(d => d.Blog)
                    .WithMany(p => p.Post)
                    .HasForeignKey(d => d.BlogId);
            });
        }

        public virtual DbSet<Blog> Blog { get; set; }
        public virtual DbSet<Post> Post { get; set; }
    }
}

 public virtual Blog Blog { get; set; }

 public virtual ICollection<Post> Post { get; set; }

<primary key property name><navigation property name><primary key property name><principal entity name><primary key property name>

  public virtual Blog Blog { get; set; }
  public int BlogId { get; set; }

modelBuilder.Entity<Post>(entity =>
{
    entity.HasOne(d => d.Blog)
             .WithMany(p => p.Post)
             .HasForeignKey(d => d.BlogId);
});

 dotnet ef dbcontext scaffold "Data Source=(local);Initial Catalog=BloggingCore2016;Integrated Security = true" Microsoft.EntityFrameworkCore.SqlServer -o Entities --context MyDBDataContext --verbose -a

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace Core1RtmEmptyTest.Entities
{
    public partial class Blog
    {
        public Blog()
        {
            Post = new HashSet<Post>();
        }

        public int BlogId { get; set; }

        [Required]
        public string Url { get; set; }

        [InverseProperty("Blog")]
        public virtual ICollection<Post> Post { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace Core1RtmEmptyTest.Entities
{
    public partial class Post
    {
        public int PostId { get; set; }
        public string Content { get; set; }
        public string Title { get; set; }

        [ForeignKey("BlogId")]
        [InverseProperty("Post")]
        public virtual Blog Blog { get; set; }
        public int BlogId { get; set; }
    }
}

using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;

namespace Core1RtmEmptyTest.Entities
{
    public partial class MyDBDataContext : DbContext
    {
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlServer(@"Data Source=(local);Initial Catalog=BloggingCore2016;Integrated Security = true");
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
        }

        public virtual DbSet<Blog> Blog { get; set; }
        public virtual DbSet<Post> Post { get; set; }
    }
}

  [ForeignKey("BlogId")]
  [InverseProperty("Post")]
  public virtual Blog Blog { get; set; }
  public int BlogId { get; set; }

   [InverseProperty("Blog")]
  public virtual ICollection<Post> Post { get; set; }

public virtual Blog Blog { get; set; }

 var firstPost = context.Post.First();
Console.WriteLine(firstPost.Blog.Url);

 System.NullReferenceException
Object reference not set to an instance of an object.

 var firstPost = context.Post.Include(x => x.Blog).First();
Console.WriteLine(firstPost.Blog.Url);

var blogs = context.Blogs
                              .Include(blog => blog.Posts)
                              .Include(blog => blog.Owner)
                              .ToList();

var blogs = context.Blogs
                              .Include(blog => blog.Posts)
                                      .ThenInclude(post => post.Author)
                              .ToList();

var blogs = context.Blogs
                              .Include(blog => blog.Posts)
                                 .ThenInclude(post => post.Author)
                                        .ThenInclude(author => author.Photo)
                              .ToList();

var blogs = context.Blogs
                              .Include(blog => blog.Posts)
                                  .ThenInclude(post => post.Author)
                                      .ThenInclude(author => author.Photo)
                              .Include(blog => blog.Owner)
                                    .ThenInclude(owner => owner.Photo)
                              .ToList();

var blogs = context.Blogs
                              .Include(blog => blog.Posts)
                              .Select(blog => new
                               {
                                  Id = blog.BlogId,
                                  Url = blog.Url
                               })
                               .ToList();

 CONSTRAINT [FK_Post_Blog_BlogId] FOREIGN KEY ([BlogId]) REFERENCES [Blog] ([BlogId]) ON DELETE CASCADE

modelBuilder.Entity<Post>()
                    .HasOne(p => p.Blog)
                    .WithMany(b => b.Posts)
                    .OnDelete(DeleteBehavior.Cascade);

modelBuilder.Entity<Post>()
                    .HasOne(p => p.Blog)
                    .WithMany(b => b.Posts)
                    .IsRequired();