
#### Table of Contents

1. ASP.NET MVC's OutputCache
2. 1. Permanently store cache on client and server
3. 2. Permanently store cache on client
4. 3. Use Cache profile
5. Reference Resources
6. Other Resources
7. Best Practice or Tips

## ASP.NET MVC's `OutputCache`

### 1. Permanently store cache on client and server

Following example code, permanently cache page on client and server means once
browser loads the page the page will remain on the page forever unless server
rebuild, since cache on the server another agent will use the same server
cache version as well. This is good for static resource and the resource won't
change until server rebuild.

```
[OutputCache(Duration =int.MaxValue)]
public ActionResult Index()
{
return View();
}
```

###### max-age

The code above will response as following, the key here is
`max-age` (in seconds). As you can see it means the page will keep
a cache for a year.

This **Client Cache** will not work if either user type,`F5
or open developer console and check the.disable cache`
Otherwise, the browser will use the cached version from a client machine.

```
HTTP/1.1 304 Not Modified
Cache-Control: public, max-age=31535986
Expires: Sun, 01 Jul 2018 06:37:30 GMT
Last-Modified: Sat, 01 Jul 2017 06:37:30 GMT
Vary: *
Server: Microsoft-IIS/10.0
X-Powered-By: ASP.NET
Date: Sat, 01 Jul 2017 06:37:43 GMT
```

The client will store the cache on the machine, for example, Chrome will store
the cached version at the following location.

```
{YourPCsLoginUser}\AppData\Local\Google\Chrome\User Data\Default\Cache
```

## 2. Permanently store cache on client

```
[OutputCache(Duration = int.MaxValue, Location = System.Web.UI.OutputCacheLocation.Client)]
public ActionResult About()
{
return View();
}


```

## 3. Use Cache profile

Instead of define cache at C#, you could add at Web.Config. The good to add to
config is that you can modify the change without involving deployment.

```









```

After defined at Web.Config, you can use the MVC action as follows. It is
better to use at config if you use the common function and might change later.

```
[OutputCache(CacheProfile="MyProfile")]
        public ActionResult Test(int id)
        {
            return View();
        }
```

