Tugberk's Blog

Getting Started With ASP.NET Web API - Tutorials, Videos, Samples

Fri, 24 Feb 2012 06:49:00 Z

ASP.NET team shipped the beta version of ASP.NET Web API which has been known as WCF Web API for more than a year. It has seen 6 preview versions and we have now nearly the final bits and pieces. The beta version of the product has been merged with ASP.NET MVC so that we won’t feel ourselves in a fork in the road in order to create REST APIs.

In my opinion, ASP.NET Web API is really exciting because it offers a simple and pluggable way to expose your data to the World. The one of the best parts is that you don’t have to just expose it as XML or JSON. You have the XML and JSON support out of the box but the format of the data is really up to you. Since nearly all of the devices out there today know how to communicate through HTTP, your data has the best possible reach.

One of the other great features of ASP.NET Web API is that everything has been built asynchrony in mind. So, you can scale out very easily. On the other hand, don’t act prejudicial that it is ASP.NET based and cannot run anywhere other than IIS. It has a self hosting capability as well (I honestly don’t know how it works at the background but it looks promising).

It has been not much since the product beta version has shipped but there are pretty good blog posts and articles about ASP.NET Web API out there. Instead of writing one, I would like to point you those resources.

Getting Started

Validation and Data Annotations

Validating your models in ASP.NET Web API

Dependency Injection & Unit Testing

Using the Web API Dependency Resolver

Message Handlers, Filters & Formatters

HttpClient

Self Hosting

Uncategorized

Samples

Also, there are some great videos done by @jongalloway on ASP.NET web site as well as some other videos:

ASP.NET Web API Video Series

Some Other Great Talks, Webcasts and Other Type of Visuals

If you have any other related blog post, tutorial, sample or whatever related to ASP.NET Web API, please comment and I will add them to this list. I will also add new things to this list that I come across. Enjoy:)

ASP.NET Web API and ELMAH Integration

Thu, 23 Feb 2012 11:53:00 Z

As you all probably heard, ASP.NET MVC 4 Beta is now available and has new features in it. One of them is that ASP.NET MVC has shipped with ASP.NET Web API (which was previously know as WCF Web API). Here is the quote from ASP.NET web site which explains what Web API Framework is all about shortly:

ASP.NET Web API is a framework that makes it easy to build HTTP services that reach a broad range of clients, including browsers and mobile devices. ASP.NET Web API is an ideal platform for building RESTful applications on the .NET Framework.

I am not going to give an into on ASP.NET Web API. There are great into tutorials and videos on ASP.NET web site for ASP.NET Web API. Instead, I will give you an example of a custom filter implementation.

A couple of months ago, I wrote a blog post about WCF Web API HttpErrorHandlers: WCF Web API Plays Nice With ELMAH - A Quick Introduction to WCF Web API HttpErrorHandler. It works nicely on WCF Web API but this version of the framework, things a little bit changed. Instead of ErrorHandlers, we now have Filters which is more generic.

In order to make ELMAH work with ASP.NET Web API, we need to create a new Attribute which implements IExceptionFilter interface. Since we have ExceptionFilterAttribute (which implements the IExceptionFilter interface) available at the framework, we will derived from that class instead. Here is the whole implementation:

public class ElmahErrorAttribute : 
    System.Web.Http.Filters.ExceptionFilterAttribute {

    public override void OnException(
        System.Web.Http.Filters.HttpActionExecutedContext actionExecutedContext) {

        if(actionExecutedContext.Exception != null)
            Elmah.ErrorSignal.FromCurrentContext().Raise(actionExecutedContext.Exception);

        base.OnException(actionExecutedContext);
    }
}

Now we have our attribute, we need to tell the framework to use it. It is very straight forward as well. Here is how my Global.asax (Global.asax.cs) looks like:

public class WebApiApplication : System.Web.HttpApplication {

    protected void Application_Start() {

        Configure(
            System.Web.Http.GlobalConfiguration.Configuration
        );
    }

    private void Configure(HttpConfiguration httpConfiguration) {

        httpConfiguration.Filters.Add(
            new ElmahErrorAttribute()
        );

        httpConfiguration.Routes.MapHttpRoute(
            name: "DefaultApi",
            routeTemplate: "api/{controller}/{id}",
            defaults: new { id = RouteParameter.Optional }
        );
    }
}

This will make Elmah log the errors. Now, you can configure ELMAH to send you an e-mail when an error occurred or you can log the error inside an XML file, SQL Server Database, wherever you what.

One more thing to mention about is that when you hit an error, the response will carry the exception details at the body of the response if you run your application locally. You can configure this option as well with the following configuration:

httpConfiguration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Never;

My Story of Seeing a Company Which Has High Level Cheapness At Their Core

Sat, 18 Feb 2012 09:35:04 Z

Yesterday, I went to fast food restaurant to have lunch after a wonderful movie (in Aydin, Turkey). As you expected, I was starving and try to figure out how to have it my way there. At the end I decided to have a burger menu.

Just after I ordered, I nicely asked one more tiny mayonnaise and ketchup and the response that I got was unreasonably shocking and stupid. In a programmers brain, it was a HTTP 509 Bandwidth Limit Exceeded. The reason why this is stupid is not that they asked me extra money for that, because I have been going their restaurants pretty often and they responded nicely and tried to make my dreams come true if I request the same thing. Not to mention their stuff told me that this is the rule that they have been applying for nearly two years. That's lie and a big one.

In the middle of my day, this really hit me and I thought that this was the lowest level a company can go down. This shows how poor and cheap their service is and that they have no idea on how to train their stuff so that they behave the same way. I am not judging them to ask extra money for these little boxes of souce, this is their cheapness in my opinion unless a person abuses this. I mean it is reasonable to reject the request of the person if s/he asked for 100 boxes of mayonnaise and ketchup but for one more, this is the high level of cheapness my dear friend.

The funny part is that they told me I could have one special souce since I ordered Chicken Tenders along with the burgers. That sentence really made my day. I told them to keep it as my donation to their poor company so that the company can grow more and get rid of this cheapness.

I am writing this as a customer complaint and you, that restaurant, should take this into considiration.

Windows Azure, SSL, Self-Signed Certificate and Annoying HTTPS Input Endpoint Does Not Contain Private Key Error

Fri, 03 Feb 2012 22:23:08 Z

While I was trying out the Windows Azure features yesterday, I had a deployment problem. The case was to deploying SSL enabled web role. Let’s walk through the steps I have taken.

Since it was a try out, I decided to create a self-signed certificate instead of buying one. The case of how I created the self-signed certificate was fairly simple. I opened up the Visual Studio Command Prompt (2010) and cd to directory path where I would like to put the certificate file I was about to create. Then, I used the following makecert command line utility to create the certificate. Here is the code I used:

makecert -sky exchange -r -n "CN=TugberkUgurlu.Com" -pe -a sha1 -len 2048 -ss My "Azure.TugberkUgurlu.Com.cer"

I had my .cer file under c:\Azure\Certs directory. Also, I executed the following script on PowerShell console and I saw the certificate listed there.

dir cert:\CurrentUser\My

In order to upload the certificate to windows azure, I needed to export the certificate from .cer file to .pfx. Here where things get messy. I used the followig powershell script to create one but I was about to realize that it was the wrong decision. We'll see why in a minute.

$c = New-Object System.Security.Cryptography.X509Certificates.X509Certificate2("c:\azure\certs\Azure.TugberkUgurlu.Com.cer")
$bytes = $c.Export("Pfx","password")
[System.IO.File]::WriteAllBytes("c:\azure\certs\Azure.TugberkUgurlu.Com.pfx", $bytes)

The next step was to deploy this .pfx file to Certificates store of my windows azure hosted service. In order to complate this challange, I went to Windows Azure portal, navigated to my hosted service. Right click on the blue Certificate folder (I think it is a folder icon but not sure exactly what it is) and click Add Certificate:

It poped up a dialog box for me to upload that certificate file. I completed the steps and there it was. I had the certificate deployed on my hosted service.

Finally, I was done setting things up and I can jump right to my application. Wait, I wasn't done yet complately! I had to set things up at the application level so that I could hook it up to that certificate I had just uploded.

At that stage, first thing I did was to grab the thumbprint of the certificate. I ran the following PowerShell command to grab the thumbprint of the certificate:

(New-Object System.Security.Cryptography.X509Certificates.X509Certificate2("c:\azure\certs\Azure.TugberkUgurlu.Com.cer")).Thumbprint

