Caveman's Blog

My commitment to learning.

Archive for the ‘General Programming’ Category

Dependency Injection: Unity Application Block

leave a comment »


In this post I will show you how to use Microsoft Unit Application Block to achieve Dependency Injection. We will see the two methods of configuring the IOC container, firstly the “.config” way and then the “inline” method. Let us take a look at the following code snippet and see how this code can be improved.

class Program
{
    static void Main(string[] args)
    {
        Service svc = new Service();
        svc.Print();
    }
}

public class Service
{
    public void Print()
    {
        Employee empl = new Employee();
        empl.PrintEmployeeTitle("Test Employee");
    }
}

public class Employee
{
    public void PrintEmployeeTitle(string name)
    {
        Console.WriteLine("Employee Name: {0}, Title:{1}", name, "Some Title");
    }
}

What does this code do?

The above code snippet if from a console application, where we are creating an instance of the Service class and are calling the Print method. The Print method in turn instantiates the Employee class and then calls the PrintEmployeeTitle method of the Employee class to print the employee name and title. The PrintEmployeeTitle method writes the name and title of an employee to the console.

What is wrong?

Nothing. While there is nothing wrong with this code, if we closely observer, we can notice that the Employee class instance could not exist without an instance of the Service class. Basically they both are tightly coupled, meaning to say we can only have one implementation of the Employee class to be consumed by the Service class at any given instance of time.

What if we have a scenario when we want to test more than one implementation of the Employee class or if the Employee class implementation is a work-in-progress? Here is where Dependency Injection design pattern comes to our rescue. I hope I have set some context before I explaining about DI and its implementation.

Solving the problem

Decoupling the Employee class life cycle management from the Service class is the primary objective.  The advantage of decoupling the Employee class are that 1) we will be in a position to provide multiple implementations to the Employee class 2) be able to select the kind of implementation that is suitable for our purpose and 3) manage the life cycle of the Employee class. We define an interface IEmployee with one method PrintEmployeeTitle and define two implementations for this demo purpose. The first implementation is what we already had above and the second is a MockEmployee Class.

public class Employee : IEmployee
{
    public void PrintEmployeeTitle(string name)
    {
        Console.WriteLine("Employee Name: {0}, Title:{1}", name, "Some Title");
    }
}

public class MockEmployee : IEmployee
{
    public void PrintEmployeeTitle(string name)
    {
        Console.WriteLine("Employee Name: {0}, Title:{1}", name, "Some MOCK Title");
    }
}

public interface IEmployee
{
    void PrintEmployeeTitle(string name);
}

Let us see how we can delegate the Employee class instantiation to the client (Class:Program; Method: Main) and then inject the Employee object into the Service object.

Dependency Injection

Service class has a dependency on the Employee class and our objective here is inject this dependency into the Service class from the Client. Dependency injection is a software design pattern that allows a choice of component to be made at run-time rather than compile time [2]. One way to achieve this is via passing the Employee object reference to the Service class constructor like in the code below:

class Program
{
    static void Main(string[] args)
    {
        Employee empl = new Employee();
        Service svc = new Service(empl);
        svc.Print();
    }
}

public class Service
{
    private IEmployee empl;
    public Service(IEmployee empl)
    {
        this.empl = empl;
    }

    public void Print()
    {
        empl.PrintEmployeeTitle("Test Employee");
    }
}

Another way of injecting the Employee reference into the Service object is via setting the instance of Employee class to an I IEmployee property of the Service class.

class Program
{
    static void Main(string[] args)
    {
        Employee empl = new Employee();
        Service svc = new Service();
        svc.empl = empl;
        svc.Print();
    }
}

public class Service
{
    IEmployee _empl;
    public IEmployee empl
    {
        set
        {
            this._empl = value;
        }
    }
    public void Print()
    {
        _empl.PrintEmployeeTitle("Test Employee");
    }
}

We have so far been able to decouple the Service class and the Employee class, however we still have to create an instance of the Employee class to implement dependency injection. Any change in to the Employee class creation mechanism with require a code change and also a code recompile.  This is the point where IOC framework comes handy in automating the creation and injection of the dependency via just one configuration.

Inversion of control

In software engineering, Inversion of Control (IoC) is an object-oriented programming practice where the object coupling is bound at run time by an assembler object and is typically not known at compile time using static analysis [1]. Like discussed earlier we are going to transfer the control of creating the Employee object to the IOC framework rather than keeping it with the Client, mean to say we are performing an “Inversion of Control”.

The configured entities are loaded into an IOC container at run-time and will be injected into the appropriate classes. We can implement .Net Dependency Inject using any one of the following IOC containers:

Microsoft Unity IoC Container

