MVC5 Vs MVC6 in ASP.NET

1. .NET framework is now part of your project and you can point to multiple frameworks at the same. Like in the figure its pointing to 4.5 framework ( full framework) and also to .NET core ( which is cross platform depending what you choose).
   
2. Global.asax is replaced by startup.cs which is more light weight and customizable.
   
3. Web.config configuration will not go in Config.json.
   
4. As a developer we have been adding references using our favorite add reference , you can now also add in project.json and your project will reference it automatically and also vice versa.
   
5. They have given a special wwwroot folder which will store static files of your project. Any files including HTML files, CSS files, image files, and JavaScript files which are sent to the users browser should be stored inside this folder.
   
6. There is a dependencies node which shows which JavaScript files have been used in your project

Point 3 have been explained in detail below :

New Configuration and AppSettings for MVC6 - Web.config is Gone

Web.config is gone but the new solution is great, you get a dependency injected POCO with strongly typed settings instead

New Settings File - appsettings.json

Instead of web.config, all your settings are now located in appsettings.json. Here’s what the default one looks like, though I’ve also added an AppSettings section:

{

  "AppSettings": {

    "BaseUrls": {

      "API": "https://localhost:44307/",

      "Auth": "https://localhost:44329/",

      "Web": "https://localhost:44339/"

    },

    "AnalyticsEnabled": true

  },

  "Data": {

    "DefaultConnection": {

      "ConnectionString": "Server=(localdb)\\mssqllocaldb;Database=aspnet5-AppSettings1-ad2c59cc-294a-4e72-bc31-078c88eb3a99;Trusted_Connection=True;MultipleActiveResultSets=true"

    }

  },

  "Logging": {

    "IncludeScopes": false,

    "LogLevel": {

      "Default": "Verbose",

      "System": "Information",

      "Microsoft": "Information"

    }

  }

}

Notice that we’re using JSON instead of XML now. This is pretty great with one big exception, No Intellisense.

Create an AppSettings class

If you’re used to using ConfigurationManager.AppSettings["MySetting"] in your controllers then you’re out of luck, instead you need to setup a class to hold your settings. As you can see above I like to add an “AppSettings” section to the config that maps directly to an AppSettings POCO. You can even nest complex classes as deep as you like:

public class AppSettings

{

    public BaseUrls BaseUrls { get; set; }

    public bool AnalyticsEnabled { get; set; }

}

public class BaseUrls

{

    public string Api { get; set; }

    public string Auth { get; set; }

    public string Web { get; set; }

}   

Configure Startup.cs

Now that we have a class to hold our settings, lets map the data from our appsettings.json. You can do it in a couple of ways.

Automatically bind all app settings:

public IServiceProvider ConfigureServices(IServiceCollection services)

{            

    services.Configure<AppSettings>(Configuration.GetSection("AppSettings"));

}

or if you need to alter or transform anything you can assign each property manually:

public IServiceProvider ConfigureServices(IServiceCollection services)

{            

    services.Configure<AppSettings>(appSettings =>

    {

        appSettings.BaseUrls = new BaseUrls()

        {

            // Untyped Syntax - Configuration[""]

            Api = Configuration["AppSettings:BaseUrls:Api"],

            Auth = Configuration["AppSettings:BaseUrls:Auth"],

            Web = Configuration["AppSettings:BaseUrls:Web"],

        };

        // Typed syntax - Configuration.Get<type>("")

        appSettings.AnalyticsEnabled = Configuration.Get<bool>("AppSettings:AnalyticsEnabled");

    });

}

Using the settings

Finally we can access our settings from within our controllers. We’ll be using dependency injection, so if you’re unfamiliar with that, get ready to learn!

public class HomeController : Controller

{

    private readonly AppSettings _appSettings;

    public HomeController(IOptions<AppSettings> appSettings)

    {

        _appSettings = appSettings.Value;

    }

    public IActionResult Index()

    {

        var webUrl = _appSettings.BaseUrls.Web;

        return View();

    }

}

There are a few important things to note here:

The class we are injecting is of type IOptions<AppSettings>. If you try to inject AppSettings directly it won’t work.

Instead of using the IOptions class throughout the code, instead I set the private variable to just AppSettings and assign it in the constructor using the .Valueproperty of the IOptions class.

By the way, the IOptions class is essentially a singleton. The instance we create during startup is the same throughout the lifetime of the application.

While this is a lot more setup than the old way of doing things, I think it forces developers to code in a cleaner and more modular way.