With that thumbprint, I went to my project and added the following code inside ServiceConfiguration.Clound.cscfg and ServiceConfiguration.Local.cscfg under Role node:

<Certificates>
  <Certificate name="Azure.TugberkUgurlu.Com" thumbprint="AAD5DDD0CA9B4D3CFEF1652130142020770B8BDF" thumbprintAlgorithm="sha1"/>
</Certificates>

The ServiceDefinition.csdef file needed a little more touch than the configuration files. Here is the complate csdef file after the set-up:

<ServiceDefinition name="HttpsEnabledCloudProject" xmlns="http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition">
  <WebRole name="MvcWebRole1" vmsize="Small">
    <Sites>
      <Site name="Web">
        <Bindings>
          <Binding name="Endpoint1" endpointName="Endpoint1" hostHeader="azure.tugberkugurlu.com" />
          <Binding name="HttpsIn" endpointName="HttpsIn" hostHeader="azure.tugberkugurlu.com" />
        </Bindings>
      </Site>
    </Sites>
    <Endpoints>
      <InputEndpoint name="Endpoint1" protocol="http" port="80" />
      <InputEndpoint name="HttpsIn" protocol="https" port="443" certificate="Azure.TugberkUgurlu.Com" />
    </Endpoints>
    <Imports>
      <Import moduleName="Diagnostics" />
    </Imports>
    <Certificates>
      <Certificate name="Azure.TugberkUgurlu.Com" storeLocation="LocalMachine" storeName="My" />
    </Certificates>
  </WebRole>
</ServiceDefinition>

Everything looked right at that point but got an ugly error message telling me that my deployment had been failed:

HTTP Status Code: 400. Error Message: Certificate with thumbprint AAD5DDD0CA9B4D3CFEF1652130142020770B8BDF associated with HTTPS input endpoint HttpsIn does not contain private key

After a couple of searched on the internet, I ended up checking the private key of my certificate and here is the result:

That looked awkward and might be the problem. Then I grabed the certificate from the certificate store and check the private key. That was the evidence that it was the problem:

At that point, I created the .pfx file from the certificate in my certificate store with following code:

$cert = (get-item cert:\CurrentUser\My\AAD5DDD0CA9B4D3CFEF1652130142020770B8BDF)
$bytes = $cert.Export("Pfx","password")
[System.IO.File]::WriteAllBytes("c:\azure\certs\Azure.TugberkUgurlu.Com_2.pfx", $bytes)

At last, I deleted the certificate which was under my hosted service and reuploaded the new one I had just created.

Lastly, I ran the publish process again without changing anything inside my code, configuration or service definition files and I suceedded!

Here is the SSL enabled application running in the cloud:

Please comment if you have the same problem as me so that I won't feel lonely in this small World:)

How to Use Windows Azure Blob Storage Service With ASP.NET MVC Web Application

Wed, 18 Jan 2012 07:17:00 Z

I have been digging into Windows Azure more and more lately. I wish that it would be supported in Turkey but anyway, emulator is my cloud for now Yesterday, I thought I should note some of things down and told myself "There is no better place than your blog for that, my friend" and here I am.

One feature of Windows Azure platform which I will be using is Blob Storage. Blob storage enables you to store your unstructured data (like pictures, word docs, excel file, etc.) inside Windows Azure servers and access them over HTTP or HTTPS. With Windows Azure .Net SDK, you have full control over your blobs and program against that easily. How? Let’s see.

Before starting, make sure that you have installed Windows Azure SDK for .Net which will bring down Windows Azure Tools for Microsoft Visual Studio and Windows Azure Client Libraries for .Net. You can find the information on how to install the SDK from http://www.windowsazure.com/en-us/develop/net/

First thing is first. We need an ASP.NET MVC project to simulate this (but it doesn’t have to be ASP.NET MVC project). We have two options to make our application azure-cloudy:

Directly Create a Cloud Application

Inside the new project dialog box on Visual Studio, choose Windows Azure Project as indicated below:

When you hit OK, you will see a dialog as below:

This dialog box is like a open buffet, you can choose which project you need for your application here. But we will choose ASP.NET MVC 3 Web Role and then hit OK:

Then we will see a dialog box which is owned by ASP.NET MVC. From now on everything is same like it is a standard ASP.NET MVC project.

Make Your Application Azure-Cloudy Later

Assuming that we have an existing ASP.NET MVC application and we want to run this application on Windows Azure. What we need to do is to right click on our project and choose "Add Windows Azure Deployment Project Option" as below:

Either way, our solution will look something like this:

Configure to Work With Blob Storage

We have a few steps to make before we can start developing. In a real world scenario, you need a Windows Azure storage account to use the blob storage service and you can create this account from Windows Azure Management Portal. After you configure your account, you will have your access keys to that storage account which you will need on your development process.

One thing to mention before going further is that you will be able to access your files through HTTP or HTTPS as motioned before and the URL for your blobs will look like this:

http://<storage account>.blob.core.windows.net/<container>/<blob>

There is a way to change this so that you can use your own domain. In our example, we will be reaching out our blobs through localhost. we will get to that later in this post.

In order to develop locally with emulator, we do not need a storage account which means that we don’t need access keys. In order to configure it so, right click on the web role file and choose Properties.

This action will brings up the properties windows. From there, go to Settings tab and click add settings and on the new created node, select Connection String as Type and click "..." which stands right hand side.

This action will also open up a new window for you and this is where you configure your storage account. But we will choose "Use the Windows Azure storage emulator" option and give this configuration a new friendly name:

Those actions are not required but viewed as a best practice while working windows azure cloud projects. Also, you can use Windows Azure Storage and run your application inside your own servers. It is totally fine. So, in that case you won’t need a cloud project. What .Net SDK provides is a wrapper around Windows Azure REST APIs which makes it easy to program against.

Now we are all set and finally we can write some code.

First of all, we need two additional libraries to develop against Windows Azure with .Net:

Microsoft.WindowsAzure.StorageClient.dll
Microsoft.WindowsAzure.ServiceRuntime.dll

Those two will give us everything we need. For the sake of simplicity, I created a simple project which uploads images through Windows Azure Storage service and list those images on a page. In order to do that so, I created a service class (which is a standard class, nothing further than that) called MyBlobStorageService. Let’s see the code first:

public class MyBlobStorageService {

    public CloudBlobContainer GetCloudBlobContainer() {

        // Retrieve storage account from connection-string
        CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
                RoleEnvironment.GetConfigurationSettingValue("StorageConnectionString")
            );

        // Create the blob client 
        CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();

        // Retrieve a reference to a container 
        CloudBlobContainer blobContainer = blobClient.GetContainerReference("albums");

        // Create the container if it doesn't already exist
        if (blobContainer.CreateIfNotExist()) {

            blobContainer.SetPermissions(
               new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }
            );
        }

        return blobContainer;
    }

}

What this code does it fairly simple. It gets the storage account information form the connection string that we have configured and creates a CloudStorageAccount class according to that. Then, We create a blob storage client (CloudBlobClient) over that storage account. Finally, we create a container (CloudBlobContainer) for our blobs and check if it exists of not. If not, then we simply create it and set the public access permission to it because we will store images inside that container and we want to display those images on our web page.

In order to demonstrate this, I have two controller actions. One is for HTTP GET and the other is for HTTP POST. Here is the complete controller code:

public class HomeController : Controller {

    public MyBlobStorageService 
        _myBlobStorageService = new MyBlobStorageService();

    public ActionResult Index() {

        // Retrieve a reference to a container 
        CloudBlobContainer blobContainer = 
            _myBlobStorageService.GetCloudBlobContainer();

        List<string> blobs = new List<string>();

        // Loop over blobs within the container and output the URI to each of them
        foreach (var blobItem in blobContainer.ListBlobs())
            blobs.Add(blobItem.Uri.ToString());

        return View(blobs);
    }

    [HttpPost]
    [ActionName("index")]
    public ActionResult Index_post(HttpPostedFileBase fileBase) {

        if (fileBase.ContentLength > 0) {

            // Retrieve a reference to a container 
            CloudBlobContainer blobContainer = 
                _myBlobStorageService.GetCloudBlobContainer();

            CloudBlob blob = 
                blobContainer.GetBlobReference(fileBase.FileName);
            
            // Create or overwrite the "myblob" blob with contents from a local file
            blob.UploadFromStream(fileBase.InputStream);

        }

        return RedirectToAction("index");
    }   
}