Now let us look at the two ways of configuring and implementing DI using Microsoft Unity Container. Before we can use the Unity container you have to download and install the Microsoft Unit Application Block from the Microsoft Patterns and Practices website. The dll’s necessary for this implementation can be found under the “Drive:/Program Files/Microsoft Unity Application Block x.0/Bin/” folder and should be added as references to your project.

Please accept my apologies for a very crude/rude representation of the client (Class: Program, Method: Main) being able to select one of the three implementations of the Employee class use Dependency Injection via an IOC container.

Application Configuration File

When we have to implement DI using the Application Config file, we have to define Unity block section, define a container and register that namespace and the Class that is getting DI’ed.

<configSections>
<section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Microsoft.Practices.Unity.Configuration" />
</configSections>
<unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
<alias alias="singleton" type="Microsoft.Practices.Unity.ContainerControlledLifetimeManager,
Microsoft.Practices.Unity" />
<container name="TestService">
<register type="UnityFrameworkDemo.IEmployee, UnityFrameworkDemo"
mapTo="UnityFrameworkDemo.MockEmployee, UnityFrameworkDemo">
<lifetime type="singleton" />
</register>
</container>
</unity>

I had to also add a reference of the System.Configuration namespace to the project. Once we have this configuration all set, we have to update the client to 1) load the container that we defined in the configuration and 2) generate the Service class based on the configuration that we have defined:

