Download source – 12 Kb

Introduction

This article is based on the webinar I gave on 6 March 2017. Thanks to the all the people joining in and sharing the knowledge and Mumbai Techie Group for again giving me the opportunity to share my learning with all the Attendee and getting involve in the Community.

Background

I received lot of feedback after the webinar, it was mixture of all, as i call myself a learner i want to improvise on all the aspects which people told me i can improve. I was happy and enthusiastic to share my knowledge and as well patient enough to note down the learnings. So i decided i should also blog my webinar agenda where people can get the resources to get started along with brief of all the agendas which i covered in the article or due to time constraint i was not able to show them the code. I hope i will learn from my mistake and in future will prioritize to not make the same mistake twice. Thanks all for taking your time and giving me the feedback, I appreciate that a lot.

Youtube Link for the .NET CORE and ASP.NET CORE Webinar

Agenda For the Day

Where is my ASP.NET?

Once we are done restoring the packages we are ready to set up our kestrel web server.

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

public class StartUp
{
    public void ConfigureServices(IServiceCollection services)
    {
         //Responsible for injecting this class or service we want in our Controller
    }


    public void Configure(IApplicationBuilder app)
    {
        //Set up your http pipeline
    }

}

using Microsoft.AspNetCore.Builder;
    using Microsoft.Extensions.DependencyInjection;
    using Microsoft.AspNetCore.Http;
    public class StartUp
    {
        public void ConfigureServices(IServiceCollection services)
        {
            //Responsible for inject this class or service we want
        }
        public void Configure(IApplicationBuilder app)
        {
        app.Run(context=>{

    return context.Response.WriteAsync("HELLO WORLD FROM ASP.NET CORE");
        });
        }
    }

Now once we are done with Let’s try to continue with setting up our WebServer.

using System;
using Microsoft.AspNetCore.Hosting;

namespace ConsoleApplication
{
    public class Program
    {
        public static void Main(string[] args)
        {
           var host=new WebHostBuilder()
                        .UseKestrel()
                        .UseIISIntegration()
                        .UseStartup()
                        .Build();
                        host.Run(); //run the server
        }
    }
}

Middleware

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

public class StartUp
    {
        public void ConfigureServices(IServiceCollection services)
        {
            //Responsible for inject this class or service we want
        }

        public void Configure(IApplicationBuilder app)
        {

  //middleware
            app.Use(async(context,next)=>{
            await context.Response.WriteAsync("I will execute first"+Environment.NewLine);
            await next.Invoke();
            await context.Response.WriteAsync("I will execute at last"+Environment.NewLine);
        });

            app.Run(context=>{
            return context.Response.WriteAsync("HELLO WORLD FROM ASP.NET CORE"+Environment.NewLine);
        });
        }

    }

Creating your own Basic Authentication Middleware of ASP.NET WEB API CORE

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;

namespace WebAPI.Controllers
{
    [Route("api/[controller]")]
    public class ValuesController : Controller
    {
        // GET api/values
        [HttpGet]
        public IEnumerable Get()
        {
            return new string[] { "value1", "value2" };
        }
    }
}

using Microsoft.AspNetCore.Http;
using System;
using System.Text;
using System.Threading.Tasks;

namespace WebAPI.Controllers
{
    public class Authorize
    {
        int i = 0;
        private readonly RequestDelegate _next;
        static string strToken = "";
        string strTokVal = "";
        public Authorize(RequestDelegate next)
        {
            _next = next;
        }

        public async Task Invoke(HttpContext _context)
        {
            string authHeader = _context.Request.Headers["Authorization"];
            if (!string.IsNullOrEmpty(authHeader))
            {
                string authStr = _context.Request.Headers["Authorization"];

                authStr = authStr.Trim();
                if (authStr.IndexOf("Basic", 0) != 0 || string.IsNullOrEmpty(authStr))
                {
                    DenyAccess(_context);
                    return;
                }
                authStr = authStr.Trim();
                string encodedCredentials = authStr.Substring(5);
                byte[] decodedBytes;
                decodedBytes = Convert.FromBase64String(encodedCredentials);

                string s = new ASCIIEncoding().GetString(decodedBytes);
                string[] userPass = s.Split(new char[] { ':' });
                string username = userPass[0];
                string password = userPass[1];
                if (!(string.IsNullOrEmpty(username) && string.IsNullOrEmpty(password)))
                {
                    if (username == "Saillesh" && password == "Saillesh@123")
                    {
                        AllowAccess(_context);
                    }
                    else
                    {
                        DenyAccess(_context);
                        return;
                    }
                }
                else
                {
                    DenyAccess(_context);
                    return;
                }
            }
            else
            {

                _context.Response.StatusCode = 401;
                _context.Response.Headers.Add("WWW-Authenticate", "Basic Authentication");

            }

        }
        private void DenyAccess(HttpContext app)
        {
            app.Response.StatusCode = 401;
            app.Response.WriteAsync("401 Access Denied");
            return;
        }