And the view code is simple as well:

@model List<string>           
@{
    ViewBag.Title = "My Cloudy Album";
}

<h2>My Cloudy Album</h2>

@foreach (var item in Model) {
    <img src="@item" width="200" height="100" />
}

@using (Html.BeginForm("index", "home",  
    FormMethod.Post, new { enctype = "multipart/form-data" })) {
    
    <input type="file" name="fileBase" />
    <p>
        <input type="submit" value="Upload" />
    </p>    
}

Now we are all set and go to go.

But (a big but), you need to run Visual Studio with admin rights in order to run the emulator. Otherwise, you won’t be able to.

When we hit CTRL + F5, VS will create a cloud deployment package and deploy it to emulator and we will see the emulator starting up:

Now we are cloudy!

When we choose a picture and upload it, we should be able to see it after we got back.

One more thing to prove that we really run inside the emulator is to right click the emulator icon, choose Show Storage Emulator UI:

This will bring up the Storage Emulator as below:

On the right hand side, there is a reset button. Click it to reset the emulator and go back to your page and refresh. You will see that all the pictures that you have uploaded are gone now.

That’s all for now

Additional Resources

Entity Framework DbContext Generic Repository Implementation Is Now On Nuget and GitHub

Sun, 15 Jan 2012 08:41:00 Z

Couple of weeks ago, I have done two blog post on Generic Repository Pattern - Entity Framework, ASP.NET MVC and Unit Testing Triangle and How to Work With Generic Repositories on ASP.NET MVC and Unit Testing Them By Mocking and I have put up the https://github.com/tugberkugurlu/GenericRepoWebApp up on GitHub as well.

Now, the Generic Repository implementation has its own project separately: https://github.com/tugberkugurlu/GenericRepository. This is a simple project and has not much inside it but it is nice to have something static so that it can be improved along the way.

Here is a brief intro:

This little project contains a Generic Repository infrastructure for .NET applications and also a DbContext Implementation of that.

You can find more information about the main idea of this pattern and the usage on ASP.NET MVC along with Unit Testing by visiting the below links:

Generic Repository Pattern - Entity Framework, ASP.NET MVC and Unit Testing Triangle How to Work With Generic Repositories on ASP.NET MVC and Unit Testing Them By Mocking

How to Install

You can directly install this little project from Nuget. There are two packages:

GenericRepository

Generic Repository Infrastructure For .NET Applications

GenericRepository.EF

Generic Repository DbContext Implementation

Releases

Under the master branch, you can find the latest stable release of this project.

Also, you can see the most up-to-date project under develop branch. Repository under develop branch is possibly the unstable version of the project.

You can also find all the releases under Tags section.

I await for your PRs :)

ASP.NET MVC Code Review #2 - A Way of Working with Html Select Element (AKA DropDownList) In ASP.NET MVC

Fri, 30 Dec 2011 14:28:00 Z

This is the #2 of the series of blog posts which is about some core scenarios on ASP.NET MVC. In this one, code review #2, I will try to show you the best way of working with Html Select element (AKA DropDownList) in ASP.NET MVC. Here is the code:

Repository Class which generates the dummy data for the demo:

public class ProductCategory {

    public int CategoryId { get; set; }
    public string CategoryName { get; set; }
}

public class ProductCategoryRepo {

    public List<ProductCategory> GetAll() {

        List<ProductCategory> categories = new List<ProductCategory>();

        for (int i = 1; i <= 10; i++) {

            categories.Add(new ProductCategory { 
                CategoryId = i,
                CategoryName = string.Format("Category {0}", i)
            });
        }

        return categories;
    }
}

Controller:

public class SampleController : Controller {

    private readonly ProductCategoryRepo productCategoryRepo = 
         new ProductCategoryRepo();

    public ActionResult Index() {

        registerProductCategorySelectListViewBag();
        return View();
    }

    private void registerProductCategorySelectListViewBag() {

        ViewBag.ProductCategorySelectList = 
            productCategoryRepo.GetAll().Select(
                c => new SelectListItem { 
                    Text = c.CategoryName,
                    Value = c.CategoryId.ToString()
                }
            );
    }
}

View:

@{
    ViewBag.Title = "HTML Select List Sample";
}

<h2>HTML Select List Sample</h2>

<p>
    <strong>Product Categories:</strong>
</p>
<p>
    @Html.DropDownList(
        "ProductCategoryId", 
        (IEnumerable<SelectListItem>)ViewBag.ProductCategorySelectList
    )
</p>

Let’s see what it generates for us:

Output HTML of Select element:

<select id="ProductCategoryId" name="ProductCategoryId">
    <option value="1">Category 1</option>
    <option value="2">Category 2</option>
    <option value="3">Category 3</option>
    <option value="4">Category 4</option>
    <option value="5">Category 5</option>
    <option value="6">Category 6</option>
    <option value="7">Category 7</option>
    <option value="8">Category 8</option>
    <option value="9">Category 9</option>
    <option value="10">Category 10</option>
</select>

Just like what I expected. On the controller, you see that I newed up SelectListItem classes and pass them to the view through the ViewDataDictionary. SelectListItem class works nicely with DropDownList and DropDownListFor Html helpers within ASP.NET MVC as you see inside the view code above.

So, don’t try to reinvent the wheel and don’t get into for and foreach loops in order just to create a select element. SelectListItem has been put inside the library just for this purpose and leverage it.

ASP.NET MVC Code Review #1 - File Upload With HttpPostedFileBase Class

Thu, 29 Dec 2011 21:25:00 Z

Today, I decided to change my blogging style a little bit. I always try to write posts which contains detailed information about the subject but I realized that it prevents me from writing much more useful things. So, from now on, I will drop a bunch of code on the screen and talk about that briefly.

This is the beginning of the series of blog posts which is about some core scenarios on ASP.NET MVC. In this one, code review #1, I will give you an example on how to get file upload functionality working in ASP.NET MVC. Here is the code:

Controller:

public class SampleController : Controller {

    public ActionResult Index() {
        return View();
    }

    [ActionName("Index")]
    [ValidateAntiForgeryToken, HttpPost]
    public ActionResult Index_post(HttpPostedFileBase File) {

        //Check if the file is not null and content length is bigger than 0
        if (File != null && File.ContentLength > 0) {

            //Check if folder is there
            if(!System.IO.Directory.Exists(Server.MapPath("~/Content/PostedFiles")))
                System.IO.Directory.CreateDirectory(
                    Server.MapPath("~/Content/PostedFiles")
                );

            //Set the full path
            string path = System.IO.Path.Combine(
                Server.MapPath("~/Content/PostedFiles"),
                System.IO.Path.GetFileName(File.FileName)
            );

            //Save the thing
            File.SaveAs(path);

            TempData["Result"] = "File created successfully!";
        }

        //RedirectToAction so that we can get rid of so-called "Form Resubmission"
        return RedirectToAction("Index");
    }

}

View:

@{
    ViewBag.Title = "File Upload Sample";
}
<h2>File Upload Sample</h2>

@if (TempData["Result"] != null) { 
    <ul>
        <li>@TempData["Result"]</li>
    </ul>
}

@using (Html.BeginForm("index", "sample", 
    FormMethod.Post, new { enctype = "multipart/form-data" })) {
 
    @Html.AntiForgeryToken()
    
    <input type="file" name="File" />
    <p>
        <input type="submit" value="Upload" />
    </p>
}

Actually, code explains itself nicely here but I see one thing to worth pointing out here. HttpPostedFileBaseModelBinder class from System.Web.Mvc namespace is the class which binds a model to a posted file. So, the parameter (which is type of HttpPostedFileBase) of the Index_post method receives the posted file.

Pretty neat stuff. Hope you enjoy it.

How to Work With Generic Repositories on ASP.NET MVC and Unit Testing Them By Mocking

Thu, 22 Dec 2011 17:05:00 Z

I have blogged about Generic Repository Pattern - Entity Framework, ASP.NET MVC and Unit Testing Triangle but that blog post only contains how we can implement that pattern on our DAL (Data Access Layer) project. Now, let’s see how it fits into our ASP.NET MVC application.

I created a sample project which basically has CRUD operations for Foo class and I put the complete code of the project on GitHub. https://github.com/tugberkugurlu/GenericRepoWebApp

