PM> Install-Package Microsoft.CodeAnalysis

using System;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
namespace Roslyn01
{    class Program    {        static void Main(string[] args)        {            parseText();        }        static void parseText()        {            var tree = CSharpSyntaxTree.ParseText("class Foo { void Bar(int x) {} }");            Console.WriteLine(tree.ToString());            Console.WriteLine(tree.GetRoot().NormalizeWhitespace().ToString());            var res = SyntaxFactory.ClassDeclaration("Foo")                .WithMembers(SyntaxFactory.List<MemberDeclarationSyntax>(new[] {                    SyntaxFactory.MethodDeclaration(                        SyntaxFactory.PredefinedType(                            SyntaxFactory.Token(SyntaxKind.VoidKeyword)                        ),                        "Bar"                    )                    .WithBody(SyntaxFactory.Block())                }))                .NormalizeWhitespace();            Console.WriteLine(res);        }     }
}

 tree.GetRoot().NormalizeWhitespace().ToString()

class Foo
{
    void Bar(int x)
    {
    }
}

static void querySyntaxTree()
{    var tree = CSharpSyntaxTree.ParseText("class Foo { void Bar() {} }");    var node = (CompilationUnitSyntax)tree.GetRoot();    // Using the object model    foreach (var member in node.Members)    {        if (member.Kind() == SyntaxKind.ClassDeclaration)        {            var @class = (ClassDeclarationSyntax)member;            foreach (var member2 in @class.Members)            {                if (member2.Kind() == SyntaxKind.MethodDeclaration)                {                    var method = (MethodDeclarationSyntax)member2;                    // do stuff                }            }        }    }    // Using LINQ query methods    var bars = from member in node.Members.OfType<ClassDeclarationSyntax>()               from member2 in member.Members.OfType<MethodDeclarationSyntax>()               where member2.Identifier.Text == "Bar"               select member2;    var res = bars.ToList();    // Using visitors    new MyVisitor().Visit(node);
}

class MyVisitor : CSharpSyntaxWalker
{    public override void VisitMethodDeclaration(MethodDeclarationSyntax node)    {        if (node.Identifier.Text == "Bar")        {            // do stuff        }        base.VisitMethodDeclaration(node);    }
}

 new MyVisitor().Visit(node);

static void firstCompilation()
{    var tree = CSharpSyntaxTree.ParseText("class Foo { void Bar(int x) {} }");    var mscorlibReference = MetadataReference.CreateFromFile(typeof (object).Assembly.Location);    var compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);    var comp = CSharpCompilation.Create("Demo")                                .AddSyntaxTrees(tree)                                .AddReferences(mscorlibReference)                                .WithOptions(compilationOptions);    var res = comp.Emit("Demo.dll");    if (!res.Success)    {        foreach (var diagnostic in res.Diagnostics)        {            Console.WriteLine(diagnostic.GetMessage());        }    }
}

