
## Table of Contents

1. [Introduction](#introduction)
2. [Getting Started](#getting-started)
3. [Troubleshooting](#troubleshooting)
4. [Running Forever Successfully](#running-forever-successfully)
5. [Sample Server Code](#sample-server-code)
6. [Conclusion](#conclusion)

## Introduction

This is for running on Windows. I was able to make it start but couldn't stop it. I'm still looking for the solution. However, a quick solution is to deploy your Node.js web application to Linux, where forever seems to work. If you use Windows for your deployment, you might want to try IIS-node instead.

When getting started with Node.js, you'll notice that when you stop the Node.js command, your HTTP server stops. You might close the command on purpose, or after a long time, the machine may auto-close the command. In these cases, your Node.js HTTP server will not run automatically. So, in this blog, I'll show how to use forever.

## Getting Started

I searched online, and it looks like lots of people are using the forever module created by nodejitsu. I have referenced their document about how to use forever: keep-a-nodejs-server-up-with-forever. I copied their server-side code to my local machine and tried to run it in the following environment:

- Windows Server 2008 (64-bit)
- Node version: 0.10.26
- npm 1.4.3
- Run as administrator

## Troubleshooting

First try: it didn't work. I got different kinds of errors, like the error on this page: forever issue. So I tried the following things:

1. Deleted all files from the npm folder, under `/Users/{yourname}/AppData/Roaming/`

2. Removed all files except my `server.js`

3. Tried again, still not working. I tried the following commands, all not working:

```
forever server.js
```

```
forever start server.js
```

```
forever node server.js
```

But this time, I saw the error was looking for the following file. I thought this was a Linux thing, but it looks like forever is looking for this file. Then I manually created the folder root, added the folder `.forever` under root, and finally added the log file. Actually, you don't need to add the log file — just the folder `/root/.forever/` needs to exist.

**C:/root/.forever/KsIJ.log**

## Running Forever Successfully

After I set up all of these and typed the command below, this time even though I closed my command window, the site was still running. It looks like it starts a `node.exe` as a background process.

```
forever start server.js


```

## Sample Server Code

Following is the `server.js` code:

```
var util = require('util'),
    http = require('http');

http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.write('hello')
  res.end();
}).listen(8000);

/* server started */
util.puts('> hello running on port 8000');
```

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

Folder structure when running correctly.

## Conclusion

If you look at the following post, you'll notice forever doesn't work well on Windows. I had the same situation — able to start with forever but couldn't stop or list processes. So, there's no point in using it on Windows. Consider deploying to Linux or using IIS-node on Windows instead.

Forever Windows issue

Following are a few links about forever:

- Run Ghost with forever


How to use forever to run Node.js as a background process.

How to Run Node.js as Background by Using Forever


delete all folder, files and sub directory.

```
rm -rf ./{your folder location}
```

http://www.mediacollege.com/linux/command/linux-command.html


Useful Linux Command


## 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.

How to Use Ninject as Dependency Injection with ASP.NET MVC


## Table of Contents

1. [Introduction](#introduction)
2. [Add Index to a Document Field](#add-index-to-a-document-field)
3. [Conclusion](#conclusion)

## Introduction

When working with MongoDB in C#, adding indexes to your document fields improves query performance. Below is a quick code snippet showing how to add an index to both a top-level document field and a subdocument field.

## Add Index to a Document Field

```
// add index to document's field
collection.CreateIndex(IndexKeys.Ascending(_ => _.FieldName));
// add index to subdocument's field
collection.CreateIndex("SubDocument.FieldName");
```

## Conclusion

Adding indexes to your MongoDB collections is essential for query performance. Use `IndexKeys.Ascending` for typed fields on documents and a string path for subdocument fields.


A quick code snippet showing how to set up an index on a MongoDB document or subdocument field using C#.

Code Snippet - How to Add Index to Document at MongoDB C#


## Table of Contents

- [Introduction](#introduction)
- [Find Deadlock Information from SQL Server](#find-deadlock-information-from-sql-server)
- [Fix Deadlock](#fix-deadlock)
- [Reference](#reference)
- [Conclusion](#conclusion)

## Introduction

There are many ways to find SQL Server deadlocks or resolve deadlock issues. In this blog, I will show how to use SQL Server Profiler to detect deadlocks and one example of how to fix them.

## Find Deadlock Information from SQL Server

- Open SQL Server Profiler

- Create a new Trace file

- At the General tab, check "Save to file" and save the file to a shared folder. This is because after stopping the trace, you can analyze the trace log information.

- At the Events Selection tab, expand Locks and check "Deadlock graph". Trace Properties will show an "Events Extraction Settings" tab; then click "Save Deadlock XML events separately" and save the file to a shared folder.

- Click "Run"

- If you know where the application causes the deadlock, then go to the application and reproduce the error.

- Stop the trace.

- Go to the trace file you saved to the shared folder and search for "dead". You should find the deadlock XML.

## Fix Deadlock

My issue was fixed by running the following SQL command:

```
EXEC sp_updatestats
```

## Reference

- http://blogs.msdn.com/b/saponsqlserver/archive/2015/01/18/deadlock-analysis-examples.aspx

- http://blogs.msdn.com/b/saponsqlserver/archive/2013/01/31/deadlock-analysis-basic.aspx

- http://blog.sqlauthority.com/2007/05/16/sql-server-fix-error-1205-transaction-process-id-was-deadlocked-on-resources-with-another-process-and-has-been-chosen-as-the-deadlock-victim-rerun-the-transaction/

- http://sqlmag.com/database-performance-tuning/gathering-deadlock-information-deadlock-graph

## Conclusion

SQL Server Profiler is a useful tool for detecting deadlocks. By saving trace logs and deadlock XML events, you can analyze the root cause and apply fixes such as updating statistics with `sp_updatestats`.


This blog shows how to use SQL Server Profiler to find and fix deadlock issues in SQL Server.

TechnoApple Blogs

Practical guides, tutorials, and insights on cloud, full-stack development, and everything in between.

How to Run Node.js as Background by Using Forever

Useful Linux Command

How to Use Ninject as Dependency Injection with ASP.NET MVC

Code Snippet - How to Add Index to Document at MongoDB C#

How to Find Deadlock Information from SQL Server