So, in the previous blog post we have created our DAL project and repository classes based on our generic repository. I have created an ASP.NET MVC 3 Web Application project and a Visual Studio Test Project besides the DAL project. On the left had side, you can see how the project structure looks like inside solution explorer.

When we think about the project, we have repository classes which implements GenericRepositroy<C, T> abstract class and individual repository interfaces. So, we need a way to inject our concrete repository classes into our ASP.NET MVC application so that we make our application loosely coupled which means unit testing friendly.

Fortunately, ASP.NET MVC has been built with unit testing in mind so it makes dependency injection very easy with DependencyResolver class. DependencyResolver class Provides a registration point for dependency resolvers that implement IDependencyResolver or the Common Service Locator IServiceLocator interface. But we won’t be dealing with that class at all. Instead, we will use a third party dependency injector called Ninject. Ninject also has a package which benefits from DependencyResolver of ASP.NET MVC. We will use Nuget to bring down Ninject.

After we install the package, we will see a folder named App_Start added to our project. Inside that folder, open up the NinjectMVC3.cs file and go to RegisterServices method. In our case, here what we do:

/// <summary>
/// Load your modules or register your services here!
/// </summary>
/// <param name="kernel">The kernel.</param>
private static void RegisterServices(IKernel kernel) {

    kernel.Bind<IFooRepository>().To<FooRepository>();
    kernel.Bind<IBarRepository>().To<BarReposiltory>();
}

This does some stuff behind the scenes and I won’t go into details here but I really recommend you to go and take a look at series of blog posts which Brad Wilson has done on ASP.NET MVC 3 Service Location. However, if we try to explain it with simplest words, Ninject news up the controller classes with parameters which we specify. In this case, if a controller constructor accepts a parameter which is type of IFooRepository, Ninject will give it FooRepository class and news it up. We will see why this is useful on unit testing stage.

When we look inside the RegisterServices method, we don’t see neither GenericRepository nor IGenericRepository because the way we implement them enables them to work behind the scenes.

As for the implementation, here how the controller looks like:

public class FooController : Controller {

    private readonly IFooRepository _fooRepo;
    
    public FooController(IFooRepository fooRepo) {
        _fooRepo = fooRepo;
    }

    public ViewResult Index() {

        var model = _fooRepo.GetAll();
        return View(model);
    }

    public ActionResult Details(int id) {

        var model = _fooRepo.GetSingle(id);
        if (model == null)
            return HttpNotFound();

        return View(model);
    }

    public ActionResult Edit(int id) {

        var model = _fooRepo.GetSingle(id);
        if (model == null)
            return HttpNotFound();

        return View(model);
    }

    [ActionName("Edit"), HttpPost]
    public ActionResult Edit_post(Foo foo) {

        if (ModelState.IsValid) {

            try {
                _fooRepo.Edit(foo);
                _fooRepo.Save();

                return RedirectToAction("details", new { id = foo.FooId });

            } catch (Exception ex) {
                ModelState.AddModelError(string.Empty, "Something went wrong. Message: " + ex.Message);
            }
        }

        //If we come here, something went wrong. Return it back.
        return View(foo);
    }

    public ActionResult Create() {

        return View();
    }

    [ActionName("Create"), HttpPost]
    public ActionResult Create_post(Foo foo) {

        if (ModelState.IsValid) {

            try {
                _fooRepo.Add(foo);
                _fooRepo.Save();

                return RedirectToAction("details", new { id = foo.FooId });

            } catch (Exception ex) {
                ModelState.AddModelError(string.Empty, "Something went wrong. Message: " + ex.Message);
            }
        }

        //If we come here, something went wrong. Return it back.
        return View(foo);

    }

    public ActionResult Delete(int id) {

        var model = _fooRepo.GetSingle(id);
        if (model == null)
            return HttpNotFound();

        return View(model);
    }

    [ActionName("Delete"), HttpPost]
    public ActionResult Delete_post(int id) {

        var model = _fooRepo.GetSingle(id);
        if (model == null)
            return HttpNotFound();

        _fooRepo.Delete(model);
        _fooRepo.Save();

        return RedirectToAction("Index");
    }
}

All of the action methods do some very basic stuff but one thing to notice here is the below code:

    private readonly IFooRepository _fooRepo;
    
    public FooController(IFooRepository fooRepo) {
        _fooRepo = fooRepo;
    }

As I mentioned before, controller constructor accepts a parameter which is type of IFooRepository and inside the constructor method, we expose the parameter for internal use of that controller class.

I have some views which corresponds to each action method and they work as expected.

Unit Testing

So, how do we unit test that controller without connecting to our database? When we think theoretically, what we need is a fake repository which implements IFooRepository interface so that we can pass that fake repository into our controller as a constructor parameter. Pay attention here that we still has no need for neither generic repository interface nor generic repository abstract class. We just need to fake FooRepository interface with fake data.

We will do this by mocking and creating mock objects. In order to do that, we will benefit from an awesome library called Moq.

As you can see inside the project on GitHub, I didn’t use NuGet to bring down the Moq because I tried and it failed over and over again. So, I put that inside the lib folder under the root directory and reference it from there.

After you reference the Moq library inside the Test application, create a class named FooControllerTest.cs. Here how it should look like at first:

[TestClass]
public class FooControllerTest {

}

So empty. We will start to fill it in with a mock of IFooReporsitory. Below, you can see the complete code which enables that:

[TestClass]
public class FooControllerTest {

    private IFooRepository fooRepo;

    [TestInitialize]
    public void Initialize() {

        //Mock repository creation
        Mock<IFooRepository> mock = new Mock<IFooRepository>();
        mock.Setup(m => m.GetAll()).Returns(new[] { 
            new Foo { FooId = 1, FooName = "Fake Foo 1" },
            new Foo { FooId = 2, FooName = "Fake Foo 2" },
            new Foo { FooId = 3, FooName = "Fake Foo 3" },
            new Foo { FooId = 4, FooName = "Fake Foo 4" }
        }.AsQueryable());

        mock.Setup(m => 
            m.GetSingle(
                It.Is<int>(i => 
                    i == 1 || i == 2 || i == 3 || i == 4
                )
            )
        ).Returns<int>(r => new Foo { 
            FooId = r,
            FooName = string.Format("Fake Foo {0}", r)
        });

        fooRepo = mock.Object;
    }

}

This Initialize method will run before all of the test methods run so we can work inside that method in order to mock our object.

In here, first I have setup a mock for GetAll method result and it returns 4 instances or Foo class.

Second, I do the same thing for GetSingle method. It looks a little different because it accepts a parameter type of int. What I am telling there is that: there are 4 instances I have here and if the parameter matches one of those instances, it will returns a Foo class which is a type of GetSingle method returns.

Lastly, I expose the mock object for internal use for the test class.

Now we have an IFooRepository instance we can work with. We have completed the hard part and now we can start writing our unit tests. Here is some of possible unit tests that we can have:

[TestClass]
public class FooControllerTest {

    private IFooRepository fooRepo;

    [TestInitialize]
    public void Initialize() {

        //Mock repository creation
        Mock<IFooRepository> mock = new Mock<IFooRepository>();
        mock.Setup(m => m.GetAll()).Returns(new[] { 
            new Foo { FooId = 1, FooName = "Fake Foo 1" },
            new Foo { FooId = 2, FooName = "Fake Foo 2" },
            new Foo { FooId = 3, FooName = "Fake Foo 3" },
            new Foo { FooId = 4, FooName = "Fake Foo 4" }
        }.AsQueryable());

        mock.Setup(m => 
            m.GetSingle(
                It.Is<int>(i => 
                    i == 1 || i == 2 || i == 3 || i == 4
                )
            )
        ).Returns<int>(r => new Foo { 
            FooId = r,
            FooName = string.Format("Fake Foo {0}", r)
        });

        fooRepo = mock.Object;
    }

    [TestMethod]
    public void is_index_returns_model_type_of_iqueryable_foo() {
        
        //Arrange
        //Create the controller instance
        FooController fooController = new FooController(fooRepo);

        //Act
        var indexModel = fooController.Index().Model;

        //Assert
        Assert.IsInstanceOfType(indexModel, typeof(IQueryable<Foo>));
    }

    [TestMethod]
    public void is_index_returns_iqueryable_foo_count_of_4() {

        //Arrange
        //Create the controller instance
        FooController fooController = new FooController(fooRepo);

        //Act
        var indexModel = (IQueryable<object>)fooController.Index().Model;

        //Assert
        Assert.AreEqual<int>(4, indexModel.Count());
    }