        private async void AllowAccess(HttpContext app)
        {
            app.Response.StatusCode = 200;
            await _next(app);
        }
    }
}

 await _next(app);

using Microsoft.AspNetCore.Builder;
using WebAPI.Controllers;

namespace WebAPI.Middleware
{
    public static class AuthorizationMiddleware
    {

        public static void UseAuthorizationMiddleware(this IApplicationBuilder builder)
        {
            builder.UseMiddleware();
        }
    }
}

Setting Up the Pipeline

 public void Configure(IApplicationBuilder app)
        {
            app.UseAuthorizationMiddleware();
            app.UseMvc();
        }

Calling API Using Postman

Sample ASP.NET Core application

namespace MarchDemo.Model
{
    public class Attendee
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Profession { get; set; }
        public string MobileNumber { get; set; }
        public string EmailId { get; set; }


    }
}

Views

Controllers

using System;
using System.Linq;
using MarchDemo.Model;
using MarchDemo.Persistence;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;

namespace MarchDemo.Controllers
{
  public class AttendeeController : Controller
  {
private ApplicationDbContext _context;
    public IActionResult Index()
    {    
   return View();
    }
public IActionResult AllAttendees()
{
_context=new ApplicationDbContext();
return View("AllAttendees",_context.Attendees.ToList());
}
public IActionResult AddAttendee(Attendee attendee)
{
_context=new ApplicationDbContext();
_context.Attendees.Add(attendee);
_context.SaveChanges();
return RedirectToAction("AllAttendees");
} }
}

EF Mapping

using MarchDemo.Model;
using Microsoft.EntityFrameworkCore;

namespace MarchDemo.Persistence
{
    public class ApplicationDbContext:DbContext
    {
public DbSet Attendees {get;set;}
protected override void OnConfiguring(DbContextOptionsBuilder options)
{
options.UseSqlServer(@"Data Source=.;Initial Catalog=MumbaiTechieGroup;Integrated Security=True");   
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity().ToTable("MtgParticipants");
}
}
}

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

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

        public void Configure(IApplicationBuilder app)
        {

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

    }

 "Microsoft.AspNetCore.StaticFiles": "1.1.0",

Dependency Injection in ASP.NET Core

AddTransient

AddTransient will create the new instance each time the request comes to the web application.

AddScoped

I found this to be extremely difficult to convey this DI but defining it I would say it will return the same of the for the class referred in i.e. a class referred in Service class or repository etc. We will see this in the demo.

I hope you have read the blog and download the source code from the Github and I am sure all your doubts who have been cleared as off now. If not feel free to reach me.

Deploying ASP.NET Core application using VsCode command line

The asp.net core is cloud ready framework which can be deployed cross platform. So in this context, we will be deploying the same to IIS. You might be thinking that will we be able to use the blown power of IIS, then my honest answer will be no. IIS with ASP.NET CORE work as a proxy server whose role is to pass all the HTTP request to kestrel. As Microsoft team has said that kestrel not being matured enough should be used behind the IIS. So let’s publish our ASP.NET Core application to IIS.

Now the application has been published we can see all the published DLLS and files.

We have the folder called Runtime which contains all the respective for our cross-platform deployment libraries.

When you publish the application you will find that there is no web.config as we use to have in asp.net application. Now in order to deploy the application on IIS, we still need the web.config file. So inorder to generate the same we need to add the dependency in tool section and scripts as shown below:

So now in order to deploy the application on IIS. We need to add the new application to the default website as shown below:.

Conclusion

I want to thank all the attendee and viewers who have already watched this video, thanks to people who has replied with feedback where I was lacking. I will make sure to improve on that bullet point. I hope this Summary article will be helpful who want to start with.NET CORE and ASP.NET CORE .