class Program
{
    static void Main(string[] args)
    {
        try
        {
            container.LoadConfiguration("TestService");
            svc = container.Resolve();
            if (svc != null)
                svc.Print();
            else
                Console.WriteLine("Could not load the Service Class");
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

public class Service
{
    IEmployee _empl;
    public Service(IEmployee empl)
    {
        this._empl = empl;
    }

    public void Print()
    {
        _empl.PrintEmployeeTitle("Test Employee");
    }
}

You would also have noticed that I have added a constructor that accepts parameter of IEmployee type to the Service class. The IOC framework will use this constructor to generate an instance of the Service class and will also pass a reference of the Employee class into the Service instance. Following is the output of using the default Employee implementation:

Now switching to the Mock Employee implementation from the default implementaion is as simple as updating the register element of the configuration with the MockEmployee class name and then we get the following output


Inline

Lastly let us look at how we can configure an implementation inside the client instead of in the application config file. Basically you have to register the Interface and the implementation with the container in the client and your client is ready to make a call to the Service instance methods like shown in the code below:

container.RegisterType();
   svc = container.Resolve();
   if (svc != null)
      svc.Print();

Unity framework basically provides a fantastic approach to decouple the application layer code. You can define several containers and register several classes with the container and be able to enjoy the flexibility by implementing Dependency Injection using the Unity IOC container.

Happy Fourth of July !

References:
1. Inversion of Control – IOC – Wikipedia
2. Dependency Injection – Wikipedia

 
Advertisements

File upload – attachment size validation

with one comment


Restricting the size of a file upload is an important validation that needs to be performed by an online application so avoid the risk of filling up the server disk space by a malicious intent. ASP.Net provides an upload control that only provides a server side validation of file size. By the time the control validates the size of the uploaded file, the physical file would have been already been copied to the server, which is tool late in avoiding the issue.

Client side technologies comes to the rescue in this scenario, where the validation of an attachment size can be implemented using a browser run-time like Flash, Silverlight, ActiveX, HTML5 etc. This way, if attempts were made to upload files with unsupported sizes, the run-time plug-in can thwart the attempt without any impact on your web server. Following are two free tools that can be employed for this purpose:

  • SWFUpload is a flash based tool.
  • PLUpload is a versatile plugin that can support multiple run-times. This plugin slices a large file in small chunks and will send them out one by one to the server. You can then safely collect them on the server and combine into the original file. The size of the chunks and the acceptable file formats can be defined in the plugin UI definition.

We have implemented PLUpload with good success. This plugin also support multiple file uploads. Visit the plugin homepage to see the other rich features that are supported. The online forum is a treasure trove, where you can find the various implementations, code snippets and will be able to participate in contributing to the community.

PLUpload

References:
1. SWFUpload
2. PLUpload
3. PLUpload Forums

Written by cavemansblog

February 20, 2013 at 10:02 am

Failed to enable constraints

leave a comment »


Debugging a “failed to enable constraint” error when filling a data table was very hard until I found this wonderful tip. This blog post is only for documentation purpose and the full credit goes to PaulStock for this awesome response.

This problem is usually caused by one of the following

  • null values being returned for columns not set to AllowDBNull
  • duplicate rows being returned with the same primary key.
  • a mismatch in column definition (e.g. size of char fields) between the database and the dataset

Try running your query natively and look at the results, if the resultset is not too large. If you’ve eliminated null values, then my guess is that the primary key columns is being duplicated.

Or, to see the exact error, you can manually add a Try/Catch block to the generated code like so and then breaking when the exception is raised:

enter image description here

Then within the command window, call GetErrors method on the table getting the error.
For C#, the command would be ? dataTable.GetErrors()
For VB, the command is ? dataTable.GetErrors

enter image description here

This will show you all datarows which have an error. You can get then look at the RowError for each of these, which should tell you the column that’s invalid along with the problem. So, to see the error of the first datarow in error the command is:
? dataTable.GetErrors(0).RowError
or in C# it would be ? dataTable.GetErrors()[0].RowError

enter image description here

Reference:

1. Failed to enable constraints. One or more rows contain values violating non-null, unique, or foreign-key constraints

Written by cavemansblog

June 10, 2012 at 10:26 am

C# 3.0: Extension method “In”

leave a comment »


Extension methods allows existing classes to be extended with out having to change the class’s source code. This means that we can add new functionality to existing like the String class, where we do not have access to modifying the source code. Here is one such extension method for the String class. Note that the class is defined as non-generic static and the “this” keyword specifies the type on which extension method is a part of.

The “In” extension method can be used to check if a given string exists in a set of strings.

public static class Extensions
{
      public static bool In(this string t, params string[] values)
      { return values.Contains(t); }
}

Usage: In the code below an we are trying to check if an input string “new” exists in a give list of strings (“new”,  “renew”) and it can be called in an application by this syntax

string[] strList = { "new", "renew" };
string inputStr = "new";
if (inputStr.In(strList))
    Console.WriteLine("Found a match");

References:
1. Extension Methods (C# Programming Guide)

Written by cavemansblog

March 8, 2012 at 6:25 pm

Linq: Contains operator

leave a comment »


The Contains method determines weather a sequence contains a specified element by using the default equality comparer. The following code illustrated a how “contains” and “not contains” operations can be implemented to filter a list of objects. In this sample code we filter the objects on the “name” property, the code for generating the collection class can be obtained from my previous post:

//Filter by "007" containing as a part of the employee list
var sortedEmployees = EmployeeList.Where(i => i.name.Contains("007")).ToList();

//Filter by "007" NOT containing as a part of the employee list
sortedEmployees = EmployeeList.Where(i => !i.name.Contains("007")).ToList();

The contains method also has an overloaded method, which can take a custom comparer as an argument. The custom comparer could be used to determine if an object is contained in a given sequence of objects. A sample implementation can be found at this location. My take away from the sample at MSDN is the implementation of the object comparer and more specifically the way the GetHashCode method has been implemented.

References:
1. MSDN Online

Written by cavemansblog

January 10, 2012 at 12:48 am

Linq: OrderByDescending operator

leave a comment »


OrderByDescending is one of the query operators in linq and can be can be to sort data, objects by descending order. Following is an example of an employee collection that is sorted in descending order using the OrderByDescending operator. The following code snippet illustrated the ordering of the Employee objects in descending order:

 class Program
    {
        static void Main(string[] args)
        {
            List<Employee> EmployeeList = new List<Employee>();
            Employee employee = new Employee();
            employee.ID = 1001;
            employee.name = "User 1001";
            EmployeeList.Add(employee);

            employee = new Employee();
            employee.ID = 1007;
            employee.name = "User 1007";
            EmployeeList.Add(employee);

            employee = new Employee();
            employee.ID = 1002;
            employee.name = "User 1002";
            EmployeeList.Add(employee);

            var sortedEmployeed = EmployeeList.OrderByDescending(i => i.ID);
            foreach (var emp in sortedEmployeed)
                Console.WriteLine("EmployeeID: {0}", emp.ID);

        }
    }

    public class Employee
    {
        public int ID { get; set; }
        public string name { get; set; }
    }

Written by cavemansblog

January 8, 2012 at 1:38 am

C# 4.0 – Named and Optional parameters

leave a comment »


In this post I will cover two C# 4.0 features that I have recently learned. Optional parameters allows us to define default values to a method parameters. This will help us calling the methods in a polymorphic manner. The code below defines a method to calculate the interest for a given principal amount:

public static decimal SimpleInterest(decimal principal, decimal interest = 2)
{
decimal interestPaid = principal * (interest / 100);
return interestPaid;
}

We can pass the principle amount and the interest rate as arguments compute the interest like below;

SimpleInterest(1000, 20);

or we can also compute the interest using the default interest rate like below:

SimpleInterest(1000);

Named arguments allows us to explicitly name the parameters that are passed to a method. This is a great feature in combination with Optional parameters when the method supports multiple optional parameters. This style of notation will make the code more readable and will be useful when  I will use the method from the above example here as well to name the arguments to the method like below:

SimpleInterest(principal : 1000, interest: 20);
SimpleInterest(principal : 1000);

Written by cavemansblog

December 20, 2011 at 1:55 pm