    [TestMethod]
    public void is_details_returns_type_of_ViewResult() {

        //Arrange
        //Create the controller instance
        FooController fooController = new FooController(fooRepo);

        //Act
        var detailsResult = fooController.Details(1);

        //Assert
        Assert.IsInstanceOfType(detailsResult, typeof(ViewResult));
    }

    [TestMethod]
    public void is_details_returns_type_of_HttpNotFoundResult() { 

        //Arrange
        //Create the controller instance
        FooController fooController = new FooController(fooRepo);

        //Act
        var detailsResult = fooController.Details(5);

        //Assert
        Assert.IsInstanceOfType(detailsResult, typeof(HttpNotFoundResult));
    }
}

When I run the all the test, I should see all of them pass and I do:

I hope this blog post gives you an idea. Stay tuned for others

NOTE:

Entity Framework DbContext Generic Repository Implementation Is Now On Nuget and GitHub: http://www.tugberkugurlu.com/archive/entity-framework-dbcontext-generic-repository-implementation-is-now-on-nuget-and-github

Generic Repository Pattern - Entity Framework, ASP.NET MVC and Unit Testing Triangle

Thu, 22 Dec 2011 09:07:00 Z

DRY: Don’t repeat yourself which is a principle of software development aimed at reducing repetition of information of all kinds, especially useful in multi-tier architectures. That’s what Wikipedia says. In my words, if you are writing same code twice, follow these steps:

Step back.
Sit.
Think about it and dwell on that.

That’s what I have done for repository classes on my DAL projects. I nearly all the time use Entity Framework to reach out my database and I create repositories in order to query and manipulate data inside that database. There are some specific methods which I use for every single repository. As you can assume, those are FindBy, Add, Edit, Delete, Save. Let’s see on code what is my story here.

First approach (worst approach)

At first, long time ago, I have been creating all the single methods for each interface. For example below one is one of my repository interfaces:

I am giving examples here with EF 4.2 but I was following this approach with EF 4 which does not contain DbContext class.

public interface IFooRepository {
        
    IQueryable<Foo> GetAll();
    Foo GetSingle(int fooId);
    IQueryable<Foo> FindBy(Expression<Func<Foo, bool>> predicate);
    void Add(Foo entity);
    void Delete(Foo entity);
    void Edit(Foo entity);
    void Save();
}

This repo is for Foo class I have (imaginary). Let's see the implementation for Bar class.

public interface IBarRepository {
    
    IQueryable<Bar> GetAll();
    Bar GetSingle(int barId);
    IQueryable<Bar> FindBy(Expression<Func<Bar, bool>> predicate);
    void Add(Bar entity);
    void Delete(Bar entity);
    void Edit(Bar entity);
    void Save();
}

Implementation nearly exactly the same here. Here is also an example of implementing one of these interfaces:

public class FooRepository : IFooRepository {

    private readonly FooBarEntities context = new FooBarEntities();

    public IQueryable<Foo> GetAll() {

        IQueryable<Foo> query = context.Foos;
        return query;
    }

    public Foo GetSingle(int fooId) {

        var query = this.GetAll().FirstOrDefault(x => x.FooId == fooId);
        return query;
    }

    public void Add(Foo entity) {

        context.Foos.Add(entity);
    }

    public void Delete(Foo entity) {

        context.Foos.Remove(entity);
    }

    public void Edit(Foo entity) {

        context.Entry<Foo>(entity).State = System.Data.EntityState.Modified;
    }

    public void Save() {

        context.SaveChanges();
    }
}

Also imagine this implementation for BarRepository as well. Indeed, there would be probably more repository classes for your project. After playing like that for a while I decided to do something different which still sucked but better.

A better approach but still sucks

I created a generic interface which saves me a lot of keystrokes. Here how it looks like:

public interface IGenericRepository<T> where T : class {
    
    IQueryable<T> GetAll();
    IQueryable<T> FindBy(Expression<Func<T, bool>> predicate);
    void Add(T entity);
    void Delete(T entity);
    void Edit(T entity);
    void Save();
}

And how I implemented in on repository interfaces:

public interface IFooRepository : IGenericRepository<Foo> {
    
    Foo GetSingle(int fooId);
}

public interface IBarRepository : IGenericRepository<Bar> {
    
    Bar GetSingle(int barId);
}

You can see that I only needed to implement GetSingle method here and others come with IGenericRepositoy<T> interface.

Where I implement these repository interfaces to my concrete classes, I still need to go over all the methods and create them individually. The repository class looked like as the same. So it leads me to a final solution which is the best one I can come up with so far.

Best approach

The generic interface I have created is still legitimate and usable here. In fact, I won’t touch the repository interfaces at all. What I did here first is to create an abstract class which implements IGenericReposity<T> interface but also accepts another type parameter defined in a generic declaration which is a type of DbConetxt class. Here is how it looks like:

public abstract class GenericRepository<C, T> : 
    IGenericRepository<T> where T : class where C : DbContext, new() {

    private C _entities = new C();
    public C Context {

        get { return _entities; }
        set { _entities = value; }
    }

    public virtual IQueryable<T> GetAll() {

        IQueryable<T> query = _entities.Set<T>();
        return query;
    }

    public IQueryable<T> FindBy(System.Linq.Expressions.Expression<Func<T, bool>> predicate) {

        IQueryable<T> query = _entities.Set<T>().Where(predicate);
        return query;
    }

    public virtual void Add(T entity) {
        _entities.Set<T>().Add(entity);
    }

    public virtual void Delete(T entity) {
        _entities.Set<T>().Remove(entity);
    }

    public virtual void Edit(T entity) {
        _entities.Entry(entity).State = System.Data.EntityState.Modified;
    }

    public virtual void Save() {
        _entities.SaveChanges();
    }
}

This is so nice because of some factors I like:

This implements so basic and ordinary methods
If necessary, those methods can be overridden because each method is virtual.
As we newed up the DbContext class here and expose it public with a public property, we have flexibility of extend the individual repositories for our needs.
As we only implement this abstract class only to our repository classes, it won’t effect unit testing at all. DbContext is not in the picture in terms of unit testing.

So, when we need to implement these changes to our concrete repository classes, we will end up with following result:

public class FooRepository :
    GenericRepository<FooBarEntities, Foo>, IFooRepository {

    public Foo GetSingle(int fooId) {

        var query = GetAll().FirstOrDefault(x => x.FooId == fooId);
        return query;
    }
}

public class BarReposiltory : 
    GenericRepository<FooBarEntities, Bar>, IBarRepository  {

    public Bar GetSingle(int barId) {

        var query = Context.Bars.FirstOrDefault(x => x.BarId == barId);
        return query;
    }
}

Very nice and clean. Inside BarRepository GetSingle method, as you see I use Context property of GenericRepository<C, T> abstract class to access an instance of DbContext.

So, how the things work inside our ASP.NET MVC project? this is another story but no so complicated. I will continue right from here on my next post.

UPDATE:

Here is the next post:

How to Work With Generic Repositories on ASP.NET MVC and Unit Testing Them By Mocking

Make The Visual Studio Extensions Compatible With Visual Studio 11 Developer Preview

Wed, 07 Dec 2011 14:05:00 Z

Do you use Visual Studio 11 Developer Preview and miss your extensions? Well, I do! Especially, ADO.NET C# DbContext Generator.

As you know, for now Visual Studio extensions are not compatible with Visual Studio 11 Developer Preview.

This is normal because it is Developer Preview. Even, I opened up a thread for that on Stackoverflow: Visual Studio Extensions and Visual Studio 11 Dev. Preview and @betty replied to my post after a long time with an amazing answer. I never developed a Visual Studio extension before and I am not familiar with the drill so I thought it is not possible to tweak the extensions so that they can be compatible with Visual Studio 11 Developer Preview but it turns out that it is as easy as pie. How so? Here are the steps:

Oww, by the way, this thing works on my machine and I am not guarantee that it will work on yours as well. Even worse, it can completely screw your machine up. So, take the risk here and don’t swear to me.

I also assume that the ADO.NET C# DbContext Generator does not integrate with Visual Studio that much so there was no big compatibility problems but I won’t try this for the extensions like VSCommands 2010, Web Essentials, etc. If you try, please let me know how it went. Anyway, here is the drill:

