
## Table of Contents

1. [Introduction](#introduction)
2. [Save DateTime as GMT Time to MongoDB](#save-datetime-as-gmt-time-to-mongodb)
3. [Reference](#reference)
4. [Conclusion](#conclusion)

## Introduction

When working with MongoDB and C#, it is important to store dates in UTC format for consistency. This post shows how to save `DateTime` as GMT/UTC time in MongoDB using the C# driver.

## Save DateTime as GMT Time to MongoDB

You can set the UTC date at the property level and assign it when inserting.

### Property Attribute to Save Time as UTC

```
[BsonDateTimeOptions(Kind = DateTimeKind.Utc)]
public DateTime UpdateDate { get; set; }
```

### Save Date When Inserting to MongoDB

```
table.CreateDate = DateTime.UtcNow;
```

## Reference

- http://www.nationalgeographic.com/geobee/study-corner/activity-10/

## Conclusion

By using the `[BsonDateTimeOptions(Kind = DateTimeKind.Utc)]` attribute and `DateTime.UtcNow`, you can ensure that all dates stored in MongoDB are in GMT/UTC format, which helps maintain consistency across different time zones.


How to save DateTime as GMT/UTC time in MongoDB using C#.

Set MongoDB GMT Time in C#


## Table of Contents

1. [Introduction](#introduction)
2. [Example of Log WebAPI MVC3 Controller](#example-of-log-webapi-mvc3-controller)
3. [Conclusion](#conclusion)

## Introduction

This post demonstrates how to log every request, response, and exception when accessing an ASP.NET MVC 3 controller using a custom `ActionFilterAttribute`.

## Example of Log WebAPI MVC3 Controller

The following code creates a `LogFilterAttribute` that captures request parameters, URLs, headers, and response status codes for every controller action.

```
public class LogFilterAttribute : ActionFilterAttribute
    {
        ILog _log;

        public LogFilterAttribute()
            : this(null)
        {
        }

        public LogFilterAttribute(ILog log)
        {
			// TODO: define default ILog Service
            //_log = log ?? SomekindOfDefaultLogService()
        }

        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            string controllerNamespace = string.Format("{0} {1}Controller.{2} {3}",
                filterContext.HttpContext.Request.HttpMethod,
                filterContext.ActionDescriptor.ControllerDescriptor.ControllerName,
                filterContext.ActionDescriptor.ActionName, "Request");
            var requestObject = new
            {
                Request = new
                {
                    Parameters = JsonConvert.SerializeObject(filterContext.ActionParameters),
                    Url = filterContext.HttpContext.Request.RawUrl,
                    Headers = JsonConvert.SerializeObject(filterContext.HttpContext.Request.Headers)
                }
            };

            _log.Save(controllerNamespace, JsonConvert.SerializeObject(requestObject));

            base.OnActionExecuting(filterContext);
        }

        public override void OnActionExecuted(ActionExecutedContext filterContext)
        {
            string controllerNamespace = string.Format("{0}Controller.{1} {2}", filterContext.ActionDescriptor.ControllerDescriptor.ControllerName, filterContext.ActionDescriptor.ActionName, "Response");

            var reponseObject = new
            {
                Response = new
                {
                    StatusCode = filterContext.HttpContext.Response.StatusCode,
                    StatusDescription = filterContext.HttpContext.Response.StatusDescription,
                    Exception = JsonConvert.SerializeObject(filterContext.Exception)
                }
            };

            if (filterContext.Exception != null)
            {
                controllerNamespace = controllerNamespace + " Exception";
            }

            _log.Save(controllerNamespace, JsonConvert.SerializeObject(reponseObject));

            base.OnActionExecuted(filterContext);
        }
    }
```

## Conclusion

By using a custom `ActionFilterAttribute`, you can easily log all WebAPI requests and responses in your ASP.NET MVC application. This approach captures request parameters, URLs, headers, response status codes, and any exceptions that occur during controller action execution.


Example code of logging every request, response, and exception when accessing an ASP.NET MVC 3 controller.

How to Log All WebAPI Request Response at ASP.NET MVC


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. [The Problem](#the-problem)
3. [The Extension Method](#the-extension-method)
4. [Conclusion](#conclusion)

## Introduction

In C# you sometimes need to convert an enum to an int value. Here is a simple extension method to make that easier.

## The Problem

Given the following enum:

```
public enum NameType
    {
        Undefined,
        TypeA,
        TypeB,
        TypeC,
        TypeD,
        TypeE = 99
    }
```

You could write like this:

```
(int)NameType.TypeE
```

But what if you could just write like this:

```
NameType.TypeE.ToInt();
```

## The Extension Method

Here is an Enum Extension Class that makes this possible. This is just a basic
example.

```
public static class EnumHelper
    {
        public static int ToInt(this Enum enumValue)
        {
            object val = Convert.ChangeType(enumValue, enumValue.GetTypeCode());
            return Convert.ToInt32(val);
        }
    }
```

## Conclusion

Using extension methods on enums in C# provides a cleaner syntax for common operations like converting to int. You can extend this pattern to add other useful helpers to your enum types.


In C# you sometimes need to convert an enum to an int value. This snippet shows how to create an extension method for enums.

Code Snippet - How to Use Extension with Enum


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

C#

Set MongoDB GMT Time in C#

How to Log All WebAPI Request Response at ASP.NET MVC

Simple Code to Setup WebApi with OData

Code Snippet - How to Use Extension with Enum

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

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

Subscribe for Updates