        static void semanticQuestions()        {            var tree = CSharpSyntaxTree.ParseText(@"
using System;
class Foo
{    public static explicit operator DateTime(Foo f)    {        throw new NotImplementedException();    }    void Bar(int x)    {    }
}");            var mscorlib = MetadataReference.CreateFromFile(typeof (object).Assembly.Location);            var options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);            var comp = CSharpCompilation.Create("Demo").AddSyntaxTrees(tree).AddReferences(mscorlib).WithOptions(options);            // var res = comp.Emit("Demo.dll");            // boxing            var conv1 = comp.ClassifyConversion(                comp.GetSpecialType(SpecialType.System_Int32),                comp.GetSpecialType(SpecialType.System_Object)                );            // unboxing            var conv2 = comp.ClassifyConversion(                comp.GetSpecialType(SpecialType.System_Object),                comp.GetSpecialType(SpecialType.System_Int32)                );            // explicit reference conversion            var conv3 = comp.ClassifyConversion(                comp.GetSpecialType(SpecialType.System_Object),                comp.GetTypeByMetadataName("Foo")                );            // explicit user-supplied conversion            var conv4 = comp.ClassifyConversion(                comp.GetTypeByMetadataName("Foo"),                comp.GetSpecialType(SpecialType.System_DateTime)                );        }

    public struct Optional<T>
    {
        public bool HasValue { get; }
        public T Value { get; }
    }

class ConsoleWriteLineWalker : CSharpSyntaxWalker
{    public ConsoleWriteLineWalker()    {        Arguments = new List<ExpressionSyntax>();    }    public List<ExpressionSyntax> Arguments { get; }    public override void VisitInvocationExpression(InvocationExpressionSyntax node)    {        var member = node.Expression as MemberAccessExpressionSyntax;        var type = member?.Expression as IdentifierNameSyntax;        if (type != null && type.Identifier.Text == "Console" && member.Name.Identifier.Text == "WriteLine")        {            if (node.ArgumentList.Arguments.Count == 1)            {                var arg = node.ArgumentList.Arguments.Single().Expression;                Arguments.Add(arg);                return;            }        }        base.VisitInvocationExpression(node);    }
}

static void getConstantValue()
{    // Get the syntax tree.    var code = @"                using System;                class Foo                {                    void Bar(int x)                    {                        Console.WriteLine(3.14);                        Console.WriteLine(""qux"");                        Console.WriteLine('c');                        Console.WriteLine(null);                        Console.WriteLine(x * 2 + 1);                    }                }                ";    var tree = CSharpSyntaxTree.ParseText(code);    var root = tree.GetRoot();    // Get the semantic model from the compilation.    var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);    var comp = CSharpCompilation.Create("Demo").AddSyntaxTrees(tree).AddReferences(mscorlib);    var model = comp.GetSemanticModel(tree);    // Traverse the tree.    var walker = new ConsoleWriteLineWalker();    walker.Visit(root);    // Analyze the constant argument (if any).    foreach (var arg in walker.Arguments)    {        var val = model.GetConstantValue(arg);        if (val.HasValue)        {            Console.WriteLine(arg + " has constant value " + (val.Value ?? "null") + " of type " + (val.Value?.GetType() ?? typeof(object)));        }        else        {            Console.WriteLine(arg + " has no constant value");        }    }
}

 3.14 has constant value 3.14 of type System.Double
"qux" has constant value qux of type System.String
'c' has constant value c of type System.Char
null has constant value null of type System.Object
x * 2 + 1 has no constant value

static void workingWithSymbols()
{    // Get the syntax tree.    var code = @"                using System;                class Foo                {                    void Bar(int x)                    {                        // #insideBar                    }                }                class Qux                {                    protected int Baz { get; set; }                }                ";    var tree = CSharpSyntaxTree.ParseText(code);    var root = tree.GetRoot();    // Get the semantic model from the compilation.    var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);    var comp = CSharpCompilation.Create("Demo").AddSyntaxTrees(tree).AddReferences(mscorlib);    var model = comp.GetSemanticModel(tree);    // Traverse enclosing symbol hierarchy.    var cursor = code.IndexOf("#insideBar");    var barSymbol = model.GetEnclosingSymbol(cursor);    for (var symbol = barSymbol; symbol != null; symbol = symbol.ContainingSymbol)    {        Console.WriteLine(symbol);    }    // Analyze accessibility of Baz inside Bar.    var bazProp = ((CompilationUnitSyntax)root)        .Members.OfType<ClassDeclarationSyntax>()        .Single(m => m.Identifier.Text == "Qux")        .Members.OfType<PropertyDeclarationSyntax>()        .Single();    var bazSymbol = model.GetDeclaredSymbol(bazProp);    var canAccess = model.IsAccessible(cursor, bazSymbol);
}

 Foo.Bar(int)
Foo<global namespace>
Demo.exe
Demo, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null

static void bindingSymbols()
{    // Get the syntax tree.    var code = @"                using System;                class Foo                {                    private int y;                    void Bar(int x)                    {                        Console.WriteLine(x);                        Console.WriteLine(y);                        int z = 42;                        Console.WriteLine(z);                        Console.WriteLine(a);                    }                }";    var tree = CSharpSyntaxTree.ParseText(code);    var root = tree.GetRoot();    // Get the semantic model from the compilation.    var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);    var comp = CSharpCompilation.Create("Demo").AddSyntaxTrees(tree).AddReferences(mscorlib);    var model = comp.GetSemanticModel(tree);    // Traverse the tree.    var walker = new ConsoleWriteLineWalker();    walker.Visit(root);    // Bind the arguments.    foreach (var arg in walker.Arguments)    {        var symbol = model.GetSymbolInfo(arg);        if (symbol.Symbol != null)        {            Console.WriteLine(arg + " is bound to " + symbol.Symbol + " of type " + symbol.Symbol.Kind);        }        else        {            Console.WriteLine(arg + " could not be bound");        }    }
}

 x is bound to int of type Parameter
y is bound to Foo.y of type Field
z is bound to z of type Local
a could not be bound

    public class Student    {        public string FirstName;        public string LastName;        public int TotalPointsEarned;        public void TakeExam(int pointsForExam)        {            TotalPointsEarned += pointsForExam;        }        public void ExtraCredit(int extraPoints)        {            TotalPointsEarned += extraPoints;        }        public int PointsEarned { get { return TotalPointsEarned; } }    }

using System.Collections.Immutable;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;
namespace CodingStandards
{    [DiagnosticAnalyzer(LanguageNames.CSharp)]    public class CodingStandardsAnalyzer : DiagnosticAnalyzer    {        public const string DiagnosticId = "CodingStandards";        // You can change these strings in the Resources.resx file. If you do not want your analyzer to be localize-able, you can use regular strings for Title and MessageFormat.        internal static readonly LocalizableString Title = new LocalizableResourceString(nameof(Resources.AnalyzerTitle), Resources.ResourceManager, typeof(Resources));        internal static readonly LocalizableString MessageFormat = new LocalizableResourceString(nameof(Resources.AnalyzerMessageFormat), Resources.ResourceManager, typeof(Resources));        internal static readonly LocalizableString Description = new LocalizableResourceString(nameof(Resources.AnalyzerDescription), Resources.ResourceManager, typeof(Resources));        internal const string Category = "Naming";        internal static DiagnosticDescriptor Rule =             new DiagnosticDescriptor(                DiagnosticId,                 Title,                 MessageFormat,                 Category,                 DiagnosticSeverity.Error,                 isEnabledByDefault: true,                 description: Description);        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics        {            get { return ImmutableArray.Create(Rule); }        }        public override void Initialize(AnalysisContext context)        {            // TODO: Consider registering other actions that act on syntax instead of or in addition to symbols            context.RegisterSyntaxNodeAction(analyzeFieldDeclaration, SyntaxKind.FieldDeclaration);        }        static void analyzeFieldDeclaration(SyntaxNodeAnalysisContext context)        {            var fieldDeclaration = context.Node as FieldDeclarationSyntax;            if (fieldDeclaration == null) return;            var accessToken = fieldDeclaration                                .ChildTokens()                                .SingleOrDefault(token => token.Kind() == SyntaxKind.PublicKeyword);            // Note: Not finding protected or internal            if (accessToken.Kind() != SyntaxKind.None)            {                // Find the name of the field:                var name = fieldDeclaration.DescendantTokens()                              .SingleOrDefault(token => token.IsKind(SyntaxKind.IdentifierToken)).Value;                var diagnostic = Diagnostic.Create(Rule, fieldDeclaration.GetLocation(), name, accessToken.Value);                context.ReportDiagnostic(diagnostic);            }        }    }
}

using System.Collections.Immutable;
using System.Composition;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.CodeActions;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
namespace CodingStandards
{    [ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(CodingStandardsCodeFixProvider)), Shared]    public class CodingStandardsCodeFixProvider : CodeFixProvider    {        public sealed override ImmutableArray<string> FixableDiagnosticIds        {            get { return ImmutableArray.Create(CodingStandardsAnalyzer.DiagnosticId); }        }        public sealed override FixAllProvider GetFixAllProvider()        {            return WellKnownFixAllProviders.BatchFixer;        }        public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)        {            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);            // TODO: Replace the following code with your own analysis, generating a CodeAction for each fix to suggest            var diagnostic = context.Diagnostics.First();            var diagnosticSpan = diagnostic.Location.SourceSpan;            // Find the type declaration identified by the diagnostic.            var declaration = root.FindToken(diagnosticSpan.Start)                                   .Parent.AncestorsAndSelf().OfType<FieldDeclarationSyntax>()                                   .First();            // Register a code action that will invoke the fix.            context.RegisterCodeFix(                CodeAction.Create("Make Private",                 c => makePrivateDeclarationAsync(context.Document, declaration, c)),                diagnostic);        }        async Task<Document> makePrivateDeclarationAsync(Document document, FieldDeclarationSyntax declaration, CancellationToken c)        {            var accessToken = declaration.ChildTokens()                .SingleOrDefault(token => token.Kind() == SyntaxKind.PublicKeyword);            var privateAccessToken = SyntaxFactory.Token(SyntaxKind.PrivateKeyword);            var root = await document.GetSyntaxRootAsync(c);            var newRoot = root.ReplaceToken(accessToken, privateAccessToken);            return document.WithSyntaxRoot(newRoot);        }    }
}

var ws = MSBuildWorkspace.Create();
var sln = ws.OpenSolutionAsync(@"..\..\..\Roslyn.sln").Result;


// Print the root of the solution.
Console.WriteLine(Path.GetFileName(sln.FilePath));
// Get dependency graph to perform a sort.
var g = sln.GetProjectDependencyGraph();
var ps = g.GetTopologicallySortedProjects();
// Print all projects, their documents, and references.
foreach (var p in ps)
{    var proj = sln.GetProject(p);    Console.WriteLine("> " + proj.Name);    Console.WriteLine("  > References");    foreach (var r in proj.ProjectReferences)    {        Console.WriteLine("    - " + sln.GetProject(r.ProjectId).Name);    }    foreach (var d in proj.Documents)    {        Console.WriteLine("  - " + d.Name);    }
}

 Roslyn.sln> Roslyn01> References
  - Program.cs
  - AssemblyInfo.cs
  - .NETFramework,Version=v4.6.AssemblyAttributes.cs

var ws = MSBuildWorkspace.Create();
var sln = ws.OpenSolutionAsync(@"..\..\..\Roslyn.sln").Result;

// Get the Tests\Bar.cs document.
var proj = sln.Projects.Single(p => p.Name == "Roslyn04.Tests");
var test = proj.Documents.Single(d => d.Name == "Bar.cs");
var tree = test.GetSyntaxTreeAsync().Result;
var root = tree.GetRootAsync().Result;
// Get all the spans in the document that are classified as language elements.
var spans = Classifier.GetClassifiedSpansAsync(test, root.FullSpan).Result.ToDictionary(c => c.TextSpan.Start, c => c);
// Print the source text with appropriate colorization.
var txt = tree.GetText().ToString();
var i = 0;
foreach (var c in txt)
{    var span = default(ClassifiedSpan);    if (spans.TryGetValue(i, out span))    {        var color = ConsoleColor.Gray;        switch (span.ClassificationType)        {            case ClassificationTypeNames.Keyword:                color = ConsoleColor.Cyan;                break;            case ClassificationTypeNames.StringLiteral:            case ClassificationTypeNames.VerbatimStringLiteral:                color = ConsoleColor.Red;                break;            case ClassificationTypeNames.Comment:                color = ConsoleColor.Green;                break;            case ClassificationTypeNames.ClassName:            case ClassificationTypeNames.InterfaceName:            case ClassificationTypeNames.StructName:            case ClassificationTypeNames.EnumName:            case ClassificationTypeNames.TypeParameterName:            case ClassificationTypeNames.DelegateName:                color = ConsoleColor.Yellow;                break;            case ClassificationTypeNames.Identifier:                color = ConsoleColor.DarkGray;                break;        }        Console.ForegroundColor = color;    }    Console.Write(c);    i++;
}

var ws = MSBuildWorkspace.Create();
var sln = ws.OpenSolutionAsync(@"..\..\..\Roslyn.sln").Result;


// Get the Tests\Qux.cs document.
var proj = sln.Projects.Single(p => p.Name == "Roslyn04.Tests");
var qux = proj.Documents.Single(d => d.Name == "Qux.cs");
Console.WriteLine("Before:");
Console.WriteLine();
Console.WriteLine(qux.GetSyntaxTreeAsync().Result.GetText());
Console.WriteLine();
Console.WriteLine();
// Apply formatting and print the result.
var res = Formatter.FormatAsync(qux).Result;
Console.WriteLine("After:");
Console.WriteLine();
Console.WriteLine(res.GetSyntaxTreeAsync().Result.GetText());
Console.WriteLine();

Before:

using System;

namespace Roslyn04.Tests
{
    class Qux {
        public void Baz()
        { Console.WriteLine(42);
            return;  }
    }
}


After:

using System;

namespace Roslyn04.Tests
{
    class Qux
    {
        public void Baz()
        {
            Console.WriteLine(42);
            return;
        }
    }
}

var ws = MSBuildWorkspace.Create();
var sln = ws.OpenSolutionAsync(@"..\..\..\Roslyn.sln").Result;


// Get the Tests project.
var proj = sln.Projects.Single(p => p.Name == "Roslyn04.Tests");
// Locate the symbol for the Bar.Foo method and the Bar.Qux property.
var comp = proj.GetCompilationAsync().Result;
var barType = comp.GetTypeByMetadataName("Roslyn04.Tests.Bar");
var fooMethod = barType.GetMembers().Single(m => m.Name == "Foo");
var quxProp = barType.GetMembers().Single(m => m.Name == "Qux");
// Find callers across the solution.
Console.WriteLine("Find callers of Foo");
Console.WriteLine();
var callers = SymbolFinder.FindCallersAsync(fooMethod, sln).Result;
foreach (var caller in callers)
{    Console.WriteLine(caller.CallingSymbol);    foreach (var location in caller.Locations)    {        Console.WriteLine("    " + location);    }
}
Console.WriteLine();
Console.WriteLine();
// Find all references across the solution.
Console.WriteLine("Find all references to Qux");
Console.WriteLine();
var references = SymbolFinder.FindReferencesAsync(quxProp, sln).Result;
foreach (var reference in references)
{    Console.WriteLine(reference.Definition);    foreach (var location in reference.Locations)    {        Console.WriteLine("    " + location.Location);    }
}

var ws = MSBuildWorkspace.Create();
var sln = ws.OpenSolutionAsync(@"..\..\..\Roslyn.sln").Result;

// Get the Tests\Foo.cs document.
var proj = sln.Projects.Single(p => p.Name == "Roslyn04.Tests");
var foo = proj.Documents.Single(d => d.Name == "Foo.cs");
// Find the 'dot' token in the first Console.WriteLine member access expression.
var tree = foo.GetSyntaxTreeAsync().Result;
var model = proj.GetCompilationAsync().Result.GetSemanticModel(tree);
var consoleDot = tree.GetRoot().DescendantNodes().OfType<MemberAccessExpressionSyntax>().First().OperatorToken;
// Get recommendations at the indicated cursor position.
//
//   Console.WriteLine
//           ^
var res = Recommender.GetRecommendedSymbolsAtPosition(

                    model, consoleDot.GetLocation().SourceSpan.Start + 1, ws).ToList();
foreach (var rec in res)
{    Console.WriteLine(rec);
}

 System.Console.Beep()
System.Console.Beep(int, int)
System.Console.Clear()

var ws = MSBuildWorkspace.Create();
var sln = ws.OpenSolutionAsync(@"..\..\..\Roslyn.sln").Result;


// Get Tests\Bar.cs before making changes.
var oldProj = sln.Projects.Single(p => p.Name == "Roslyn04.Tests");
var oldDoc = oldProj.Documents.Single(d => d.Name == "Bar.cs");
Console.WriteLine("Before:");
Console.WriteLine();
var oldTxt = oldDoc.GetTextAsync().Result;
Console.WriteLine(oldTxt);
Console.WriteLine();
Console.WriteLine();
// Get the symbol for the Bar.Foo method.
var comp = oldProj.GetCompilationAsync().Result;
var barType = comp.GetTypeByMetadataName("Roslyn04.Tests.Bar");
var fooMethod = barType.GetMembers().Single(m => m.Name == "Foo");
// Perform the rename.
var newSln = Renamer.RenameSymbolAsync(sln, fooMethod, "Foo2", ws.Options).Result;
// Get Tests\Bar.cs after making changes.
var newProj = newSln.Projects.Single(p => p.Name == "Roslyn04.Tests");
var newDoc = newProj.Documents.Single(d => d.Name == "Bar.cs");
Console.WriteLine("After:");
Console.WriteLine();
var newTxt = newDoc.GetTextAsync().Result;
Console.WriteLine(newTxt);

var ws = MSBuildWorkspace.Create();
var sln = ws.OpenSolutionAsync(@"..\..\..\Roslyn.sln").Result;


// Get the Tests\Baz.cs document.
var proj = sln.Projects.Single(p => p.Name == "Roslyn04.Tests");
var baz = proj.Documents.Single(d => d.Name == "Baz.cs");
Console.WriteLine("Before:");
Console.WriteLine();
Console.WriteLine(baz.GetSyntaxTreeAsync().Result.GetText());
Console.WriteLine();
Console.WriteLine();
var oldRoot = baz.GetSyntaxRootAsync().Result;

 
var memberAccesses = oldRoot.DescendantNodes().OfType<CastExpressionSyntax>();
var newRoot = oldRoot.ReplaceNodes(memberAccesses, (_, m) => m.WithAdditionalAnnotations(Simplifier.Annotation));
var newDoc = baz.WithSyntaxRoot(newRoot);
// Invoke the simplifier and print the result.
var res = Simplifier.ReduceAsync(newDoc).Result;
Console.WriteLine("After:");
Console.WriteLine();
Console.WriteLine(res.GetSyntaxTreeAsync().Result.GetText());
Console.WriteLine();

using System;
namespace CS6NewFeatures
{    class Person    {        public string FirstName { set; get; }        public string LastName { set; get; }        public int Age { set; get; }    }    class Program    {        static void Main(string[] args)        {            var person = new Person { FirstName = "User 1", LastName = "Last Name 1", Age = 50 };            var message = string.Format("Hello!  My name is {0} {1} and I am {2} years old.",                                          person.FirstName, person.LastName, person.Age);            Console.Write(message);        }    }
}

static void Main(string[] args)
{    var person = new Person { FirstName = "User 1", LastName = "Last Name 1", Age = 50 };    var message = $"Hello!  My name is {person.FirstName} {person.LastName} and I am {person.Age} years old.";    Console.Write(message);
}

 var message2 = $"{Environment.NewLine}Test {DateTime.Now}, {3*2}";
Console.Write(message2);

 var message3 = $"{Environment.NewLine}{1000000:n0} {DateTime.Now:dd-MM-yyyy}";
Console.Write(message3);

class MyDateFormatProvider : IFormatProvider
{    readonly MyDateFormatter _formatter = new MyDateFormatter();    public object GetFormat(Type formatType)    {        return formatType == typeof(ICustomFormatter) ? _formatter : null;    }    class MyDateFormatter : ICustomFormatter    {        public string Format(string format, object arg, IFormatProvider formatProvider)        {            if (arg is DateTime)                return ((DateTime)arg).ToString("MM/dd/yyyy");            return arg.ToString();        }    }
}

static string formatMyDate(FormattableString formattable)
{
      return formattable.ToString(new MyDateFormatProvider());
}

 var message2 = formatMyDate($"{Environment.NewLine}Test {DateTime.Now}, {3*2}");
Console.Write(message2);

public static string faIr(IFormattable formattable)
{
    return formattable.ToString(null, new CultureInfo("fa-Ir"));
}

 static string invariant(FormattableString formattable)
{
    return formattable.ToString(CultureInfo.InvariantCulture);
}

 var message0 = $"Hello! My name is {person.FirstName} {{person.FirstName}}";

 Console.Write($"{(person.Age>50 ? "old": "young")}");

 string data = null;
var result = data ?? "value";

if (data == null)
{
    data = "value";
}
var result = data;

class Response
{    public string Result { set; get; }    public int Code { set; get; }
}

 
class WebRequest
{    public Response GetDataFromWeb(string url)    {        // ...        return new Response { Result = null };    }
}

 var webData = new WebRequest().GetDataFromWeb("http://www.dotnettips.info/");
if (webData != null && webData.Result != null)
{
    Console.WriteLine(webData.Result);
}

 if (webData?.Result != null)
{
    Console.WriteLine(webData.Result);
}

 if (x != null)
{
   x.Dispose();
}

 x?.Dispose();

 var copy = OnMyEvent;
if (copy != null)
{
   copy(this, new EventArgs());
}

 OnMyEvent?.Invoke(this, new EventArgs());

 var code = webData?.Code;

 if (webData?.Code > 0)
{

}

 int count = response?.Results?.Count ?? 0;

 int? x = 10;
//var value = x?.Value; // invalid
Console.WriteLine(x?.ToString());

 if (response != null && response.Results != null && response.Results.Addresses != null&& response.Results.Addresses[0] != null && response.Results.Addresses[0].Zip == "63368")
{

}

 if(response?.Results?.Addresses?[0]?.Zip == "63368")
{

}

 public void DoSomething(Customer customer)
{
    string address = customer?.Employees
                  ?.SingleOrDefault(x => x.IsAdmin)?.Address?.ToString();
    SendPackage(address);
}

 public void DoSomething(Customer customer)
{
   Contract.Requires(customer != null); 
   string address = customer.GetAdminAddress();
   SendPackage(address);
}

try
{    // some code to check  ...
}
catch (InvalidOperationException ex)
{    // do your handling for invalid operation ...
}
catch (IOException ex)
{    // do your handling for IO error ...
}

 catch (SomeException ex) when (someConditionIsMet)
{
    // Your handler logic
}

 catch (SomeDependencyException ex) when (condition1 && condition2)
{
}
catch (SomeDependencyException ex) when (condition1)
{
}
catch (SomeDependencyException ex)
{
}

 catch (SomeDependencyException ex)
{
}
catch (SomeDependencyException ex) when (condition1 && condition2)
{
}
catch (SomeDependencyException ex) when (condition1)
{
}

 try
{
    DoSomethingThatMightFail(s);
}
catch (Exception ex) when (Log(ex, "An error occurred"))
{
    // this catch block will never be reached
}

...

static bool Log(Exception ex, string message, params object[] args)
{
   Debug.Print(message, args);
   return false;
}

try
{    var request = WebRequest.Create("http://www.google.coom/");    var response = request.GetResponse();
}
catch (WebException we)
{    if (we.Status == WebExceptionStatus.NameResolutionFailure)    {        //handle DNS error        return;    }    if (we.Status == WebExceptionStatus.ConnectFailure)    {        //handle connection error        return;    }    throw;
}

try
{    var request = WebRequest.Create("http://www.google.coom/");    var response = request.GetResponse();
}
catch (WebException we) when (we.Status == WebExceptionStatus.NameResolutionFailure)
{    //Handle NameResolutionFailure Separately
}
catch (WebException we) when (we.Status == WebExceptionStatus.ConnectFailure)
{    //Handle ConnectFailure Separately
}

 {
   "alg": "HS256",
   "typ": "JWT"
}

 {
   "sub": "1234567890",
   "name": "John Doe",
   "admin": true
}

 HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret)

 {
   "sub": "1234567890",
   "name": "Ado Kukic",
   "admin": true
}

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkFkbyBLdWtpYyIsImFkbWluIjp0cnVlLCJpYXQiOjE0NjQyOTc4ODV9.Y47kJvnHzU9qeJIN48_bVna6O0EDFiMiQ9LpNVDFymM

 Authorization: Bearer <token>

 http://en.هشام.com/post/build-customizable-language-switcher-tag-helper-with-bootstrap

 WebRequest wr = WebRequest.Create(uri);
using (WebResponse response = wr.GetResponse()) { }

 The remote name could not be resolved: 'en.هشام.com'

<configuration><uri><idn enabled="All" /><iriParsing enabled="true" /></uri></configuration>

 var unicode = @"en.هشام.com";
 
var mapping = new IdnMapping(); // IDN  = Internationalizing Domain Names
var ascii = mapping.GetAscii(unicode);
Console.WriteLine(ascii);
 
string convertedBackToUnicode = mapping.GetUnicode(ascii);
Console.WriteLine(convertedBackToUnicode);

PM> Install-Package Microsoft.Owin.Host.SystemWeb
PM> Install-Package Microsoft.Owin.Security.Jwt
PM> Install-Package structuremap
PM> Install-Package structuremap.web

<appJwtConfiguration
    tokenPath="/login"
    expirationMinutes="2"
    refreshTokenExpirationMinutes="60"
    jwtKey="This is my shared key, not so secret, secret!"
    jwtIssuer="http://localhost/"
    jwtAudience="Any" />

<configSections><section name="appJwtConfiguration" type="JwtWithWebAPI.JsonWebTokenConfig.AppJwtConfiguration" /></configSections>

public interface ITokenStoreService
{    void CreateUserToken(UserToken userToken);    bool IsValidToken(string accessToken, int userId);    void DeleteExpiredTokens();    UserToken FindToken(string refreshTokenIdHash);    void DeleteToken(string refreshTokenIdHash);    void InvalidateUserTokens(int userId);    void UpdateUserToken(int userId, string accessTokenHash);
}

public void CreateUserToken(UserToken userToken)
{
   InvalidateUserTokens(userToken.OwnerUserId);
   _tokens.Add(userToken);
}

public interface IUsersService
{    string GetSerialNumber(int userId);    IEnumerable<string> GetUserRoles(int userId);    User FindUser(string username, string password);    User FindUser(int userId);    void UpdateUserLastActivityDate(int userId);
}

public interface ISecurityService
{
   string GetSha256Hash(string input);
}

function doLogin() {    $.ajax({        url: "/login", // web.config --> appConfiguration -> tokenPath        data: {            username: "Vahid",            password: "1234",            grant_type: "password"        },        type: 'POST', // POST `form encoded` data        contentType: 'application/x-www-form-urlencoded'

 identity.AddClaim(new Claim(ClaimTypes.UserData, user.UserId.ToString()));

function doRefreshToken() {    // obtaining new tokens using the refresh_token should happen only if the id_token has expired.    // it is a bad practice to call the endpoint to get a new token every time you do an API call.    $.ajax({        url: "/login", // web.config --> appConfiguration -> tokenPath        data: {            grant_type: "refresh_token",            refresh_token: refreshToken        },        type: 'POST', // POST `form encoded` data        contentType: 'application/x-www-form-urlencoded'

 [JwtAuthorize(Roles = "Admin")]
public class MyProtectedAdminApiController : ApiController

var jwtToken;
var refreshToken;
function doLogin() {    $.ajax({
     // same as before    }).then(function (response) {        jwtToken = response.access_token;        refreshToken = response.refresh_token;     }

function doCallApi() {    $.ajax({        headers: { 'Authorization': 'Bearer ' + jwtToken },        url: "/api/MyProtectedApi",        type: 'GET'    }).then(function (response) {

function doLogout() {    $.ajax({        headers: { 'Authorization': 'Bearer ' + jwtToken },        url: "/api/user/logout",        type: 'GET'

public AppOAuthProvider(
   Func<IUsersService> usersService,
   Func<ITokenStoreService> tokenStoreService,
   ISecurityService securityService,
   IAppJwtConfiguration configuration)

 C:\Users\Vahid>dotnet --version
1.0.0-preview2-003121

 .NET Core -> ASP.NET Core Web Application (.NET Core) -> Select `Empty` Template

{  "projects": [ "src", "test" ],  "sdk": {    "version": "1.0.0-preview2-003121"  }
}

 .NET Core -> ASP.NET Core Web Application (.NET Core) -> Select `Empty` Template

{  "projects": [ "src", "test" ],  "sdk": {    "version": "1.0.0-preview2-003121"  }
}

  "projects": [ "src", "test", "c:\\sources\\Configuration\\src" ],

 app.Run(async (context) =>
{
   await context.Response.WriteAsync("Hello World!");
});

 await context.Response.WriteAsync("Hello DNT!");

"dependencies": {  "Microsoft.NETCore.App": {    "version": "1.0.0",    "type": "platform"  },  "Microsoft.AspNetCore.Diagnostics": "1.0.0",  "Microsoft.AspNetCore.Server.IISIntegration": "1.0.0",  "Microsoft.AspNetCore.Server.Kestrel": "1.0.0",  "Microsoft.Extensions.Logging.Console": "1.0.0"
},

"frameworks": {  "netcoreapp1.0": {    "imports": [      "dotnet5.6",      "portable-net45+win8"    ]  }
},

 "frameworks": {
    "netcoreapp1.0": {
    },
    "net452": {
    }
  }

"frameworks": {  "netcoreapp1.0": {      "imports": [          "dotnet5.6",          "portable-net45+win8"      ]  },  "net461": {      "imports": [          "portable-net45+win8"      ],      "dependencies": {      }  }
},

 "dependencies": {
 //"Microsoft.NETCore.App": {
 //  "version": "1.0.0",
 //  "type": "platform"
 //},

{
  "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"
  }
}

{
    "webroot":"AppWebRoot"
}

"buildOptions": {  "emitEntryPoint": true,  "preserveCompilationContext": true
},

public static void Main(string[] args)
{    var host = new WebHostBuilder()        .UseKestrel()        .UseContentRoot(Directory.GetCurrentDirectory())        .UseIISIntegration()        .UseStartup<Startup>()        .Build();    host.Run();
}

 var outputKind = compilerOptions.EmitEntryPoint.GetValueOrDefault() ?
OutputKind.ConsoleApplication : OutputKind.DynamicallyLinkedLibrary;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
    }

    public void Configure(IApplicationBuilder app)
    {
        app.Run(async (context) =>
        {
            await context.Response.WriteAsync("Hello World!");
        });
    }
}

{  "iisSettings": {    "windowsAuthentication": false,    "anonymousAuthentication": true,    "iisExpress": {      "applicationUrl": "http://localhost:7742/",      "sslPort": 0    }  },  "profiles": {    "IIS Express": {      "commandName": "IISExpress",      "launchBrowser": true,      "environmentVariables": {        "ASPNETCORE_ENVIRONMENT": "Development"      }    },    "Core1RtmEmptyTest": {      "commandName": "Project",      "launchBrowser": true,      "launchUrl": "http://localhost:5000",      "environmentVariables": {        "ASPNETCORE_ENVIRONMENT": "Development"      }    }  }
}

{    "dependencies": {        "Microsoft.NETCore.App": {            "version": "1.0.0",            "type": "platform"        },        "Microsoft.AspNetCore.Diagnostics": "1.0.0",        "Microsoft.AspNetCore.Server.IISIntegration": "1.0.0",        "Microsoft.AspNetCore.Server.Kestrel": "1.0.0",        "Microsoft.Extensions.Logging.Console": "1.0.0"    },

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
namespace Core1RtmEmptyTest
{    public class Startup    {        public void ConfigureServices(IServiceCollection services)        {        }        public void Configure(IApplicationBuilder app)        {            app.UseWelcomePage();            app.Run(async (context) =>            {                await context.Response.WriteAsync("Hello DNT!");            });        }    }
}

public class Program
{    public static void Main(string[] args)    {        var host = new WebHostBuilder()            .UseKestrel()            .UseContentRoot(Directory.GetCurrentDirectory())            .UseIISIntegration()            .UseStartup<Startup>()            .Build();        host.Run();    }
}

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

public class Startup
{    public void ConfigureServices(IServiceCollection services)    {    }    public void Configure(IApplicationBuilder app)    {        app.UseStaticFiles();        //app.UseWelcomePage();        app.Run(async context =>        {            await context.Response.WriteAsync("Hello DNT!");        });    }
}

<!DOCTYPE html><html><head>    <meta charset="utf-8" />    <title>Hello World</title></head><body>    Hello World!</body></html>

public void Configure(IApplicationBuilder app)
{
   app.UseDefaultFiles();
   app.UseStaticFiles();

 // Serve my app-specific default file, if present.
DefaultFilesOptions options = new DefaultFilesOptions();
options.DefaultFileNames.Clear();
options.DefaultFileNames.Add("mydefault.html");
app.UseDefaultFiles(options);

public void Configure(IApplicationBuilder app)
{
  app.UseStaticFiles();
  app.UseDefaultFiles();

○ wwwroot
   § css
   § images
   § ...
○ MyStaticFiles
   § test.png

app.UseStaticFiles(new StaticFileOptions
{    FileProvider = new PhysicalFileProvider(root: Path.Combine(Directory.GetCurrentDirectory(), @"MyStaticFiles")),    RequestPath = new PathString("/StaticFiles")
});

app.UseDirectoryBrowser(new DirectoryBrowserOptions
{    FileProvider = new PhysicalFileProvider(root: Path.Combine(Directory.GetCurrentDirectory(), @"wwwroot\images")),    RequestPath = new PathString("/MyImages")
});

 Unable to resolve service for type 'System.Text.Encodings.Web.HtmlEncoder' while attempting to activate 'Microsoft.AspNetCore.StaticFiles.DirectoryBrowserMiddleware'.

public void ConfigureServices(IServiceCollection services)
{
   services.AddDirectoryBrowser();
}

app.UseStaticFiles(new StaticFileOptions
{    FileProvider = new PhysicalFileProvider(root: Path.Combine(Directory.GetCurrentDirectory(), @"wwwroot\images")),    RequestPath = new PathString("/MyImages")
});

using System.IO;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.FileProviders;
namespace Core1RtmEmptyTest
{    public class Startup    {        public void ConfigureServices(IServiceCollection services)        {            services.AddDirectoryBrowser();        }        public void Configure(IApplicationBuilder app)        {            app.UseDefaultFiles();            app.UseStaticFiles(); // For the wwwroot folder            // For the files outside of the wwwroot            app.UseStaticFiles(new StaticFileOptions            {                FileProvider = new PhysicalFileProvider(root: Path.Combine(Directory.GetCurrentDirectory(), @"MyStaticFiles")),                RequestPath = new PathString("/StaticFiles")            });            // For DirectoryBrowser            app.UseStaticFiles(new StaticFileOptions            {                FileProvider = new PhysicalFileProvider(root: Path.Combine(Directory.GetCurrentDirectory(), @"wwwroot\images")),                RequestPath = new PathString("/MyImages")            });            app.UseDirectoryBrowser(new DirectoryBrowserOptions            {                FileProvider = new PhysicalFileProvider(root: Path.Combine(Directory.GetCurrentDirectory(), @"wwwroot\images")),                RequestPath = new PathString("/MyImages")            });            //app.UseWelcomePage();            app.Run(async context =>            {                await context.Response.WriteAsync("Hello DNT!");            });        }    }
}

 app.UseFileServer();

 app.UseFileServer(enableDirectoryBrowsing: true);

app.UseFileServer(new FileServerOptions
    {
        FileProvider = new PhysicalFileProvider(
            Path.Combine(Directory.GetCurrentDirectory(), @"MyStaticFiles")),
        RequestPath = new PathString("/StaticFiles"),
        EnableDirectoryBrowsing = false
    });

 // Set up custom content types -associating file extension to MIME type
var provider = new FileExtensionContentTypeProvider();
provider.Mappings[".xyz"] = "text/html";
app.UseStaticFiles(new StaticFileOptions
{
    ContentTypeProvider = provider
}) ; // For the wwwroot folder

public class XyzContentTypeProvider : FileExtensionContentTypeProvider
{    public XyzContentTypeProvider()    {        this.Mappings.Add(".xyz", "text/html");    }
}

app.UseStaticFiles(new StaticFileOptions
{
    ContentTypeProvider = new XyzContentTypeProvider()
}) ; // For the wwwroot folder

app.UseStaticFiles(new StaticFileOptions
{
    ServeUnknownFileTypes = true,
    DefaultContentType = "image/png"
});

public void Configure(IApplicationBuilder app)
{    app.Run(async context =>    {        throw new Exception("Generic Error");        await context.Response.WriteAsync("Hello DNT!");    });
}

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

public void Configure(IApplicationBuilder app, IHostingEnvironment env)

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

if(env.IsDevelopment()){ }
if(env.IsProduction()){ }
if(env.IsStaging()){ }

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{    if (env.IsDevelopment())    {        app.UseDeveloperExceptionPage();    }    else    {        app.UseExceptionHandler(errorHandlingPath: "/MyControllerName/SomeActionMethodName");    }

 var feature = HttpContext.Features.Get<IExceptionHandlerFeature>();
var error = feature?.Error;

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{    if (env.IsDevelopment())    {        app.UseStatusCodePages();        app.UseDeveloperExceptionPage();    }    else    {        app.UseExceptionHandler(errorHandlingPath: "/MyControllerName/SomeActionMethodName");    }
}

 app.UseStatusCodePagesWithReExecute("/MyControllerName/SomeActionMethodName/{0}");

namespace Core1RtmEmptyTest.Services
{    public interface IMessagesService    {        string GetSiteName();    }    public class MessagesService : IMessagesService    {        public string GetSiteName()        {            return "DNT";        }    }
}

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

public void Configure(    IApplicationBuilder app,    IHostingEnvironment env,    IMessagesService messagesService)

public void Configure(    IApplicationBuilder app,    IHostingEnvironment env,    IMessagesService messagesService)
{     app.Run(async context =>    {        var siteName = messagesService.GetSiteName();        await context.Response.WriteAsync($"Hello {siteName}");    });
}

 System.InvalidOperationException
No service for type 'Core1RtmEmptyTest.Services.IMessagesService' has been registered.
at Microsoft.Extensions.DependencyInjection.ServiceProviderServiceExtensions.GetRequiredService(IServiceProvider provider, Type serviceType)
at Microsoft.AspNetCore.Hosting.Internal.ConfigureBuilder.Invoke(object instance, IApplicationBuilder builder)

System.Exception
Could not resolve a service of type 'Core1RtmEmptyTest.Services.IMessagesService' for the parameter 'messagesService' of method 'Configure' on type 'Core1RtmEmptyTest.Startup'.
at Microsoft.AspNetCore.Hosting.Internal.ConfigureBuilder.Invoke(object instance, IApplicationBuilder builder)
at Microsoft.AspNetCore.Hosting.Internal.WebHost.BuildApplication()

public class Startup
{    public void ConfigureServices(IServiceCollection services)    {        services.AddTransient<IMessagesService, MessagesService>();    }

{    "dependencies": {
        // same as before          "StructureMap.Dnx": "0.5.1-rc2-final"    },

public class Startup
{    public IServiceProvider ConfigureServices(IServiceCollection services)    {        services.AddDirectoryBrowser();        var container = new Container();        container.Configure(config =>        {            config.Scan(_ =>            {                _.AssemblyContainingType<IMessagesService>();                _.WithDefaultConventions();            });            //config.For<IMessagesService>().Use<MessagesService>();            config.Populate(services);        });        container.Populate(services);        return container.GetInstance<IServiceProvider>();    }

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

{    "Key1": "Value1",    "Auth": {        "Users": [ "Test1", "Test2", "Test3" ]    },    "Logging": {        "IncludeScopes": false,        "LogLevel": {            "Default": "Debug",            "System": "Information",            "Microsoft": "Information"        }    }
}

<appSettings><add key="Logging-IncludeScopes" value="false" /><add key="Logging-Level-Default" value="verbose" /><add key="Logging-Level-System" value="Information" /><add key="Logging-Level-Microsoft" value="Information" /></appSettings>

public class Startup
{    public IConfigurationRoot Configuration { set; get; }    public Startup(IHostingEnvironment env)    {        var builder = new ConfigurationBuilder()                            .SetBasePath(env.ContentRootPath)                            .AddJsonFile("appsettings.json");        Configuration = builder.Build();    }

var key1 = Configuration["Key1"];
var user1 = Configuration["Auth:Users:0"];
var authUsers = Configuration.GetSection("Auth:Users").GetChildren().Select(x => x.Value).ToArray();
var loggingIncludeScopes = Configuration["Logging:IncludeScopes"];
var loggingLoggingLogLevelDefault = Configuration["Logging:LogLevel:Default"];

 var val = Configuration.GetValue<int>("key-name", defaultValue: 10);

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

var container = new Container();
container.Configure(config =>
{    config.For<IConfigurationRoot>().Singleton().Use(() => Configuration);

public IServiceProvider ConfigureServices(IServiceCollection services)
{    services.AddSingleton<IConfiguration>(provider => { return Configuration; });

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

public interface IMessagesService
{    string GetSiteName();
}
public class MessagesService : IMessagesService
{    private readonly IConfigurationRoot _configurationRoot;    public MessagesService(IConfigurationRoot configurationRoot)    {        _configurationRoot = configurationRoot;    }    public string GetSiteName()    {        var key1 = _configurationRoot["Key1"];        return $"DNT {key1}";    }
}

public void Configure(    IApplicationBuilder app,    IHostingEnvironment env,    IMessagesService messagesService)
{     app.Run(async context =>    {        var siteName = messagesService.GetSiteName();        await context.Response.WriteAsync($"Hello {siteName}");    });
}

var builder = new ConfigurationBuilder()                    .AddInMemoryCollection(new[]                                {                                    new KeyValuePair<string,string>("the-key", "the-value"),                                });

 var theValue = Configuration["the-key"];

public class Startup
{    public IConfigurationRoot Configuration { set; get; }    public Startup(IHostingEnvironment env)    {        var builder = new ConfigurationBuilder()                            .SetBasePath(env.ContentRootPath)                            .AddInMemoryCollection(new[]                                {                                    new KeyValuePair<string,string>("the-key", "the-value"),                                })                            .AddJsonFile("appsettings.json", reloadOnChange: true, optional: false)                            .AddJsonFile($"appsettings.{env}.json", optional: true);        Configuration = builder.Build();    }

 var builder = new ConfigurationBuilder()
.SetBasePath(env.ContentRootPath)
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
.AddEnvironmentVariables();

{    "Key1": "Value1",    "Auth": {        "Users": [ "Test1", "Test2", "Test3" ]    },    "Logging": {        "IncludeScopes": false,        "LogLevel": {            "Default": "Debug",            "System": "Information",            "Microsoft": "Information"        }    },    "Smtp": {        "Server": "0.0.0.1",        "User": "user@company.com",        "Pass": "123456789",        "Port": "25"    }
}

namespace Core1RtmEmptyTest.ViewModels
{    public class SmtpConfig    {        public string Server { get; set; }        public string User { get; set; }        public string Pass { get; set; }        public int Port { get; set; }    }
}

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

public IServiceProvider ConfigureServices(IServiceCollection services)
{
   services.Configure<SmtpConfig>(options => Configuration.GetSection("Smtp").Bind(options));

    "dependencies": {        "Core1RtmEmptyTest.ViewModels": "1.0.0-*",        "Microsoft.Extensions.Configuration.Abstractions": "1.0.0",        "Microsoft.Extensions.Options": "1.0.0",        "NETStandard.Library": "1.6.0"    }

public interface IMessagesService
{    string GetSiteName();
}
public class MessagesService : IMessagesService
{    private readonly IConfigurationRoot _configurationRoot;    private readonly IOptions<SmtpConfig> _settings;    public MessagesService(IConfigurationRoot configurationRoot, IOptions<SmtpConfig> settings)    {        _configurationRoot = configurationRoot;        _settings = settings;    }    public string GetSiteName()    {        var key1 = _configurationRoot["Key1"];        var server = _settings.Value.Server;        return $"DNT {key1} - {server}";    }
}

 .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)

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

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

public void Configure(IApplicationBuilder app)
{
   app.UseFileServer();
   app.UseMvcWithDefaultRoute();

namespace Core1RtmEmptyTest.Controllers
{    public class HomeController    {        public string Index()        {            return "Running a POCO controller!";        }    }
}

using Microsoft.AspNetCore.Mvc;
namespace Core1RtmEmptyTest.Controllers
{    public class AboutController : Controller    {        public IActionResult Index()        {            return Content("Hello from DNT!");        }    }
}

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
namespace Core1RtmEmptyTest.Controllers
{    public class HomeController    {        [ActionContext]        public ActionContext ActionContext { get; set; }        public HttpContext HttpContext => ActionContext.HttpContext;        public string Index()        {            return "Running a POCO controller!";        }        public IActionResult About()        {            return new ContentResult            {                Content = "Hello from DNT!",                ContentType = "text/plain; charset=utf-8"            };        }    }
}

 app.UseMvcWithDefaultRoute();

    public static IApplicationBuilder UseMvcWithDefaultRoute(this IApplicationBuilder app)
    {
      if (app == null)
        throw new ArgumentNullException("app");
      return app.UseMvc((Action<IRouteBuilder>) (routes => routes.MapRoute("default", "{controller=Home}/{action=Index}/{id?}")));
    }

 [Route("[controller]/[action]")]

namespace Core1RtmEmptyTest.Controllers
{ public class HomeController {
   public string Index()
   {
    return "Running a POCO controller!";
   } }
}

app.UseMvc(routes =>
{ routes.MapRoute(
   name: "default",
   template: "{controller=Home}/{action=Index}/{id?}");
});

using Microsoft.AspNetCore.Mvc;
namespace Core1RtmEmptyTest.Controllers
{ public class AboutController : Controller {
   public ActionResult Hello()
   {
    return Content("Hello from DNT!");
   }
   public ActionResult SiteName()
   {
    return Content("DNT");
   } }
}

using Microsoft.AspNetCore.Mvc;
namespace Core1RtmEmptyTest.Controllers
{ [Route("About")] public class AboutController : Controller {
   [Route("")]
   public ActionResult Hello()
   {
    return Content("Hello from DNT!");
   }
   [Route("SiteName")]
   public ActionResult SiteName()
   {
    return Content("DNT");
   } }
}

 AmbiguousActionException: Multiple actions matched. The following actions matched route data and had all constraints satisfied:

Core1RtmEmptyTest.Controllers.AboutController.Hello (Core1RtmEmptyTest)
Core1RtmEmptyTest.Controllers.AboutController.SiteName (Core1RtmEmptyTest)

using Microsoft.AspNetCore.Mvc;
namespace Core1RtmEmptyTest.Controllers
{ [Route("[controller]")] public class AboutController : Controller {
   [Route("")]
   public ActionResult Hello()
   {
    return Content("Hello from DNT!");
   }
   [Route("[action]")]
   public ActionResult SiteName()
   {
    return Content("DNT");
   } }
}

 [Route("api/[controller]")]

//[Route("/Users/{userid}")]
[Route("Users/{userid}")]
public IActionResult GetUsers(int userId)
{
    return Json(new { userId = userId });
}

[Route("/Users/{userid:int?}")]

 [Route("Users/{userid:int}")]

 [Route("/Users/{userid:int:max(1000):min(10)}")]

 [Route("/Users/{userid:int}", Name="GetUserById")]

 string uri = Url.Link("GetUserById", new { userid = 1 });

 [Route("/Users/{userid:int}", Name = "GetUserById", Order = 1)]

using System;
using System.Globalization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing;
namespace Core1RtmEmptyTest
{ public class CustomRouteConstraint : IRouteConstraint {
   public bool Match(HttpContext httpContext, IRouter route, string routeKey, RouteValueDictionary values,
    RouteDirection routeDirection)
   {
    object value;
    if (!values.TryGetValue(routeKey, out value) || value == null)
    { return false;
    }
    long longValue;
    if (value is long)
    { longValue = (long)value; return longValue != 10;
    }
    var valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
    if (long.TryParse(valueString, NumberStyles.Integer, CultureInfo.InvariantCulture, out longValue))
    { return longValue != 10;
    }
    return false;
   } }
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddRouting(options =>options.ConstraintMap.Add("Custom", typeof(CustomRouteConstraint)));

 [Route("/Users/{userid:int:custom}")]

app.UseMvc(routes =>
{ routes.MapRoute(
   name: "default",
   template: "{controller=Home}/{action=Index}/{id?}");  routes.MapRoute(
   name: "spa-fallback",
   template: "{*url}",
   defaults: new { controller = "Home", action = "Index" });
});

{
    "dependencies": {
       //same as before  
       "Microsoft.AspNetCore.SpaServices": "1.0.0-beta-000007"
 },

app.UseMvc(routes =>
{ routes.MapRoute(
   name: "default",
   template: "{controller=Home}/{action=Index}/{id?}"); routes.MapSpaFallbackRoute("spa-fallback", new { controller = "Home", action = "Index" });
});

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