### Reference Resources

  - Article - Web Caching Basics

  - StackOverflow - Controlling ASP.NET output cache memory usage

  - Article - Aspnet MVC best practice

  - Document - MSDN Web.Config caching

  - Document - outputCacheSettings

  - Article - API development: ETags and Conditional Get

  - Article - Boost Your REST API with HTTP Caching

  - Article - Conditional GET and ETag Support in WCF WebHttp Services

  - Stackoverflow - Implementing ETag Support in ASP.NET MVC4 WebAPI

  - StackOverflow - Implement HTTP Cache (ETag) in ASP.NET Core Web API

  - Article - Output caching in ASP.NET Web API

  - Article - How-to: HTTP Caching for RESTful and Hypermedia APIs

  - Article - HTTP Caching

  - Blog - "Cache-control: no-store" considered harmful

  - Sample Code - Improving Performance with Output Caching (C#)

  - Article - Output Caching in MVC

### Other Resources

  - YSlow

  - Pagespeed Insights

  - dotTrace - Make use of a profiler to discover memory leaks and performance
problems in your application

  - Run as Release mode - not Debug mode, when in production, and also during
performance profiling. Release mode is much faster. Debug mode can hide
performance problems in your own code.

  - OutputCacheAttribute for cache not-prone-to-change content

  - Use ETags and expiration - write custom ActionResult

### Best Practice or Tips

1. Gzip would help the page performance

2. Gzip would be done by IIS level, however, some people IIS level might be an
issue.

3. Gzip would reduce response size around 2MB to 50KB.


Web Caching - Sample Code in ASP.NET MVC


## Table of Contents

1. [Introduction](#introduction)
2. [Errors](#errors)
3. [Compilers](#compilers)
4. [Roslyn](#roslyn)
5. [NuGet Packages](#nuget-packages)
6. [WebConfig](#webconfig)
7. [Conclusion](#conclusion)
8. [References](#references)

## Introduction

You might have seen something like the following: your ASP.NET MVC solution builds fine but you get a compiler error when deploying to a local IIS site or a cloud web server. You know you have C# 6 or higher in your application, but you're not sure why it causes a compile error during runtime. I had to spend some time figuring out what was happening in my case, so I've documented what I found here to hopefully help someone else.

## Errors

```
Microsoft (R) Visual C# Compiler version 4.7.2556.0
for C# 5
Copyright (C) Microsoft Corporation. All rights reserved.

This compiler is provided as part of the Microsoft (R) .NET Framework, but only supports language versions up to C# 5, which is no longer the latest version. For compilers that support newer versions of the C# programming language, see http://go.microsoft.com/fwlink/?LinkID=533240

warning CS2008: No source files specified
error CS1541: Invalid reference option: 'C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Temporary ASP.NET
        Files\root\442dd867\' -- cannot reference directories
error CS1562: Outputs without source must have the /out option specified
```

## Compilers

It is confusing, but .NET development has several different .NET compilers. The compiler is `csc.exe`, but there are different versions:

  - .NET Framework's `csc.exe`

    - For example, .NET 4.6 is located here:
`C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe`

  - Visual Studio's `csc.exe`

    - Visual Studio 2013 is located here:
`C:\Program Files (x86)\MSBuild\12.0\Bin\csc.exe`

    - Visual Studio 2015 is located here:
`C:\Program Files (x86)\MSBuild\14.0\Bin\csc.exe`

  - Roslyn's `csc.exe` (example below uses version 1.0.0)

    - Roslyn inside application bin folder, for example:
`/bin/roslyn/csc.exe`

So there are multiple compilers in different locations, and unfortunately, the versions of `csc.exe` are different. If they were all the same version, I don't think I would see the error of compiling C# 6 code using a C# 5 compiler.

In summary, the following are the different versions when I checked:

  - .NET Framework's csc.exe - version 4.7.2556.0

  - Visual Studio 2013 - version 12.0.21005.1

  - Visual Studio 2015 - version 1.3.1.60616

  - Roslyn (1.0.0) - version 1.0.0.50618

```
C:\>"C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe"
Microsoft (R) Visual C# Compiler version 4.7.2556.0
for C# 5
Copyright (C) Microsoft Corporation. All rights reserved.

This compiler is provided as part of the Microsoft (R) .NET Framework, but only supports language versions up to C# 5, which is no longer the latest version. For compilers that support newer versions of the C# programming language, see http://go.microsoft.com/fwlink/?LinkID=533240

warning CS2008: No source files specified
error CS1562: Outputs without source must have the /out option specified

C:\>"C:\Program Files (x86)\MSBuild\12.0\Bin\csc.exe"
Microsoft (R) Visual C# Compiler version 12.0.21005.1
for C# 5
Copyright (C) Microsoft Corporation. All rights reserved.

warning CS2008: No source files specified
error CS1562: Outputs without source must have the /out option specified

C:\>"C:\Program Files (x86)\MSBuild\14.0\Bin\csc.exe"
Microsoft (R) Visual C# Compiler version 1.3.1.60616
Copyright (C) Microsoft Corporation. All rights reserved.

warning CS2008: No source files specified.
error CS1562: Outputs without source must have the /out option specified

C:\>"C:\projects\WebApplication1\WebApplication1\bin\roslyn\csc.exe"
Microsoft (R) Visual C# Compiler version 1.0.0.50618
Copyright (C) Microsoft Corporation. All rights reserved.

warning CS2008: No source files specified.
error CS1562: Outputs without source must have the /out option specified
```

That's why when I build the solution with Visual Studio 2015, it works fine because it uses a different `csc.exe`, but errors sometimes appear when deploying to local IIS or the cloud. Also, ASP.NET MVC Razor uses a different compiler than C#. For example, if you have the following code, with a target framework of 4.6 and you're not using Roslyn, it will build fine but you'll see a compiler error when deploying locally.

```
@model WebApplication1.Models.MyModel
@if (string.IsNullOrWhiteSpace(Model.Test?.ToLower()))
{

}
```

## Roslyn

It looks like things are moving toward using `Roslyn`, so make sure these two NuGet packages are available in your solution: `Microsoft.CodeDom.Providers.DotNetCompilerPlatform` and `Microsoft.Net.Compilers`. Also, make sure the web.config changes are applied. Roslyn should be able to determine what version is appropriate for your solution.

It should be simple — just add the following NuGet packages. But make sure the web.config is updated. Sometimes I've had the issue where the web.config is updated locally but the IIS site's web.config is not updated, so it ends up not using Roslyn and instead using the .NET Framework's `csc.exe` compiler.

### NuGet Packages

1. Microsoft.CodeDom.Providers.DotNetCompilerPlatform

2. Microsoft.Net.Compilers

### WebConfig

```






```

## Conclusion

When deploying ASP.NET MVC applications that use C# 6 or later features, you may encounter compiler errors because the default .NET Framework `csc.exe` only supports up to C# 5. The solution is to install the Roslyn NuGet packages (`Microsoft.CodeDom.Providers.DotNetCompilerPlatform` and `Microsoft.Net.Compilers`) and ensure the web.config is properly updated to use Roslyn as the compiler.

## References

  - Command-line build with csc.exe

  - How to add dynamic compilation to your C# projects?

  - Github - roslyn

  - Removing roslyn from ASP.NET 4.5.2 project template

  - Publish website without roslyn


.NET Compiler Roslyn


## Table of Contents

1. [Introduction](#introduction)
2. [gulpfile.js](#gulpfilejs)
3. [package.json](#packagejson)
4. [Other Resources](#other-resources)
5. [Conclusion](#conclusion)

## Introduction

This post shows how to use Gulp with an ASP.NET MVC 4.5.2 template and Browserify. Below are some useful references:

- Using Gulp - Microsoft
- Setting up Gulp and Bower for an ASP.NET MVC project in Visual Studio 2013
- How to use Gulp in Visual Studio
- Advanced AngularJS structure with Gulp, Node and Browserify
- Using Grunt/Gulp for Bundling and Minification in ASP.NET
- Migrating From ASP.NET MVC 5 to MVC 6
- Introducing Gulp, Grunt, Bower, and npm support for Visual Studio
- ASP.NET 5: Managing Client-side Dependencies with NPM, Bower and Gulp

## gulpfile.js

```
var gulp = require('gulp');
var connect = require('gulp-connect');
// requires browserify and vinyl-source-stream
var browserify = require('browserify');
var source = require('vinyl-source-stream');
var concat = require('gulp-concat');
//var cssmin = require("gulp-cssmin");
var uglify = require("gulp-uglify");

gulp.task('connect', function () {
    connect.server({
        root: 'public',
        port: 4000
    })
});

gulp.task('browserify.1', function () {
    // Grabs the app.js file
    return browserify('./app/test1/app.js')
        // bundles it and creates a file called main.js
        .bundle()
        .pipe(source('main.js'))
        // saves it the public/js/ directory
        .pipe(gulp.dest('./public/js/'));
});

gulp.task('browserify.2', function () {
    // Single point of entry (make sure not to src ALL your files, browserify will figure it out for you)
    //gulp.src(['./app/test2/app.js'])
    //.pipe(browserify({
    //    insertGlobals: true,
    //    debug: true
    //}))
    //// Bundle to a single file
    //.pipe(concat('bundle.js'))
    //// Output it to our dist folder
    //.pipe(gulp.dest('./public/js/'));

    // Grabs the app.js file
    return browserify('./app/test2/app.js')
        // bundles it and creates a file called main.js
        .bundle()
        .pipe(source('main.2.js'))
        // Bundle to a single file
        //.pipe(concat('bundle.js'))
        // saves it the public/js/ directory
        .pipe(gulp.dest('./public/js/'));
});

gulp.task('browserify.3', function () {
    // Grabs the app.js file
    return browserify('./app/test3/app.js')
        // bundles it and creates a file called main.js
        .bundle()
        .pipe(source('main.3.js'))
        // saves it the public/js/ directory
        .pipe(gulp.dest('./public/js/'));
});

gulp.task("min:js", function () {
    gulp.src(["./public/js/main.2.js"], { base: "." })
        .pipe(concat("./public/js/dist/main.2.js"))
        .pipe(uglify())
        .pipe(gulp.dest("."));

    gulp.src(["./public/js/main.js"], { base: "." })
    .pipe(concat("./public/js/dist/main.js"))
    .pipe(uglify())
    .pipe(gulp.dest("."));

    gulp.src(["./public/js/main.3.js"], { base: "." })
     .pipe(concat("./public/js/dist/main.3.js"))
     .pipe(uglify())
     .pipe(gulp.dest("."));
});

gulp.task("min", ["min:js"]);

// Views task
gulp.task('views', function () {
    //// Get our index.html
    //gulp.src('./app/test2/index.html')
    //// And put it in the dist folder
    //.pipe(gulp.dest('dist/'));

    // Any other view files from app/views
    gulp.src('./app/test2/views/**/*')
    // Will be put in the dist/views folder
    .pipe(gulp.dest('./public/app/test2/views/'));
});

gulp.task('watch', function () {
    gulp.watch('app/**/*.js', ['browserify.2', 'browserify.1', 'views'])
});

gulp.task('default', ['connect', 'watch']);
```

## package.json

```
{
  "name": "test_angular",
  "version": "1.0.0",
  "description": "test",
  "main": "index.js",
  "dependencies": {
    "angular": "^1.5.5",
    "gulp": "^3.9.1"
  },
  "devDependencies": {
    "angular": "^1.5.5",
    "angular-route": "^1.5.5",
    "browserify": "^13.0.0",
    "gulp-concat": "^2.6.0",
    "gulp-connect": "^3.2.2",
    "gulp-cssmin": "^0.1.7",
    "gulp-uglify": "^1.5.3",
    "vinyl-source-stream": "^1.1.0"
  },
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "repository": {
    "type": "git",
    "url": "no git"
  },
  "keywords": [
    "no",
    "keywords"
  ],
  "author": "",
  "license": "ISC"
}
```

## Other Resources

- Introduction to Bower, Grunt, and Gulp in Visual Studio
- How to use Gulp in Visual Studio
- ASP.NET - Progressive Enhancement with ASP.NET and React

## Conclusion

Using Gulp with ASP.NET MVC 4.5.2 along with Browserify allows you to bundle, minify, and manage your front-end JavaScript modules efficiently. The gulpfile and package.json above provide a working starting point for your project.


How to use Gulp with ASP.NET MVC 4.5.2 Template and Browserify.

Gulp ASP.NET MVC 4.5.2 Template and Browserify

## Table of Contents

1. [Introduction](#introduction)
2. [What's Swagger?](#whats-swagger)
3. [Use Azure API App Template with Swagger](#use-azure-api-app-template-with-swagger)
4. [Can I Use a Customized Stylesheet for Swagger?](#can-i-use-a-customized-stylesheet-for-swagger)
5. [Can I Add My Own JavaScript File to Swagger API Documents?](#can-i-add-my-own-javascript-file-to-swagger-api-documents)
6. [Can We Change the Entire HTML?](#now-we-know-we-can-change-javascript-css-can-we-change-the-entire-html)
7. [Add .NET XML Comment for Swagger's API Description](#add-net-xml-comment-for-swaggers-api-description)
8. [Conclusion](#conclusion)

## Introduction

This walkthrough tutorial is about how to set up Swagger with ASP.NET MVC API
by using Visual Studio 2015, and also provides steps on how to customize the
Swagger UI.

## What's Swagger?

Swagger could provide richer documentation for your API, but that's not all — it
provides tools to design, test, and document your API. Although this
blog just focuses on how to set up Swagger UI on Visual Studio 2015's ASP.NET
API project. ASP.NET MVC also has a Web API Helper page, but unlike Swagger,
which is more powerful with client generation, discoverability, and broader
developer support.

This blog will show how to use Swagger with an ASP.NET MVC API project and provide
a list of how-tos.

> With a Swagger-enabled API, you get interactive documentation, client SDK
> generation and discoverability.

```
Install-Package Swashbuckle
```

The following are a few resources related to Swagger.

- [swagger.io](http://swagger.io/)

- Swashbuckle

- swagger-codegen

- swagger-ui

- OpenAPI Specification

## Use Azure API App Template with Swagger

You can use Swagger with Visual Studio 2015, ASP.NET 4.5.2 Templates. Once you
use Visual Studio and create a web application using the Azure API App template, in
your solution you should see the following Swagger entry in the package file.

![](http://res.cloudinary.com/dmwrakaup/image/upload/v1458931625/vrtczaiykyxoxtecgloc.png)

You will find the NuGet library `Swashbuckle`, which is the .NET version of
Swagger. If you want to use the latest NuGet version, you can use NuGet to
uninstall the package and install the latest NuGet package again.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_dp4q0c174.png)

### SwaggerConfig, EnableSwaggerUi, and Basic Configuration

After installing Swashbuckle, you will see a SwaggerConfig under your
App_Start folder. This `SwaggerConfig` is the starting point to enable
Swagger. If you already have the following content, then your setup is
done. We should see the API documentation generated by Swagger.

```
[assembly: PreApplicationStartMethod(typeof(SwaggerConfig), "Register")]

namespace WebApplication1
{
    public class SwaggerConfig
    {
        public static void Register()
        {
            var thisAssembly = typeof(SwaggerConfig).Assembly;

            GlobalConfiguration.Configuration

                .EnableSwagger(c =>
                    // {...
                    // this will enable swagger UI
                .EnableSwaggerUi(c =>
```

### Build the Solution and Check the URL

Navigate to `{yoururl}/swagger` or `{yoururl}/swagger/ui/index`.

You should be able to see the following Swagger UI documentation page. I
have two Web APIs, `TestController` and
`ValuesController`. As you can see, it contains a search feature
and you can try it out.

![](http://res.cloudinary.com/dmwrakaup/image/upload/v1458932570/vbbqw3dh7xbalqxmxlyd.png)

![](https://d1p0mp3f1fx0hz.cloudfront.net/_3cxww0sfn.png)

However, I also had the following questions when I first saw these pages
generated by Swagger.

- Can I change this API document's UI, including the logo and stylesheet?

- Can I add JavaScript to this?

- Can I change the URL instead of /swagger?

- Can I add my own page to this auto-generated page?

- Can I make certain Web APIs not show up?

- Can I turn the Swagger API documentation off in production, but keep it only in
  development?

I might not cover all these questions I have in mind, but I will give them a
try and list them here.

## Can I Use a Customized Stylesheet for Swagger?

Let's assume I want to change the following style, which changes the header
background color to `#704C8F`.

### 1. CSS File

```
.swagger-section #header {
    background-color: #704C8F;
    padding: 14px;
}
```

### 2. SwaggerConfig

```
.EnableSwaggerUi(c =>                   {
c.InjectStylesheet(Assembly.GetAssembly(typeof(WebApiApplication)), "WebApplication2.styles.swagger_test.css");
```

### 3. Global.asax

#### How the WebApiApplication Looks

The SwaggerConfig's InjectStyleSheet's first parameter needs to pass the
current application's assembly. The second parameter is a little tricky. The
filename `WebApplication2.styles.swagger_test.css` is
`Project Folder name`.`{folder name}` and the file name.

```
namespace WebApplication2
{
    public class WebApiApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
        }
    }
}
```

#### 4. Styles File Location

Also, this is very important — you must set the file's Build Action to Embedded
Resource.

```

```

#### 5. After Steps 1–4, How the Page Looks

![](http://res.cloudinary.com/dmwrakaup/image/upload/v1458968917/vetiqfmu4mizsfyolm2h.png)

## Can I Add My Own JavaScript File to Swagger API Documents?

You are able to do it as follows. Assume you have a JavaScript file like this.

### 1. JavaScript

```
(function () {
    function init() {

        console.info("init for my swagger function");

        $("#explore").click(function () {
            alert("you clicked explore");
        });
    }

    init();
})();
```

### 2. JavaScript File Location and Build Action Property

```

```

### 3. SwaggerConfig Class

Set the JavaScript path as a string type like the following.

```
var myAssembly = Assembly.GetAssembly(typeof(WebApiApplication));
   c.InjectJavaScript(myAssembly, "WebApplication2.js.swagger_test.js");
```

### 4. Done, Check the Page

When the page loads, you can see the JavaScript console message. Now you can
add JavaScript to the page. My next question is: can I change the default HTML?

![](http://res.cloudinary.com/dmwrakaup/image/upload/v1458969860/h3novy9llbwau4kearez.png)

## Now, We Know We Can Change JavaScript, CSS — Can We Change the Entire HTML?

Yes, and the main features will still work if you use Swagger's existing
JavaScript. The following is how we can do it.

### 1. HTML Files

This time I want to add two HTML files. After creating these HTML files, you also have to
change the Build Action to Embedded Resource again.

![](http://res.cloudinary.com/dmwrakaup/image/upload/v1458971711/evgs4ci6wclqwpqpirxg.png)

swagger_test.html

```
Bomm!!!!
```

OtherVersion.html

```
<!DOCTYPE html>



    Swagger UI My Own Version






















    
    
    
    


    $(function () {
      var url = window.location.search.match(/url=([^&]+)/);
      if (url && url.length > 1) {
        url = decodeURIComponent(url[1]);
      } else {
        url = "http://petstore.swagger.io/v2/swagger.json";
      }

      // Get Swashbuckle config into JavaScript
      function arrayFrom(configString) {
        return (configString !== "") ? configString.split('|') : [];
      }

      function stringOrNullFrom(configString) {
        return (configString !== "null") ? configString : null;
      }

      window.swashbuckleConfig = {
        rootUrl: 'http://localhost:65343',
        discoveryPaths: arrayFrom('swagger/docs/v1'),
        booleanValues: arrayFrom('true|false'),
        validatorUrl: stringOrNullFrom('http://localhost:65343/validator'),
        customScripts: arrayFrom('ext/WebApplication2-js-swagger_test-js'),
        docExpansion: 'none',
        oAuth2Enabled: ('false' == 'true'),
        oAuth2ClientId: '',
        oAuth2ClientSecret: '',
        oAuth2Realm: '',
        oAuth2AppName: '',
        oAuth2ScopeSeperator: ' ',
        oAuth2AdditionalQueryStringParams: JSON.parse('{}')
      };

      // Pre load translate...
      if(window.SwaggerTranslator) {
        window.SwaggerTranslator.translate();
      }
      window.swaggerUi = new SwaggerUi({
        url: swashbuckleConfig.rootUrl + "/" + swashbuckleConfig.discoveryPaths[0],
        dom_id: "swagger-ui-container",
        booleanValues: swashbuckleConfig.booleanValues,
        onComplete: function(swaggerApi, swaggerUi){
          if (typeof initOAuth == "function" && swashbuckleConfig.oAuth2Enabled) {
            initOAuth({
              clientId: swashbuckleConfig.oAuth2ClientId,
              clientSecret: swashbuckleConfig.oAuth2ClientSecret,
              realm: swashbuckleConfig.oAuth2Realm,
              appName: swashbuckleConfig.oAuth2AppName,
              scopeSeparator: swashbuckleConfig.oAuth2ScopeSeperator,
              additionalQueryStringParams: swashbuckleConfig.oAuth2AdditionalQueryStringParams
            });
          }

          if(window.SwaggerTranslator) {
            window.SwaggerTranslator.translate();
          }

          $('pre code').each(function(i, e) {
            hljs.highlightBlock(e)
          });

          addApiKeyAuthorization();

          window.swaggerApi = swaggerApi;
          _.each(swashbuckleConfig.customScripts, function (script) {
            $.getScript(script);
          });
        },
        onFailure: function(data) {
          log("Unable to Load SwaggerUI");
        },
        docExpansion: swashbuckleConfig.docExpansion,
        jsonEditor: false,
        apisSorter: null, // default to server
        defaultModelRendering: 'schema',
        showRequestHeaders: false
      });

      if (window.swashbuckleConfig.validatorUrl !== '')
        window.swaggerUi.options.validatorUrl = window.swashbuckleConfig.validatorUrl;

      function addApiKeyAuthorization(){
        var key = encodeURIComponent($('#input_apiKey')[0].value);
        if (key && key.trim() != "") {
          var apiKeyAuth = new SwaggerClient.ApiKeyAuthorization("api_key", key, "query");
            window.swaggerUi.api.clientAuthorizations.add("api_key", apiKeyAuth);
            log("added key " + key);
        }
      }

      $('#input_apiKey').change(addApiKeyAuthorization);

      // if you have an apiKey you would like to pre-populate on the page for demonstration purposes...
      /*
        var apiKey = "myApiKeyXXXX123456789";
        $('#input_apiKey').val(apiKey);
      */

      window.swaggerUi.load();

      function log() {
        if ('console' in window) {
          console.log.apply(console, arguments);
        }
      }
  });



    Damn, I love this! Swagger!





```

### 2. SwaggerConfig for HTML

```
c.CustomAsset("swagger_test", myAssembly, "WebApplication2.html.swagger_test.html");
                        c.CustomAsset("OtherVersion", myAssembly, "WebApplication2.html.OtherVersion.html");
```

### 3. Check the Browser

Now, you're going to ask: what's the URL? I didn't figure it out at
first, but it looks like Swagger uses the file name as the URL. Since
their default page is /swagger/ui/index, my new files' URLs will be
`/swagger/ui/OtherVersion` and
`/swagger/ui/swagger_test`.

The following is one of my new pages, OtherVersion. Isn't this great? As a
developer, when you use another UI framework and you can replace CSS, JavaScript,
and HTML while keeping the original logic, that's just fantastic.

![](http://res.cloudinary.com/dmwrakaup/image/upload/v1458972150/uiblm9hoxxitxz1fgxls.png)

## Add .NET XML Comment for Swagger's API Description

ASP.NET WebAPI's default API helper documentation also looks for the DLL's XML comments
for descriptions. We can do that in Swagger too.

### 1. Project Property

The first thing you need to do is go to the project that contains the API
controller and check the XML documentation file. When building the solution,
Visual Studio will update the XML with comments you add to the class. Also,
Swagger will later read the XML comments as descriptions for the API.

![](http://res.cloudinary.com/dmwrakaup/image/upload/v1459030325/o170ozq0mak76k8hfoqi.png)

### 2. SwaggerConfig Setting

The next important thing is that Swagger has not registered the API XML. You can
add it as follows.

```
c.IncludeXmlComments(string.Format(@"{0}\bin\APIDemo.XML", System.AppDomain.CurrentDomain.BaseDirectory));
```

The following are examples of the WebAPI controller and the API Model class's XML
documentation.

```
///
    /// my product
    ///
    public class Product
    {
        ///
        /// product id
        ///
        public Guid GuidId { get; set; }
        ///
        /// product Id
        ///
        public int ProductId { get; set; }
        ///
        /// product name
        ///
        public string ProductName { get; set; }
        ///
        /// product price
        ///
        public decimal Price { get; set; }
        ///
        /// product unit
        ///
        public int Unit { get; set; }
```

```
///
    /// ProductController API
    ///
    public class ProductController : ApiController
    {
        ///
        /// products data
        ///
        public static ListProducts
        {
            get
            {
                return new List
                {
                    new Product(Guid.NewGuid(), 122, "Product A", 300, 1),
                    new Product(Guid.NewGuid(), 333, "Product B", 400, 10),
                    new Product(Guid.NewGuid(), 444, "Product C", 500, 20),
                    new Product(Guid.NewGuid(), 555, "Product D", 600, 15),
                    new Product(Guid.NewGuid(), 777, "Product E", 700, 5)
                };
            }
        }

        ///
        ///  get values for products
        ///
        ///
        public IEnumerable Get()
        {
            return Products;
        }
```

### 3. Done! Let's Browse the API Documentation

Now we're done. After building the solution, you should see your XML comments
added to the C# class on the Swagger API documentation page.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_iw664rs80.png)

## Conclusion

Swagger with ASP.NET MVC provides very powerful API documentation and it
is very flexible. You can customize the CSS, JavaScript, and HTML while retaining the core Swagger functionality.

Check the
Code
mentioned in this blog.

This walkthrough tutorial is about how to set up Swagger with ASP.NET MVC API by using Visual Studio 2015, also provides steps of how to customize the Swagger UI.

How to Setup and Customize Swagger with ASP.NET MVC


## Table of Contents

1. [Introduction](#introduction)
2. [packages.config](#packagesconfig)
3. [Startup Class](#startup-class)
4. [API Controller Class: TestController](#api-controller-class-testcontroller)
5. [Interface](#interface)
6. [Class Implementing Interface](#class-implementing-interface)
7. [Autofac Service Module](#autofac-service-module)
8. [Conclusion](#conclusion)

## Introduction

This blog shows how to set up Autofac for dependency injection in ASP.NET Web API 2 with Owin.

## packages.config

Following is the packages.config. You can use this NuGet command to install all
of these to your project: `Update-Package -ProjectName MyProject -reinstall`

```
<?xml version="1.0" encoding="utf-8"?>















```

## Startup Class

```
using Autofac;
using Autofac.Integration.WebApi;
using Microsoft.Owin;
using Owin;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Web;
using System.Web.Compilation;
using System.Web.Http;
using WebApplication2.Controllers;

[assembly: OwinStartup(typeof(WebApplication2.Startup))]
namespace WebApplication2
{
    public class Startup
    {
        public void Configuration(IAppBuilder app)
        {
            HttpConfiguration config = new HttpConfiguration();
            // register api routing.
            WebApiConfig.Register(config);
            app.UseWebApi(config);

            var builder = new ContainerBuilder();

            var assemblies = BuildManager.GetReferencedAssemblies().Cast().ToArray();

            builder.RegisterAssemblyModules(assemblies);
            builder.RegisterApiControllers(assemblies);

            var container = builder.Build();
            config.DependencyResolver = new AutofacWebApiDependencyResolver(container);

            app.UseAutofacMiddleware(container);
            app.UseAutofacWebApi(config);
            app.UseWebApi(config);
        }
    }
}
```

## API Controller Class: TestController

```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;

namespace WebApplication2.Controllers
{
    public class TestController : ApiController
    {
        Interface1 _i;
        public TestController(Interface1 i)
        {
            _i = i;
        }

        public IHttpActionResult Get()
        {

            return Ok(new List() { "Hi", "I", "'m", "Just", "testing" });
        }
    }
}
```

## Interface

```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace WebApplication2
{
    public interface Interface1
    {
        string Do();
    }
}
```

## Class Implementing Interface

```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace WebApplication2
{
    public class Class1 : Interface1
    {
        public string Do()
        {
            return Guid.NewGuid().ToString();
        }
    }
}
```

## Autofac Service Module

```
using Autofac;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace WebApplication2
{
    public class ServiceModule : Module
    {
        protected override void Load(ContainerBuilder builder)
        {
            builder.RegisterType().As().InstancePerDependency();
        }
    }
}
```

## Conclusion

With Autofac and Owin, you can easily set up dependency injection in your ASP.NET Web API 2 project. The key steps are configuring the Owin startup class, registering your controllers and services with Autofac, and creating service modules for your dependency bindings.


How to set up ASP.NET Web API 2 with Autofac and Owin for dependency injection.

ASP.NET Web API 2 with Autofac Owin


## Table of Contents

1. [Encrypt connectionString](#encrypt-connectionstring)
2. [Decrypt connectionString](#decrypt-connectionstring)
3. [Complicated!!](#complicated)

## Introduction

This post explains how to use `aspnet_regiis.exe` to encrypt and decrypt the `connectionString` section in your Web.config file, and how to share encrypted connection strings across environments or web farms.

## Encrypt connectionString

The following task is only for the initial check-in of the encrypted connectionString. Once you have checked in the encrypted connectionString, you do not need to do the following again.

What the following command does is use `aspnet_regiis.exe` to encrypt the `connectionStrings` section from Web.config using a custom provider.

```
C:\Windows\Microsoft.NET\Framework\v4.0.30319>aspnet_regiis.exe -pef connectionStrings C:Projects2013\LDWebsite\Source\Development\DEV3\Website -prov "customProvider"
C:\Windows\Microsoft.NET\Framework\v4.0.30319>aspnet_regiis.exe -pef connectionStrings {location where contains Web.config} -prov "customProvider"
```

## Decrypt connectionString

Copy the encrypted connectionString to the Web.config's connectionString section and run the following task. Then it will decrypt the connectionString. The following example checks the C drive's website folder's Web.config.

```
C:\Windows\Microsoft.NET\Framework\v4.0.30319>aspnet_regiis.exe -pdf connectionStrings C:\Website -prov "customProvider"
```

### Share Encrypted connectionString to Other Environments or Web Farms

First, you need to export the container key as XML by running the following command:

```
C:\Windows\Microsoft.NET\Framework\v4.0.30319>aspnet_regiis.exe -px "YourRSAKeyName" "c:\xmlKey.xml"
```

At the other environment, just try to run the following commands:

```
set "keyPath=%cd%\xmlKey.xml"
cd C:\Windows\Microsoft.NET\Framework\v4.0.30319
aspnet_regiis -pi "myKey" "%keyPath%"
aspnet_regiis -pa "myKey" "NT AUTHORITY\NETWORK"
pause
```

```
:: This task is for adding the RSA key to each machine so that the encrypted connectionString can be used in any environment: local, dev, QA, or web farm.
:: The Web.config's connectionString is already encrypted. If you don't run this task, the application would not be able to use the encrypted connectionString.
:: Following are the prerequisites for running this task:
:: 1. Target machine has .NET 4.0
:: 2. Under C:\Windows\Microsoft.NET\Framework\v4.0.30319, aspnet_regiis exists
:: 3. Website's application pool identity is running under NetworkService
:: If the above 1-3 are valid, you're ready to run this command line.
:: The first task registers the RSA Key Container on the machine.
:: The second task grants NetworkService permission to the RSA Key Container.
:: After running these two tasks, if you see 'Succeeded!', then you're good!
:: For how to use aspnet_regiis.exe to encrypt Web.config, see above.
```

## Complicated!!

I know, we could just use the same service account for the application pool and use that account to connect to the database, so we could remove the user and password from the connection string.

## Conclusion

Using `aspnet_regiis.exe` is a reliable way to encrypt and decrypt connection strings in your Web.config. While the process involves multiple steps—especially when sharing keys across environments or web farms—it ensures sensitive database credentials are not stored in plain text. Alternatively, using a shared service account for the application pool can simplify things by removing credentials from the connection string entirely.


How to encrypt and decrypt Web.config connectionString using aspnet_regiis

Encrypt and Decrypt Web.config ConnectionString Using aspnet_regiis


## Table of Contents

1. [Introduction](#introduction)
2. [Web.config](#webconfig)
3. [Register Bundle to Sitecore - Part 1](#register-bundle-to-sitecore---part-1)
4. [Register Bundle to Sitecore - Part 2](#register-bundle-to-sitecore---part-2)
5. [Conclusion](#conclusion)
6. [References](#references)

## Introduction

This blog shows how to enable ASP.NET Bundle & Minification for JavaScript and CSS in Sitecore. The following example is based on these technologies:

  - Sitecore 7.2

  - ASP.NET MVC 5

  - Visual Studio 2013

## Web.config

Add the following module to the web.config modules section:

```





```

## Register Bundle to Sitecore - Part 1

For registering the bundle, you need to add the following code.

Note that you don't need to add anything in the Global.asax class to register bundles, as you would with default ASP.NET MVC bundle behavior.

```
using Sitecore;
using Sitecore.Pipelines;
using System.Web.Optimization;

namespace YourNamespace
{
    ///
    /// SiteCore bundle register
    ///
    public class RegisterBundles
    {
        [UsedImplicitly]
        public virtual void Process(PipelineArgs args)
        {
            Bundles(BundleTable.Bundles);
        }

        ///
        /// add bundle collection when application start
        /// at here, you can add as regular
        ///
        ///
        private void Bundles(BundleCollection bundles)
        {

            bundles.Add(new ScriptBundle("~/bundles/jquery").Include(
                        "~/Scripts/jquery-{version}.js"));

        }
    }
}
```

## Register Bundle to Sitecore - Part 2

You need to add the following config file. Any name is fine — Sitecore will pick it up. Let's call it **bundle.config**. Put the file under `{YourAspnetWebSiteFolder}/App_Config/Include/{PutHere}`, or any location where your site loads the Sitecore config.

```





    ```

That's it! You should be able to use ASP.NET Bundle & Minification now as follows:

```
@Scripts.Render("~/bundles/jquery")
```

## Conclusion

Enabling ASP.NET Bundle & Minification in Sitecore requires adding the bundle module to the web.config, creating a bundle registration class, and adding a Sitecore pipeline config file. Once set up, you can use bundles just like in a standard ASP.NET MVC application.

## References

- Sitecore with MVC4


This blog shows how to enable ASP.NET Bundle & Minification for JavaScript and CSS in Sitecore.

MVC Bundle and Minification at Sitecore


## Table of Contents

1. [Introduction](#introduction)
2. [Official Resources](#official-resources)
3. [Sitecore Blogs](#sitecore-blogs)
4. [Learning Resources](#learning-resources)
5. [Conclusion](#conclusion)

## Introduction

A list of resources for learning Sitecore. Although I don't like Sitecore, just in case
I have to work with it, following are links for reference.

## Official Resources

[Sitecore Official Site](http://www.sitecore.net/)

## Sitecore Blogs

[Sitecore Blog - 1

Sitecore Blog - 2

Sitecore Blog - 3

Sitecore Blog - 4

Sitecore Blog - 5](http://sitecoreexperiences.blogspot.com/)

[Sitecore Blog - 6](http://webcmd.wordpress.com/)

Sitecore Blog - 7

NewGuid.Net

All Sitecore related content.

Wikipedia Sitecore

## Learning Resources

Learn Sitecore - 1 - firebreaksice

Learn Sitecore - 2

Learn Sitecore - 3 - great documents

## Conclusion

These resources should provide a good starting point for anyone needing to learn Sitecore for development purposes.


A list of resources for learning Sitecore. Although I don't like Sitecore, just in case I have to work with it, following are links for reference.

List of Useful Links to Learn Sitecore


## Table of Contents

- [Introduction](#introduction)
- [Download Source Code](#download-source-code)
- [Setup at IIS](#setup-at-iis)
- [Troubleshooting Permission Errors](#troubleshooting-permission-errors)
- [Conclusion](#conclusion)

## Introduction

Open-source Orchard CMS is awesome. This blog demonstrates how to download the source code and set it up on IIS.

## Download Source Code

Download the source code or pre-deployed code from the Orchard site.

![](http://res.cloudinary.com/dmwrakaup/image/upload/v1411602221/xrcqfk4svuxbirtrco3o.png)

## Setup at IIS

Set up IIS by creating a website and using the source code you just downloaded.

![](http://res.cloudinary.com/dmwrakaup/image/upload/v1411602372/jlol6dkbxyqizyl5guhi.png)

## Troubleshooting Permission Errors

You might see the following error, which means your deployed code doesn't have permission for `IUser_Machine`, or the folder or location is not accessible for `IUser_Machine`, or your application pool is using an old .NET Framework version.

Add `IUser_Machine` permission to your application folder. If you don't add the permission, you might see the following errors:

![](https://d1p0mp3f1fx0hz.cloudfront.net/_vpikjbmtc.png)

![](https://d1p0mp3f1fx0hz.cloudfront.net/_bwy9fdw9j.png)

![](https://d1p0mp3f1fx0hz.cloudfront.net/_45uyoxosk.png)

## Conclusion

Deploying Orchard CMS to IIS involves downloading the source code, creating an IIS website, and ensuring proper permissions are set for the application folder. If you encounter errors, check that `IUser_Machine` has the correct permissions and that the application pool is configured with the correct .NET Framework version.


Orchard CMS is an awesome open-source platform. This blog demonstrates how to download the source code and set it up on IIS.

How to Deploy Orchard CMS Open Source to IIS


## Table of Contents

1. [Introduction](#introduction)
2. [Download and Set Up Orchard](#download-and-set-up-orchard)
3. [Create the Scaffold Project](#create-the-scaffold-project)
4. [Enable Permissions](#enable-permissions)
5. [Conclusion](#conclusion)

## Introduction

This blog shows how to create a HelloWorld module in Orchard, an ASP.NET MVC open source application, and how to add the module as a role at the create role page.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_8zjywdrma.png)

![](https://d1p0mp3f1fx0hz.cloudfront.net/_7munrpija.png)

## Download and Set Up Orchard

First, you need to download Orchard. The following is a great blog to get you started — it has more detailed information on how to create a HelloWorld module than this blog:

HelloWorld Orchard

After you download the source code, you can just build and start the web application as Orchard.Web, and then you can start your web application.

## Create the Scaffold Project

Based on the above Orchard Hello document, you can create the scaffold project by typing the following command:

```
Orchard.Web\bin>orchard.exe
orchard> codegen module HelloWorld
orchard> feature enable HelloWorld
```

If you add a controller and view like the following, then your first HelloWorld is finished.

![](http://res.cloudinary.com/dmwrakaup/image/upload/v1409121218/m7mdilk998cpd0bbmwgp.png)

## Enable Permissions

To enable permissions, you need to create a Permissions file that implements `IPermissionProvider`. The Orchard framework will inject that `IPermissionProvider` to generate the actual logic.

```
using Orchard.Environment.Extensions.Models;
using Orchard.Security.Permissions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace HelloWorld
{
    public class Permissions : IPermissionProvider
    {
        public static readonly Permission SetHomePage = new Permission { Description = "Set Accounting Page", Name = "SetHomePage" };

        public virtual Feature Feature { get; set; }

        public IEnumerable GetPermissions()
        {
            return new[] {
                SetHomePage
            };
        }

        public IEnumerable GetDefaultStereotypes()
        {
            return new[] {
                new PermissionStereotype {
                    Name = "Administrator",
                    Permissions = new[] {SetHomePage}
                },
                new PermissionStereotype {
                    Name = "Editor",
                    Permissions = new[] {SetHomePage}
                }
            };
        }

    }
}
```

You also need to add the new module to the database.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_oc4aff003.png)

After everything is finished, you will notice that in the Add Role view, your HelloWorld module has been added.

![](http://res.cloudinary.com/dmwrakaup/image/upload/v1409121479/ainvoqpagqcukngkjmsm.png)

## Conclusion

Creating a module in Orchard is straightforward: scaffold the project, add a controller and view, and implement `IPermissionProvider` for permissions. Simple, isn't it!?


This blog shows how to create a HelloWorld module in Orchard, an ASP.NET MVC open source application, and how to add the module as a role at the create role page.

How to Get Started With Orchard to Create a Module


This section show how to setup OData Web api

Register WebApi at Application start

```
protected void Application_Start()
{
    GlobalConfiguration.Configure(WebApiConfig.Register);
}
```

Register OData

```
public static void Register(HttpConfiguration config)
        {
            config.MapHttpAttributeRoutes();

 ODataConventionModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet("YourEntityClassOrYourModelClassName");
            config.Routes.MapODataRoute("ODataRoute", "/url/forYourOData", builder.GetEdmModel());
        }
```

Define Odata Api Controller

```
public class YourEntityClassOrYourModelClassController : ODataController
{
        [Queryable]
        public IQueryable GetYourEntityClassOrYourModelClass()
        {
            return ReturnLogicForTheMethod().AsQueryable();
        }
}
```


This section show how to setup OData Web api

Simple Code to Setup WebApi with OData


## Table of Contents

1. [Introduction](#introduction)
2. [About Ninject](#about-ninject)
3. [Get Ninject Library](#get-ninject-library)
4. [Interface](#interface)
5. [Class](#class)
6. [Dependency Resolve Class in Ninject](#dependency-resolve-class-in-ninject)
7. [Set Up Ninject Dependency in Application Global Class](#set-up-ninject-dependency-in-application-global-class)
8. [Setup Ninject Dependency in Ninject Module](#setup-ninject-dependency-in-ninject-module)
9. [Use Ninject Dependency in ASP.NET MVC Controller](#use-ninject-dependency-in-aspnet-mvc-controller)
10. [Unit Test in Ninject + ASP.NET MVC App](#unit-test-in-ninject--aspnet-mvc-app)
11. [Mocking Data in Unit Test - Ninject + Moq](#mocking-data-in-unit-test---ninject--moq)
12. [Conclusion](#conclusion)
13. [Other Choices for Dependency Injection in .NET](#other-choices-for-dependency-injection-in-net)

## Introduction

This post demonstrates how to use Ninject as a dependency injection framework in an ASP.NET MVC application, including setup, unit testing, and mocking with Moq.

## About Ninject

- [NuGet Ninject](https://www.nuget.org/packages/Ninject/)

- [Ninject.org](http://www.ninject.org/)

- Blog - About Ninject in C#

- Code Project - Ninject Example

## Get Ninject Library

```
Install-Package Ninject -Version 3.2.2
```

## Interface

In C#, for using Dependency Injection you'll define your interface and a class that implements this interface. Once you define the interface and bind the relation via Ninject, you can use this interface at other layers without knowing the detail implementation.

```
namespace NinjectConstructorInjectionWeb
{
    public interface ISamurai
    {
        string GetData();
    }
}
```

## Class

```
namespace NinjectConstructorInjectionWeb
{
    public class Samurai : ISamurai
    {
        public string GetData()
        {
            return "my data";
        }
    }
}
```

## Dependency Resolve Class in Ninject

```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.Mvc;
using Ninject.Syntax;
using Ninject;

namespace NinjectConstructorInjectionWeb
{
    public class NinjectDependencyResolver : IDependencyResolver
    {
        private readonly IResolutionRoot _resolutionRoot;

        public NinjectDependencyResolver(IResolutionRoot kernel)
        {
            _resolutionRoot = kernel;
        }

        public object GetService(Type serviceType)
        {
            return _resolutionRoot.TryGet(serviceType);
        }

        public IEnumerable GetServices(Type serviceType)
        {
            return _resolutionRoot.GetAll(serviceType);
        }
    }
}
```

## Set Up Ninject Dependency in Application Global Class

With Ninject, you can either set up binding as follows, or set up binding as individual modules by inheriting from the `NinjectModule` class.

```
protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            RegisterGlobalFilters(GlobalFilters.Filters);
            RegisterRoutes(RouteTable.Routes);


            // setting for Ninject
            IKernel kernel = new StandardKernel();

            kernel.Bind().To();

            DependencyResolver.SetResolver(new NinjectDependencyResolver(kernel));
        }
```

## Setup Ninject Dependency in Ninject Module

```
public  class  MyModule  : NinjectModule
     {
         public  override  void  Load()
         {
             Bind().To()
                 .WithConstructorArgument("kernel" , this .Kernel);
         }
     }
```

## Use Ninject Dependency in ASP.NET MVC Controller

The beauty of doing dependency injection in an ASP.NET MVC controller is passing the interface to the constructor. The user/client doesn't need to know about the interface's implementation logic.

```
private readonly ISamurai _samurai;
public HomeController(ISamurai samurai)
{
    _samurai = samurai;
}

public ActionResult Test()
{
    // you should see "my data" here.
    ViewBag.Hi = _samurai.Attach();
    return View();
}
```

## Unit Test in Ninject + ASP.NET MVC App

Another important benefit of dependency injection with Ninject is unit testing. Because everything is interface-based, you can set up different data in unit tests to test your actual logic.

```
[TestMethod ]
         public  void  Product()
         {
 			  ISamurai  testService = new  Samurai();

 			  HomeController  controller = new  HomeController (testService);

            controller.Product();
         }
```

## Mocking Data in Unit Test - Ninject + Moq

Use Ninject + Moq + Unit Test so you can mock temporary data for the interface and pass it to your controller.

```
public  static  IProductBzService  GetProductService()
         {
             Mock  mock = new  Mock ();
             mock.SetupGet(x => x.Id).Returns(1);
             mock.SetupGet(x => x.Name).Returns("test name" );
             mock.SetupGet(x => x.Price).Returns(11.11m);
             mock.SetupGet(x => x.Unit).Returns(2);
             mock.Setup(x => x.Total()).Returns(999.999m);

             return  mock.Object;
         }
```

## Conclusion

Ninject is a useful C# .NET library for dependency injection. However, it appears that it is no longer actively maintained, so it may become a legacy dependency injection library in the future.

## Other Choices for Dependency Injection in .NET

I would recommend using [Autofac](http://blog.agilistic.nl/a-step-by-step-guide-to-using-ninject-for-dependancy-injection-in-c-sharp/). It is well documented and supports different .NET libraries, such as ASP.NET Web Forms, MVC, WebAPI 1, WebAPI 2, SignalR, RIA, OWIN, WCF, MEF, NHibernate, and Moq.

1. Autofac

2. Castle Windsor

3. StructureMap

4. Spring.NET

5. Unity

6. Puzzle.NFactory

7. Ninject

8. S2Container.NET

9. PicoContainer.NET

10. LinFu


How to use Dependency Injection with Ninject in an ASP.NET MVC application.