<Project Sdk="Microsoft.NET.Sdk.Web"> 
      <PropertyGroup> 
        <TargetFramework>netcoreapp2.0</TargetFramework> 
      </PropertyGroup> 
      <ItemGroup> 
        <Folder Include="wwwroot\" /> 
      </ItemGroup> 
      <ItemGroup> 
        <PackageReference Include="Microsoft.AspNetCore.All"
         Version="2.0.0-preview2-final" /> 
      </ItemGroup> 
    </Project> 

    <TargetFramework>netcoreapp2.0</TargetFramework>

    using Microsoft.AspNetCore; 
    using Microsoft.AspNetCore.Hosting; 

    namespace TicTacToe 
    { 
      public class Program 
      { 
        public static void Main(string[] args) 
        { 
            BuildWebHost(args).Run(); 
        } 

        public static IWebHost BuildWebHost(string[] args) => 
            WebHost.CreateDefaultBuilder(args) 
                .UseStartup<Startup>() 
                .Build(); 
      } 
    } 

    WebHost.CaptureStartupErrors(true); 

    WebHost.PreferHostingUrls(true); 
    WebHost.UseUrls("http://localhost:5000"); 

    WebHost.UseApplicationInsights();

    public class Program 
    { 
      public static void Main(string[] args) 
      { 
        BuildWebHost(args).Run(); 
      } 

      public static IWebHost BuildWebHost(string[] args) => 
        WebHost.CreateDefaultBuilder(args) 
            .CaptureStartupErrors(true) 
            .UseStartup<Startup>() 
            .PreferHostingUrls(true) 
            .UseUrls("http://localhost:5000") 
            .UseApplicationInsights() 
            .Build(); 
    } 

    using Microsoft.AspNetCore.Builder; 
    using Microsoft.AspNetCore.Hosting; 
    using Microsoft.AspNetCore.Http; 
    using Microsoft.Extensions.DependencyInjection; 

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

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

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

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

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

    app.UseStaticFiles(); 

    app.UseBrowserLink(); 

    public class Startup 
    { 
      public void ConfigureServices(IServiceCollection services) 
      { 
        services.AddMvc(); 
      } 

      public void Configure(IApplicationBuilder app,
       IHostingEnvironment env) 
      { 
        if (env.IsDevelopment()) 
        { 
          app.UseDeveloperExceptionPage(); 
          app.UseBrowserLink(); 
        } 
        else 
        { 
          app.UseExceptionHandler("/Home/Error"); 
        } 

        app.UseStaticFiles(); 

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

        @using TicTacToe 
        @addTagHelper*, Microsoft.AspNetCore.Mvc.TagHelpers 

        @{ Layout = "~/Views/Shared/_Layout.cshtml"; }

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

        { 
          "directory": "wwwroot/lib" 
        } 

        body { 
          padding-top: 50px; 
          padding-bottom: 20px; 
        } 

        /* Set padding to keep content from hitting the edges */ 
        .body-content { 
          padding-left: 15px; 
          padding-right: 15px; 
        } 

        /* Set width on the form input elements since they're 100% wide
           by default */ 
        input, 
        select, 
        textarea { 
          max-width: 280px; 
        } 

        /* styles for validation helpers */ 
        .field-validation-error { 
          color: #b94a48; 
        } 

        .field-validation-valid { 
          display: none; 
        } 

        input.input-validation-error { 
          border: 1px solid #b94a48; 
        } 

        input[type="checkbox"].input-validation-error { 
          border: 0 none; 
        } 

        .validation-summary-errors { 
          color: #b94a48; 
        } 

        .validation-summary-valid { 
          display: none; 
        } 

    <!DOCTYPE html> 
    <html> 
    <head> 
      <meta charset="utf-8" /> 
      <meta name="viewport" content="width=device-width,
       initial-scale=1.0" /> 
      <title>@ViewData["Title"] - TicTacToe</title> 

      <environment include="Development"> 
        <link rel="stylesheet"
         href="~/lib/bootstrap/dist/css/bootstrap.css" /> 
        <link rel="stylesheet" href="~/css/site.css" /> 
      </environment> 
      <environment exclude="Development"> 
        <link rel="stylesheet"
         href="https://ajax.aspnetcdn.com/ajax/bootstrap
         /3.3.7/css/bootstrap.min.css" 
         asp-fallback-href="~/lib/bootstrap/dist/css/bootstrap.min.css" 
         asp-fallback-test-class="sr-only"
         asp-fallback-test-property="position" asp-fallback-test-
          value="absolute" /> 
        <link rel="stylesheet" href="~/css/site.min.css"
         asp-append-version="true" /> 
      </environment> 
    </head> 
    <body> 
      <nav class="navbar navbar-inverse navbar-fixed-top"> 
        <div class="container"> 
        <div class="navbar-header"> 
         <button type="button" class="navbar-toggle"
           data-toggle="collapse" data-target=".navbar-collapse"> 
          <span class="sr-only">Toggle navigation</span> 
          <span class="icon-bar"></span> 
          <span class="icon-bar"></span> 
          <span class="icon-bar"></span> 
         </button> 
         <a asp-area="" asp-controller="Home" asp-action="Index"
          class="navbar-brand">Tic-Tac-Toe</a> 
        </div> 
        <div class="navbar-collapse collapse"> 
         <ul class="nav navbar-nav"> 
           <li><a asp-area="" asp-controller="Home"
             asp-action="Index">Home</a></li> 
           <li><a asp-area="" asp-controller="Home" 
             asp-action="About">About</a></li> 
           <li><a asp-area="" asp-controller="Home"
             asp-action="Contact">Contact</a></li> 
         </ul> 
        </div> 
        </div> 
      </nav> 
      <div class="container body-content"> 
        @RenderBody() 
        <hr /> 
        <footer> 
          <p>&copy; 2017 - TicTacToe</p> 
        </footer> 
      </div> 

      <environment include="Development"> 
       <script src="~/lib/jquery/dist/jquery.js"></script> 
       <script src="~/lib/bootstrap/dist/js/bootstrap.js"></script> 
       <script src="~/js/site.js" asp-append-version="true"></script> 
      </environment> 
      <environment exclude="Development"> 
       <script src="https://ajax.aspnetcdn.com/ajax/jquery/
        jquery-2.2.0.min.js" 
        asp-fallback-src="~/lib/jquery/dist/jquery.min.js" 
        asp-fallback-test="window.jQuery" 
         crossorigin="anonymous" 
         integrity="sha384-K+ctZQ+LL8q6tP7I94W+qzQsfRV2a+
         AfHIi9k8z8l9ggpc8X+Ytst4yBo/hH+8Fk"> 
       </script> 
       <script src="https://ajax.aspnetcdn.com/ajax/bootstrap/
        3.3.7/bootstrap.min.js" 
        asp-fallback-src="~/lib/bootstrap/dist/js/bootstrap.min.js" 
        asp-fallback-test="window.jQuery&&window.jQuery
         .fn&&window.jQuery.fn.modal" 
        crossorigin="anonymous" 
        integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA
         7l2mCWNIpG9mGCD8wGNIcPD7Txa"> 
       </script> 
       <script src="~/js/site.min.js" asp-append-version="true">
       </script> 
      </environment> 

      @RenderSection("Scripts", required: false) 
    </body> 
    </html> 

    @{ 
      ViewData["Title"] = "Home Page"; 
      Layout = "~/Views/Shared/_Layout.cshtml"; 
    } 
    <div class="row"> 
    <div class="col-lg-12"> 
      <h2>Tic-Tac-Toe</h2> 
      <div class="alert alert-info"> 
        <p>Tic-Tac-Toe is a two-player turn-based game.</p> 
        <p>Two players will choose who takes the Xs and who
           takes the Os. They will then be taking turns and
           mark spaces in a 3×3 grid by putting their marks,
           one mark per turn.</p> 
        <p>A player who succeeds in placing three of his
           marks in a horizontal, vertical, or diagonal row
           wins the game.</p> 
      </div> 
      <p> 
        <h3>Register by clicking <a asp-controller="UserRegistration"
            asp-view="Index">here</a></h3> 
      </p> 
    </div> 
    </div> 

        public class UserModel 
        { 
          public Guid Id { get; set; } 
          public string FirstName { get; set; } 
          public string LastName { get; set; } 
          public string Email { get; set; } 
          public string Password { get; set; } 
          public bool IsEmailConfirmed { get; set; } 
          public System.DateTime? EmailConfirmationDate { get; set; } 
          public int Score { get; set; } 
        } 

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

        services.AddTransient<IExampleService, ExampleService>();

        services.AddScoped<IExampleService, ExampleService>(); 

        services.AddSingleton<IExampleService, ExampleService>(); 

        public class UserService 
        { 
          public Task<bool>RegisterUser(UserModel userModel) 
          { 
            return Task.FromResult(true); 
          } 
        }

        public interface IUserService 
        { 
          Task<bool>RegisterUser(UserModeluserModel); 
        } 

        public class UserRegistrationController : Controller 
        { 
          private IUserService _userService; 
          public UserRegistrationController(IUserService userService) 
          { 
            _userService = userService; 
          } 

          public IActionResult Index() 
          { 
            return View(); 
          } 
        } 

        [HttpPost] 
        public async Task<IActionResult> Index(UserModel userModel) 
        { 
          await _userService.RegisterUser(userModel); 
          return Content($"User {userModel.FirstName} 
           {userModel.LastName} has been registered sucessfully"); 
        } 

        public void ConfigureServices(IServiceCollection services) 
        {             
          services.AddMvc(); 
          services.AddSingleton<IUserService, UserService>(); 
        } 

    private static void ApiPipeline(IApplicationBuilder app) 
    { 
      app.Run(async context => 
      { 
        await context.Response.WriteAsync("Branched to Api Pipeline."); 
      }); 
    } 

    private static void WebPipeline(IApplicationBuilder app) 
    { 
      app.MapWhen(context => 
      { 
        return context.Request.Query.ContainsKey("usr"); 
      }, UserPipeline); 

      app.Run(async context => 
      { 
        await context.Response.WriteAsync("Branched to Web Pipeline."); 
      }); 
    } 

    private static void UserPipeline(IApplicationBuilder app) 
    { 
      app.Run(async context => 
      { 
        await context.Response.WriteAsync("Branched to User Pipeline."); 
      }); 
    } 

    public void Configure(IApplicationBuilder app, IHostingEnvironmentenv) 
    { 
      app.Map("/api", ApiPipeline); 
      app.Map("/web", WebPipeline); 

      app.Use(next =>async context => 
      { 
        await context.Response.WriteAsync("Called Use."); 
        await next.Invoke(context); 
      }); 

      app.Run(async context => 
      { 
        await context.Response.WriteAsync("Finished with Run."); 
      }); 
    } 

        public class CommunicationMiddleware 
        { 
          private readonly RequestDelegate _next; 
          private readonly IUserService _userService; 

          public CommunicationMiddleware(RequestDelegate next,
           IUserService userService) 
          { 
            _next = next; 
            _userService = userService; 
          } 

          public async Task Invoke(HttpContext context) 
          { 
            await _next.Invoke(context); 
          } 
        }

        public static class CommunicationMiddlewareExtension 
        { 
          public static IApplicationBuilder
           UseCommunicationMiddleware(this IApplicationBuilder app) 
          { 
            return app.UseMiddleware<CommunicationMiddleware>(); 
          } 
        } 

        using TicTacToe.Extensions; 
        ... 
        public void Configure(IApplicationBuilder app,
         IHostingEnvironment env) 
        { 
          ... 
          app.UseCommunicationMiddleware(); 
          app.UseMvc(routes => 
          { 
            routes.MapRoute( 
             name: "default", 
             template: "{controller=Home}/{action=Index}/{id?}"); 
          }); 
        } 

    app.UseStaticFiles();

        services.AddDirectoryBrowser(); 

        app.UseDirectoryBrowser(); 

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

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

    public void ConfigureServices(IServiceCollection services)
    {
      services.AddMvc();
      services.AddSingleton<IUserService, UserService>();
      services.AddRouting();
    }
    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
      if (env.IsDevelopment())
      {
        app.UseDeveloperExceptionPage();
        app.UseBrowserLink();
      }
      else
      {
        app.UseExceptionHandler("/Home/Error");
      }
      app.UseStaticFiles();
      var routeBuilder = new RouteBuilder(app);
      routeBuilder.MapGet("CreateUser", context =>
      {
        var firstName = context.Request.Query["firstName"];
        var lastName = context.Request.Query["lastName"];
        var email = context.Request.Query["email"];
        var password = context.Request.Query["password"];
        var userService = 
          context.RequestServices.GetService<IUserService>();
        userService.RegisterUser(new UserModel { FirstName = firstName,
         LastName = lastName, Email = email, Password = password });
        return context.Response.WriteAsync($"User {firstName} 
         {lastName} has been sucessfully created.");
      });
      var newUserRoutes = routeBuilder.Build();
      app.UseRouter(newUserRoutes);
      app.UseCommunicationMiddleware();
      app.UseMvc(routes =>
      {
        routes.MapRoute(
         name: "default",
         template: "{controller=Home}/{action=Index}/{id?}");
      });
      app.UseStatusCodePages("text/plain",
      "HTTP Error - Status Code: {0}");
    }

    var options = new RewriteOptions() 
      .AddRewrite("NewUser", "/UserRegistration/Index", false); 
    app.UseRewriter(options);

    if (env.IsDevelopment()) 
    { 
      app.UseDeveloperExceptionPage(); 
    } 

    if (env.IsDevelopment()) 
    { 
      app.UseDeveloperExceptionPage(); 
      app.UseBrowserLink(); 
    } 
    else 
    { 
      app.UseExceptionHandler("/Home/Error"); 
    } 

    app.UseStatusCodePages("text/plain", "HTTP Error - Status Code: {0}"); 

    app.UseStatusCodePagesWithRedirects("/error/{0}"); 

    app.UseStatusCodePagesWithReExecute("/error/{0}"); 

        public class UserModel 
        { 
          public Guid Id { get; set; } 
          [Required()] 
          public string FirstName { get; set; } 
          [Required()] 
          public string LastName { get; set; } 
          [Required(), DataType(DataType.EmailAddress)] 
          public string Email { get; set; } 
          [Required(), DataType(DataType.Password)] 
          public string Password { get; set; } 
          public bool IsEmailConfirmed { get; set; } 
          public System.DateTime? EmailConfirmationDate { get; set; } 
          public int Score { get; set; } 
        } 

        [HttpPost] 
        public async Task<IActionResult> Index(UserModel userModel) 
        { 
          if (ModelState.IsValid) 
          { 
            await _userService.RegisterUser(userModel); 
            return Content($"User {userModel.FirstName}  
             {userModel.LastName} has been registered sucessfully"); 
          } 
          return View(userModel); 
        }