First of all, download the extension from Visual Studio Gallery.

I am not sure if you are aware of it but vsix files are actually zip files just like NuGet package files (nupkg) and MS Word files (docx). So, change the extension of the file we have downloaded from vsix to zip:

Unzip the zip file and you will see a file called extension.vsixmanifest under root folder. No, it is not a zip file, too It is an xml file though. Open it up with a text editor and find the node called SupportedProducts:

Just change the value of version attribute of VisualStudio node to 11.0 and save it.

This is actually enough for the extension compatibility standpoint but ADO.NET C# DbContext Generator extension has some dependencies which are specific to Visual Studio 2010 (not sure on that though). So,we have one more step to go as well.

Navigate to /T/code/ folder and you will see a zip file there:

Unzip it:

Open up the file called ADONETArtifactGenerator_DbContextCSharp.vstemplate with a text editor this time and you will notice a node like below:

  <WizardExtension>
    <Assembly>Microsoft.Data.Entity.Design, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</Assembly>
    <FullClassName>Microsoft.Data.Entity.Design.VisualStudio.ModelWizard.AddArtifactGeneratorWizard</FullClassName>
  </WizardExtension>

Change this one with the below code:

  <WizardExtension>
    <Assembly>Microsoft.Data.Entity.Design, Version=11.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</Assembly>
    <FullClassName>Microsoft.Data.Entity.Design.VisualStudio.ModelWizard.AddArtifactGeneratorWizard</FullClassName>
  </WizardExtension>

Don’t ask me why because I have no clue. I assumed that it was a versioning issue and it works this way. Remember, this is developer preview. Not even alpha or beta so don’t look for logic that much.

Save the file and zip it up again.

Don’t forget to delete other files. You just need that zip file inside the code folder.

Lastly, go under the root and zip all the files:

Now we have a zip file again. Change the extension from zip to vsix and double click on that

Now we get it working smoothly:

Now when you want to continue you way with database first approach, you can follow the steps which are explained here:

http://blogs.msdn.com/b/adonet/archive/2011/11/01/ef-4-2-released.aspx

Here is the quote from that blog post:

Model First & Database First Templates

The templates for using the DbContext API with Model First and Database First are now available under the “Online Templates” tab when “Right-Click –> Add Code Generation Item…” is selected on the EF Designer.

Instead of navigating to "Online Templates" tab, you will find the code gen. file under the "Code" tab:

Admit it, we totally nailed that thing

Don't Shit All Over The Company You Just Left

Sat, 03 Dec 2011 19:29:00 Z

A few days ago, Phil Haack made an announcement which wasn’t a kind of announcement that we had heard from Mr. Haack. It wasn’t a new product release or new version of ASP.NET MVC or NuGet. It wasn’t the birthday of one of his children either. It was the announcement which tells us a very bad news. It was telling that he won’t be working on behalf of Microsoft after the 5th of December 2011.

The blog post was sad for me and at the same time it was shocking as well. But none of those are the reason why I write about it here. I have no idea what happened and drew him away from Microsoft but I can tell that the blog post he has written is exemplary.

Phil Haack respects the place he worked and he didn’t shit all over the company. This should be always the case even if you experienced the hell there.

If you work on a company for a particular period of time and realize that this company is a shitty place after that period of time, you have a serious problem in my opinion. This behavior is no different than seeing your ex-wife / ex-husband as a monster, enemy after a divorce.

Why am I writing this? I honestly don’t know. But when I saw the blog post of Joe Stanger about the Microsoft, I was really sad that a person like him can be a person like that. The announcement of his leave was a little harsh as well. The title of the first blog post I referenced is 'What’s wrong with Microsoft?'. The company name is not important here. It could be Apple, Starbucks or The Jim’s Coffee House. The point here is that: this company was perfect when the employee was working there and it suddenly turned out a shitty place just after the employee left. Maybe it was a shitty place for a while when the employee worked there and he knew that but I, as a person in public, have no idea about that. If you don’t have guts to tell the same thing publicly when you work there, keep it to yourself for your entire life. No matter what happened, that place is the company you have worked for. At some point, maybe the place you have represented for.

So, don’t be a slave of your angers. Don’t go public without thinking by using the words you will possibly regret. Also, don’t forget this is just a random dude’s opinion on the internet.

Oww, I almost forgot. I know that you are not dying but we, at least I, will miss you anyway @Haacked!

WCF Web API Plays Nice With ELMAH - A Quick Introduction to WCF Web API HttpErrorHandler

Tue, 22 Nov 2011 12:09:00 Z

How many times you face an error message like this one when you are working with WCF? Many times I guess.

On WCF Web API, this is not a big deal on the development stage because Web API runs on core ASP.NET and debugging is not a big deal (maybe it is not a big deal on WCF as well but it always for me, anybody knows a good debugging scenario on WCF, please let me know).

But when you expose your data and your customers starts to consume your service, you will pull your hairs when you see this screen.

WCF Web API has been built extensibility and testability in mind so it is real easy to plug things into the framework. One of the extensibility points is ErrorHandlers and in this quick blog post I will show you how to handle error nicely on WCF Web API.

If you haven’t seen my previous blog post on Introduction to WCF Web API - New REST Face of .NET, I encourage you to check that out. What I do here will be addition to that.

When somebody tells me the words “Error Handling” and “.NET” in the same sentence, I tell him/her ELMAH in response. ELMAH (Error Logging Modules and Handlers) is is an application-wide error logging facility that is completely pluggable. It can be dynamically added to a running ASP.NET web application, or even all ASP.NET web applications on a machine, without any need for re-compilation or re-deployment. These are the official words.

In order to integrate ELMAH with our Web API application, we need to bring down the ELMAH via NuGet as we always do for open source libraries.

Scott Hanselman has a great blog post on how ELMAH gets into your application via NuGet Package Manager. You should check that out if you are interested:

http://www.hanselman.com/blog/IntroducingNuGetPackageManagementForNETAnotherPieceOfTheWebStack.aspx

Open up you PMC and type Install-Package ELMAH:

After you install the package successfully, it doesn’t need any extra configuration to work but you would probably want to secure your error logging page. Check it out how on Phil Haack’s blog post: http://haacked.com/archive/2007/07/24/securely-implement-elmah-for-plug-and-play-error-logging.aspx

When you go to http://localhost:{port_number}/elmah.axd, you will see the error list page:

I added a new method for PeopleApi in order to be able to reach single person data:

[WebGet(UriTemplate = "{id}")]
public HttpResponseMessage<Person> GetSingle(int id) {

    var person = _repo.GetSingle(id);

    if (person == null) {
        var response = new HttpResponseMessage();
        response.StatusCode = HttpStatusCode.NotFound;
        response.Content = new StringContent("Country not found");
        throw new HttpResponseException(response);
    }

    var personResponse = new HttpResponseMessage<Models.Person>(person);
    personResponse.Content.Headers.Expires = new DateTimeOffset(DateTime.Now.AddHours(6));
    return personResponse;
}

It is a simple method. It returns a single Person data wrapped up inside HttpResponseMessage if there is one and returns 404 if there is no person with the given id value.

Let’s send a string value instead of int32 and see what happens:

It is an error so ELMAH should have logged this, right? It didn’t because WCF Web API handles exceptions on its own but good news is you can get in there and plug your own stuff into it.

Disclaimer:

I am still a newbie on WCF Web API and learning it day by day. Also, the framework is at the preview stage (not even Alpha) so the things I explain and show might be not entirely the best case scenarios.

In WCF Web API preview 5, you can use the ErrorHandler, which is the recommended way to do error handling. In order to implement your own error handler, your class needs to derived from HttpErrorHandler class. Here is the implementation I use:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web;
using Microsoft.ApplicationServer.Http.Dispatcher;

namespace VeryFirstWcfWebAPI.Handlers {

    public class GlobalErrorHandler : HttpErrorHandler {

        protected override bool OnTryProvideResponse(Exception exception, ref System.Net.Http.HttpResponseMessage message) {

            if(exception != null) // Notify ELMAH
                Elmah.ErrorSignal.FromCurrentContext().Raise(exception);

            message = new HttpResponseMessage {
                StatusCode = HttpStatusCode.InternalServerError
            };

            return true;
        }
    }
}

Pretty straight forward implementation. The last step is to register this handler. We will do that inside the Global.asax file as below:

protected void Application_Start(object sender, EventArgs e) {

    RouteTable.Routes.SetDefaultHttpConfiguration(new Microsoft.ApplicationServer.Http.WebApiConfiguration() { 
        CreateInstance = (serviceType, context, request) => GetKernel().Get(serviceType),
        ErrorHandlers = (handlers, endpoint, description) => handlers.Add(new GlobalErrorHandler())
    });

    RouteTable.Routes.MapServiceRoute<People.PeopleApi>("Api/People");
}

Now, hit your service and cause an error. After that go back to elmah.axd page to see what we got there:

We totally nailed it! Now, you can configure ELMAH to send you an e-mail when an error occurred or you can log the error inside an XML file, SQL Server Database, wherever you what.

As I said at the end of my previous post, there is so much to cover about WCF Web API. I hope I will blog about it more.

You can find the full code on GitHub: https://github.com/tugberkugurlu/VeryFirstWcfWebAPI

Introduction to WCF Web API - New REST Face of .NET

Mon, 21 Nov 2011 08:09:00 Z

24 February 2012
WCF Web API is now ASP.NET Web API and has changed a lot. The beta version is now available. For more information: Getting Started With ASP.NET Web API - Tutorials, Videos, Samples.

Microsoft Web Platform is evolving. I mean really evolving. Scott Hanselman, Phil Haack, Glenn Block and Damian Edwards are the main actors for this evolution.

One of the biggest frustration we had as web developers was to face with the endless configurations with WCF. I mean, WCF is great but hasn’t been embraced the REST since the WCF Web API framework. There was something called REST Starter Kit but it ended up dead.

Yes, WCF Web API. WCF Web API is the new way of exposing and consuming APIs over http in .NET. The unofficial (not sure, maybe the official one) slogan of WCF Web API is this:

"Making REST a first class citizen in .NET"

I stole (or quoted would be nicer) the real sentences which explain the WCF Web API from the official WCF Web API page (I hope they don’t mind):

What is WCF Web API?

Applications are continually evolving to expose their functionality over the web for example social services like Flickr, Twitter and Facebook. Aside from social applications, organizations are also looking to surface their core enterprise business functionality to an ever expanding array of client platforms. WCF Web API allows developers to expose their applications, data and services to the web directly over HTTP. This allows developers to fully harness the richness of the HTTP as an application layer protocol. Applications can communicate with a very broad set of clients whether they be browsers, mobile devices, desktop applications or other backend services. They can also take advantage of the caching and proxy infrastructure of the web through providing proper control and entity headers. We are designing specifically to support applications built with a RESTful architecture style though it does not force developers to use REST. The benefits of REST for your applications include discoverability, evolvability and scalability.

The project is still at the preview stage and we are swimming in the dark sea. There are lots of rumors going around about it and most of them are nearly certain to be true. One of them is that WCF Web API and ASP.NEt MVC will be blood brothers in near future. In plain English, they will be merged together. This will be exciting and we won’t feel ourselves in a fork in the road when we need to pick ASP.NET MVC or WCF Web API in order to expose our data over http.

Cut the crap and show me the code

Well, when I first saw the WCF Web API, I told myself that this’s it! Why I told that? Because it is extremely easy to get started and going from there. I am interested in WCF as well but its configuration is endless so I haven’t been able to develop a decent project with WCF so far (maybe the problem is me, who knows!). Be careful here though, WCF is not gone! It is still the way to go with for SOAP based services.

Let’s see how we get started developing a Web API with WCF Web API (this sentence is like a poem ).

First of all, open up your VS and create a new ASP.NET Empty Web Application (this one is real empty guys unlike ASP.NET MVC 3 Empty Web Application):

I told you it is real empty. Anyway, let’s stick to the point here Now, bring up the NuGet PMC (Package Manager Console) and install the package called WebApi.All:

Let’s look what we got:

All the packages we have pulled is individual packages. For example, if you are consuming web services on the server side, HttpClient package will help you a lot. I think all of those packages will be baked-in for .NET 4.5 so we will see a lot samples for those.

One thing that I looked when I first bring up this package is Web.Config file because I wondered how giant it was. It comes to me as a shock and it will for you, too:

3 lines of code which is special to WCF Web API. This is awesome. So, where do we configure the stuff. First of all, if you would like to get started you do not need to make any configuration. We will see how in a minute. Web API comes with default configuration and this can be overridden in any steps. You can set your default configuration. One of your APIs needs different configuration? Don’t change the default one. Configure it separately. So, it is really a convention. Best part is that it is all done with code, I mean inside Global.asax.

For the sake of this demo, I created a dummy data to play with. It is really simple as follows (I will put up the source code online, you can check out what is in there):

I implemented the repository pattern here with an interface. I did that because I would like to show you how easy is to get going along with Dependency Injection (DI) here.

In order to create our API, we need to create a separate class. I put it under People folder and named it PeopleApi but where it stands and what name it carries don’t matter here.

I would like to go with the simplest approach firstly. Here is how PeopleApi class looks like:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Web;
using VeryFirstWcfWebAPI.People.Infrastructure;
using VeryFirstWcfWebAPI.People.Models;

namespace VeryFirstWcfWebAPI.People {

    [ServiceContract]
    public class PeopleApi {

        private readonly IPeopleRepository _repo = new PeopleRepository();

        [WebGet]
        public HttpResponseMessage<IQueryable<Person>> Get() {

            var model = _repo.GetAll();

            var responseMessage = new HttpResponseMessage<IQueryable<Person>>(model);
            responseMessage.Content.Headers.Expires = new DateTimeOffset(DateTime.Now.AddHours(6));

            return responseMessage;
        }

    }
}

When we observe this class a little bit carefully, we see some staff going on there:

You API class needs to be annotated with ServiceContractAttribute. This is must to do (@gblock said at the //Build conference that we are still in love with attributes but we are trying to get rid of them...).
The methods inside your class needs to have some special attributes like WebGetAttribute and WebInvokeAttribute. If you put them without UriTemplate property, it assumes that the method is for root of the URL.

Also, another thing to notice here is we are returning our model by wrapping it up with HttpResponseMessage class. You don’t have to do that. You can just return your object but if you need to add some special headers or response message code, it is nice way to do it that way as we set here our expires header.

As I mentioned before, there is no configuration at all in the web.config but we still need to do some configuration to tell the system to figure out what to do.

Add a Global Application Class under the root of your project:

Inside the Application_Start method, here is our initial set up to get going:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Routing;
using System.Web.Security;
using System.Web.SessionState;

namespace VeryFirstWcfWebAPI {

    public class Global : System.Web.HttpApplication {

        protected void Application_Start(object sender, EventArgs e) {

            RouteTable.Routes.SetDefaultHttpConfiguration(new Microsoft.ApplicationServer.Http.WebApiConfiguration() { 
            });

            RouteTable.Routes.MapServiceRoute<People.PeopleApi>("Api/People");
        }

    }
}

What we do here is so simple:

We are initializing the WCF Web API with default configuration.
We specifically register our API with a base URL structure as route prefix.

As we have folder called People under the root of out application, if you put People as route prefix there, you will see that your API won’t work and you will get 404. I am nearly sure that it is related to routing.

I haven’t figured out how to solve this issue and I tried to Ignore that folder but it didn’t work either.

We are ready to run:

This is good for a start. We didn’t suffer much. Now, it is time for us to think of the possible enhancements.

Dependency Injection and IoC Container Support

As you probably noticed, I "newed" up the repository inside our API class:

private readonly IPeopleRepository _repo = new PeopleRepository();

This thing made my application tightly-coupled and it is not good. Here I have a static data resource and it is not much of a problem but if we had database related data structure here, this would make it hard for us to unit test our application.

In order to get around for this, we need to figure out a way to new up the resource outside of our context and WCF Web API offers really good extensibility point here. I won’t really extend and customize our configuration much here in order to stick with the basics but I will probably blog about that either.

First of all, let’s make our API class a little DI friendly:

    [ServiceContract]
    public class PeopleApi {

        private readonly IPeopleRepository _repo;

        public PeopleApi(IPeopleRepository repo) {
            _repo = repo;
        }

        [WebGet]
        public HttpResponseMessage<IQueryable<Person>> Get() {

            var model = _repo.GetAll();

            var responseMessage = new HttpResponseMessage<IQueryable<Person>>(model);
            responseMessage.Content.Headers.Expires = new DateTimeOffset(DateTime.Now.AddHours(6));

            return responseMessage;
        }

    }

What we do here enables someone else to provide the resource so our API class is now loosely-coupled. I would like to see what happens when we run the app like this:

We got an error:

The service type provided could not be loaded as a service because it does not have a default (parameter-less) constructor. To fix the problem, add a default constructor to the type, or pass an instance of the type to the host.

The system needs a parameter-less constructor as default. Let’s see how we get around with this.

Now, we need to provide those resources outside of our context but where? Let’s first bring down a IoC container. I am fan of Ninject so I will use it here as well:

After we install Ninject through NuGet, I added the following code inside my Global.asax file:

private IKernel GetKernel() { 
    
    IKernel kernel = new StandardKernel();

    kernel.Bind<People.Infrastructure.IPeopleRepository>().
        To<People.Models.PeopleRepository>();

    return kernel;
}

This will provide us the resources we need. Now, we need to tell WCF Web API to use this provider to create instances. Believe it or not, it is extremely easy to do that. Remember our default configuration object, WebApiConfiguration class? We will register our IoC container there:

RouteTable.Routes.SetDefaultHttpConfiguration(new Microsoft.ApplicationServer.Http.WebApiConfiguration() { 
    CreateInstance = (serviceType, context, request) => GetKernel().Get(serviceType)
});

We are passing a delegate here for CreateInstance property of our WebApiConfiguration class. When we run the application, we should see it working:

So nice to do something like that without much effort.

There is so much to show but I think this is enough for an intro (which I write on the stage of preview 5, I am little late ). I am sure that you get the idea here.

You can find the full code on GitHub: https://github.com/tugberkugurlu/VeryFirstWcfWebAPI

ASP.NET MVC Server Side Remote Validation

Sun, 06 Nov 2011 17:10:00 Z

For nearly 15 days, I have been poking around on the internet, books, etc. for anything related to ASP.NET MVC validation. I have to say that validation features in ASP.NET MVC framework is really outstanding.

I have blogged about Remote Validation twice so far: Check Instantly If Username Exists - ASP.NET MVC Remote Validation and ASP.NET MVC Remote Validation For Multiple Fields With AdditionalFields Property.

Remote validation is one of the useful stuff which is baked into MVC framework. It is easy to implement this feature manually with JQuery but it is kind of nice to have it out of the box. So, thanks a lot ASP.NET MVC team.

One thing which ASP.NET MVC Remove Validation is missing is no support for server side validation of the chosen property. There is probably a good reason not to support it out of the box though.

So, I decided to build one for myself. When I implemented it, I thought it worked fine and I should blog about it. So, I am writing this short blog post. But, on the other hand I am also sure that no one should use this on production at least for now I don’t know why but it feels like it is not stable. Maybe you can use it if you see a positive comment from an MSFT person on this post.

Here how it works:

First of all, we need to use Nuget here to bring down a very small package called TugberkUg.MVC which will have the necessary stuff for server side remote validation to work.

After that, here how we can use it:

  [Required]
  [Display(Name = "User name")]
  [Remote("doesUserNameExist", "Account", HttpMethod = "POST", ErrorMessage = "User name already exists. Please enter a different user name.")]
  [ServerSideRemote("Account", "doesUserNameExistGet")]
  public string UserName { get; set; }

You do not need to use ASP.NET MVC Remote validation along with ServerSideRemote validation but in a real world scenario, we probably would use both.

As you can see, there is not much to specify but of course, you get the options properties of ValidationAttribute class along with it. there is not much to specify there because I have built it for like 30 minutes. So, spare me for that.

When we look at our controller action which holds the validation logic, we will see that it is not much different that Remote validation’s:

public JsonResult doesUserNameExistGet(string term) {

    var user = Membership.GetUser(term);

    return Json(user == null, JsonRequestBehavior.AllowGet);
}

When I fire up the register page, I am getting the following screen :

I have excluded the JavaScript files for client side validation because we do not want to see client validation working. I already have a user registered whose user name is User1. When I completed the fields, I am getting no warning:

Let’s push the Register button :

Bingo! We got it working. Let’s try a legitimate one:

That worked as well.

I also put the sample project on GitHub so you can get the working sample code if you want :

https://github.com/tugberkugurlu/MvcRemoteValidationSample

Also, you can find the whole TugberkUg.MVC package’s code on BitBucket:

https://bitbucket.org/tugberk/tugberkug.mvc/src

Donut Hole Caching In ASP.NET MVC by Using Child Actions and OutputCacheAttribute

Sun, 30 Oct 2011 09:40:00 Z

One of the common issues of web applications is performance and serving the same content over and over again for hours, days, even months is certainly effecting the performance of our web applications. This is where server side caching comes in handy. But sometimes the whole page we are scripting on the server side is going to be static for hours and sometimes some portion of it.

The first one, caching the whole page, is sort of easy with almost any web development frameworks. The second one, caching a portion of your web page, is the tricky one.

Phil Haack blogged about Donut Hole Caching in ASP.NET MVC a while back but it is a little outdated. In this quick blog post, I will try to show you the easiest way of implementing this feature with ASP.NET MVC.

Use Cases

So, where might we need this Donut Hole Caching thing? For example, if you are listing categories on the side bar, you probably gathering those categories from a database. Add the fact that you render this part on every single page of your web application, it is a waste of time if your category list is not so dynamic. So, you may want to cache the category list part of the page so that you don’t go to your database every single time.

How to Do

In ASP.NET MVC framework, we can cache the whole controller action with OutputCacheAttribute which represents an attribute that is used to mark an action method whose output will be cached according to MSDN. This is perfect but wait a second. We do not want to cache the entire action, we just want to cache the portion of it. This is where ChildActionExtensions.Action method, which invokes a child action method and returns the result as an HTML string, plays a huge role. Let me show you how these parts of the framework play nice together.

Have a look at the below controller action :

[ChildActionOnly]
[OutputCache(Duration=60)]
public ActionResult sampleChildAction() {

    //Put the thread at sleep for 3 seconds to see the difference.
    System.Threading.Thread.Sleep(3000);

    //Also pass the date time from here just to see that it is comming from here.
    ViewBag.DateTime = DateTime.Now.ToString("dd.MM.yyyy HH:mm.ss");

    return View();
}

A simple controller action method which returns ActionResult, nothing fancy going on except for ChildActionOnlyAttribute which represents an attribute that is used to indicate that an action method should be called only as a child action. Let’s look at the sampleChildAction view and I will try to explain ChildActionOnlyAttribute function after that.

@{
    Layout = null;
}

<p>
    This portion of the web page was scripted on <strong>@ViewBag.DateTime</strong> and I will be cached for <strong>60</strong> seconds.
</p>

This html will be a part of our web page which will be cached. It doesn’t mean anything by itself but we have created an action for this view which means that we can call this page directly from a browser. ChildActionOnlyAttribute exactly prevent users to call this kind of actions. You do not need to implement this attribute there but it is nice to know that it is there for us.

The controller action which will render the whole page is so simple as below and doesn’t require any special thing for us to implement in order caching to work.

public ActionResult Index() {

    return View();
}

Let’s also look at the view implementation :

@{
    ViewBag.Title = "Donut Hole Caching Sample";
}

<h2>Donut Hole Caching Sample</h2>

<h3>Cached</h3>

<div>
    @Html.Action("sampleChildAction", 
      new { controller = "Sample", Area = "DonutHoleCaching" }
    )
</div>

<h3>Normal</h3>

<div>
    <p>
        This portion of the web page was scripted on <strong>@DateTime.Now.ToString("dd.MM.yyy HH:mm.ss")</strong>
    </p>
</div>

What we are doing here is that rather than putting the part, which we would like to cache, directly here, we are calling it as child action. So, the framework will treat the child action as it does for normal action methods.

When we first call it, we will see something like below :

While I was calling this page, I was on hold for 3 seconds because we have put the thread at sleep for 3 seconds on our child action method to feel the difference as you can see on above code in order.

When I make the second call, I got something like this and I wasn’t on hold for 3 seconds :

Did you notice the time difference? This proves that if the cache is valid, our child action method won’t be rendered again. It will serve from the cache. Awesome, ha?

I decided to create an ASP.NET MVC project called MvcMiracleWorker for this kind of small samples. You can find the complete source code from GitHub : https://github.com/tugberkugurlu/MvcMiracleWorker

Behave well, use ASP.NET MVC