Dependency Injection in C#

Dependency Injection (DI, wikipedia) is a design pattern that reduces hard-coded dependencies between your classes by injecting these dependencies at run-time, instead of during design-time. Technically, Dependency Injection is a mechanism that allows the implementation of another, more high-level, design pattern called Inversion of Control (IoC, wikipedia). The purpose of both patterns is to reduce hard-coded dependencies (or ‘coupling’) between your classes.

 What are dependencies?

 Suppose that you are building a web application that is going to send e-mails to visitors that have entered a form. In object-oriented code, it is important to separate responsibilities. So you’ll probably end up with a class that handles the form input (FormHandler) and a class that is responsible for sending the e-mails (MailSender).

The MailHandler class looks like this:

public class MailSender
{
    public void Send(string toAddress, string subject)
    {
        Console.WriteLine(“Sending mail to [{0}] with subject [{1}]”, toAddress, subject);
    }
}

your FormHandler class will look like this:

public class FormHandler
{
   public void Handle(string toAddress)
     {
        MailSender mailSender = new MailSender();
        mailSender.Send(toAddress, “This is concrete code implementation example”);
     }
}

Although there’s nothing wrong with this code, it is creating a dependency between the FormHandler and MailSender classes.

The dependency is created at line MailSender mailSender = new MailSender();.

Using the New keyword in your code to instantiate a class implies that you are creating a dependency. From a practical point of view, you are telling your FormHandler class to use a concrete implementation of the MailSender class. There’s no flexibility. ‘But why’, you ask, ‘is this a bad thing?’. Let’s take a look at some reasons …

Why are dependencies a bad thing?

  • You can’t use multiple implementations of the MailSender class
  • It makes unit testing (nearly) impossible

The bottom-line is that your FormHandler shouldn’t know what concrete implementation of the MailSender is used. What concrete implementation is used, should be determined outside of your classes. That way, you can swap out the MailSender with another implementation if the need arises. If you are writing unit tests for the FormHandler, you can swap out the MailSender class with a mocked version.

we have to do is rewrite our code to use Interfaces. This is required for Dependency Injection, but is good practice anyways. An interfaces is basically a contract between classes that force one class to behave exactly as described by the interface. The contract can be implemented by other implementations (different class, same behavior).

We create a very straightforward interface for the MailSender class:

public interface IMailSender
{
    void Send(string toAddress, string subject);
}

We also rewrite the MailSender class to implement the IMailSender interface:

public class MailSender : IMailSender
{
    public void Send(string toAddress, string subject)
    {
        Console.WriteLine(“Sending mail to [{0}] with subject [{1}]”, toAddress, subject);
    }
}

We’ve basically told C# that the concrete implementation of our MailSender class follows the IMailSender interface (or contract). It is now possible to create other concrete implementations that follow the same interface but do different things ‘under the hood’,

for example:

public class MockMailSender : IMailSender
{
    public void Send(string toAddress, string subject)
   {
       Console.WriteLine(“Mocking mail to [{0}] with subject [{1}]”, toAddress, subject);
   }
}

Right now, we can change which concrete implementation is used by our FormHandler by rewriting the code where the class is instantiated:

public class FormHandler
{
    public void Handle(string toAddress)
    {
         IMailSender mailSender = new MockMailSender();
        mailSender.Send(toAddress, “This is still a concrete implementation “);
    }
}

Of course, this already adds a lot of flexibility to our code, as we can swap out which concrete implementation of IMailService is used by changing line IMailSender mailSender = new MockMailSender();.

Although C# will now force you to implement the IMailSender interface to the letter, your code will already improve a lot by using interfaces. The next step is to implement manual dependency injection to get rid of this code change that is required to change which implementation is used.

Implementing manual dependency injection:

 Basically, we’re going to pass the dependency in through the constructor of the FormHandler class. This way, the code that is using the FormHandler can determine which concrete implementation of IMailSender to use:

public class FormHandler
{
     private readonly IMailSender mailSender;

     public FormHandler(IMailSender mailSender)
     {
          this.mailSender = mailSender;
     }

    public void Handle(string toAddress)
     {
          mailSender.Send(toAddress, “This is manual dependency injection”);
      }
}

The code that creates our FormHandler has to pass in a concrete implementation of IMailService. This means that control is now inverted; instead of the FormHandler deciding which implementation to use, the calling code does. This is the whole point of Inversion of Control, of which Dependency Injection is just one approach. The calling code (the code that uses the FormHandler and now controls the dependencies) looks like this:

class Program
{
    static void Main(string[] args)
    {
        IMailSender mailSender = new MockMailSender();
        FormHandler formHandler = new FormHandler(mailSender);
        formHandler.Handle(“contact@uzval.com”);

        Console.ReadLine();
     }
}

 Concluding thoughts:

 Dependency Injection is a difficult concept to grasp if you’ve never used it before. Just give it a try, and you’ll see how flexible it makes your code. Especially when you’re writing unit tests you’ll quickly see the benefits. In that case, you can easily swap in mock implementations of dependencies. If anything, it makes your code a lot cleaner and sort of forces you to write better code.

Asynchronous Programming with Async and Await in .NET

You can avoid performance bottlenecks and enhance the overall responsiveness of your application by using Asynchronous Programming.

What is Asynchronous Programming?

Asynchronous programming is writing code that allows several things to happen at the same time without “blocking”, or waiting for other things to complete. This is different from synchronous programming, in which everything happens in the order it is written.

Let’s see example. Say I have a class called ContentManagement, which has both synchronous and asynchronous methods:

public class ContentManagement  
{
    public string GetContent()
    {
        Thread.Sleep(2000);
        return "content";
    }

    public int GetCount()
    {
        Thread.Sleep(5000);
        return 4;
    }

    public string GetName()
    {
        Thread.Sleep(3000);
        return "UZVAL";
    }

    public async Task<string> GetContentAsync()
    {
        await Task.Delay(2000);
        return "content";
    }

    public async Task<int> GetCountAsync()
    {
        await Task.Delay(5000);
        return 4;
    }

    public async Task<string> GetNameAsync()
    {
        await Task.Delay(3000);
        return "UZVAL";
    }
}

Now let’s write an MVC controller, like so:

public class HomeController : Controller  
{
    [HttpGet]
    public ActionResult Index()
    {
        Stopwatch watch = new Stopwatch();
        watch.Start();
        ContentManagement service = new ContentManagement();
        var content = service.GetContent();
        var count = service.GetCount();
        var name = service.GetName();

        watch.Stop();
        ViewBag.WatchMilliseconds = watch.ElapsedMilliseconds;
        return View("Index");
    }

    [HttpGet]
    public async Task<ActionResult> IndexAsync()
    {
        Stopwatch watch = new Stopwatch();
        watch.Start();
        ContentManagement service = new ContentManagement();
        var contentTask = service.GetContentAsync();
        var countTask = service.GetCountAsync();
        var nameTask = service.GetNameAsync();

        var content = await contentTask;
        var count = await countTask;
        var name = await nameTask;
        watch.Stop();
        ViewBag.WatchMilliseconds = watch.ElapsedMilliseconds;
        return View("IndexAsync");
    }
}

async : This tells the compiler that this method can run asynchronously.

await : This tells the compiler that we will ultimately need the result of the async method.

Notice what these two action methods are doing. In both cases, the action methods are calling the methods in the ContentManagement service, but in one they are doing it asynchronously.

On our Index view, we have an output : 

Time Elapsed : 10000 ms

On our IndexAsync view, we have an output : 

Time Elapsed : 5000 ms

Where did we get that number? The longest-running of the three tasks takes 5 seconds. By designing this to use async, we cut our total execution time in half! That’s a lot of speedup to be gained from writing a little extra code.

Potential Issues :

When we mark a method as async, the compiler generates a state machine in the background; this is extra code. If we write good, stable asynchronous code, the amount of time it takes to create this extra structure won’t impact us at all, since the benefits of running asynchronously outweigh the cost of building the state machine. However, if our async method doesn’t have an await, the method will run synchronously, and we will have spent extra time creating the state machine that we didn’t use.

There’s one other potential problem to be aware of. We cannot call an asynchronous method from a synchronous one. Because async and await should go together in all cases, we pretty much have to have async on all methods, all the way down. This is why we needed separate async methods in the ContentManagement class earlier.

List To DataTable and Vice Versa using C#

public class ObjectConverter
 {
     public DataTable ListToDataTable(List items)
     { 
          DataTable dataTable = new DataTable(typeof(T).Name);
          //Get all the properties
          PropertyInfo[] Props = typeof(T).GetProperties(BindingFlags.Public |         BindingFlags.Instance);
          foreach (PropertyInfo prop in Props)
          {
            //Setting column names as Property names
            dataTable.Columns.Add(prop.Name);
          }
          foreach (T item in items)
          {
            var values = new object[Props.Length];
            for (int i = 0; i < Props.Length; i++)
             {
               //inserting property values to datatable rows
               values[i] = Props[i].GetValue(item, null);
             }
            dataTable.Rows.Add(values);
          }
          return dataTable;
     }

     public static List DataTableToList(DataTable dt)
     {
       List lstdata = new List();
       foreach (DataRow row in dt.Rows)
        {
           T item = GetItem(row);
           lstdata.Add(item);
        }
        return lstdata;
      }

      private static T GetItem(DataRow dr)
      {
        Type temp = typeof(T);
        T obj = Activator.CreateInstance();

        foreach (DataColumn column in dr.Table.Columns)
        {
          foreach (PropertyInfo pro in temp.GetProperties())
          {
            if (pro.Name == column.ColumnName)
               pro.SetValue(obj, dr[column.ColumnName], null);
            else
               continue;
          }
        }
        return obj;
       }
 }
Calling : 
 ObjectConverter converter = new ObjectConverter();
 
 DataTable dtstudentDetails=new DataTable();
 dtstudentDetails = converter.ListToDataTable(lststudentDetails); 

 List lststudentDetails = new List(); 
 lststudentDetails = converter.DataTableToList(dtstudentDetails);

Object To XML and Vice Versa using C#

Sometimes in web applications we like to save or send our data as XML to the SQL databases.
It’s mostly done when there is a large chunk of data or we like to convert our entity model objects to XML.
It makes it easier to move data from web applications to SQL database and vice versa.
Here I’ll share a code snippet to convert C# object to XML and XML to object C#.

C# Object to XML:

To convert an object to XML, we’ll make use of XmlSerializer to serialize and XmlTextWriter to output the XML string.
Here is how the code looks like :

public static string GetXMLFromObject(object o)
{
    StringWriter sw = new StringWriter();
    XmlTextWriter tw = null;
    try
    {
        XmlSerializer serializer = new XmlSerializer(o.GetType());
        tw = new XmlTextWriter(sw);
        serializer.Serialize(tw, o);
    }
    catch (Exception ex)
    {
        //Handle Exception Code
    }
    finally
    {
        sw.Close();
        if (tw != null)
        {
            tw.Close();
        }
    }
    return sw.ToString();
}

XML to Object C# :

Similarly, to convert an XML string to object we make use of the XmlSerializer to deserialize and XmlTextReader to read the XML string.
Here is how the code to convert XML to objects looks like :

public static Object ObjectToXML(string xml, Type objectType)
{
    StringReader strReader = null;
    XmlSerializer serializer = null;
    XmlTextReader xmlReader = null;
    Object obj = null;
    try
    {
        strReader = new StringReader(xml);
        serializer = new XmlSerializer(objectType);
        xmlReader = new XmlTextReader(strReader);
        obj = serializer.Deserialize(xmlReader);
    }
    catch (Exception exp)
    {
        //Handle Exception Code
    }
    finally
    {
        if (xmlReader != null)
        {
            xmlReader.Close();
        }
        if (strReader != null)
        {
            strReader.Close();
        }
    }
    return obj;
}

Calling :

Employee emp = new Employee();
emp.FirstName = "Ujjwala Datta";
emp.LastName = "Kalluri";

string xml = GetXMLFromObject(emp);
<?xml version="1.0" encoding="utf-16" ?> 
- <Employee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <FirstName>Ujjwala Datta</FirstName> 
  <LastName>Kalluri</LastName> 
  </Employee>

Object obj = ObjectToXML(xml,typeof(Employee));

Regenerating SessionID in ASP.NET

Creating New ASP.NET_SessionId & Attaching Old ASP.NET_SessionId Values to New ASP.NET_SessionId

public void RegenerateSessionId()

{
System.Web.SessionState.SessionIDManager manager = new System.Web.SessionState.SessionIDManager();
string oldId = manager.GetSessionID(System.Web.HttpContext.Current);

string newId = manager.CreateSessionID(System.Web.HttpContext.Current);

bool isAdd = false, isRedir = false;
manager.SaveSessionID(System.Web.HttpContext.Current, newId, out isRedir, out isAdd);

HttpApplication ctx = (HttpApplication)HttpContext.ApplicationInstance;
HttpModuleCollection mods = ctx.Modules;
System.Web.SessionState.SessionStateModule ssm = (SessionStateModule)mods.Get(“Session”);
System.Reflection.FieldInfo[] fields = ssm.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
SessionStateStoreProviderBase store = null;
System.Reflection.FieldInfo rqIdField = null, rqLockIdField = null, rqStateNotFoundField = null;
foreach (System.Reflection.FieldInfo field in fields)
{
if (field.Name.Equals(“_store”)) store = (SessionStateStoreProviderBase)field.GetValue(ssm);
if (field.Name.Equals(“_rqId”)) rqIdField = field;
if (field.Name.Equals(“_rqLockId”)) rqLockIdField = field;
if (field.Name.Equals(“_rqSessionStateNotFound”)) rqStateNotFoundField = field;
}
object lockId = rqLockIdField.GetValue(ssm);
if ((lockId != null) && (oldId != null)) store.ReleaseItemExclusive(System.Web.HttpContext.Current, oldId, lockId);
rqStateNotFoundField.SetValue(ssm, true);
rqIdField.SetValue(ssm, newId);
}

UZVAL – Statistics – Total Hits-22,222, Total Visitors-6623, Total Posts – 93

Six years back I started posting certain postings in this blog for learning purpose.

Today it got 22,222 hits, Total Visitors-6623, Total Posts – 93.

During this tenure I had Learned a lot & Implemented my level best, Professionally & Personally.

Today i am feeling that i had completed one life cycle.

Heartful Thanks to My Well-Wishers who had given me good opportunities.

Now we all know lot of significant CHANGES (new versions, new libraries, new frameworks) evolved in .Net Stack.

Hope TOGETHER (Integrations & Collaborations) we learn and implement NEW needful CHANGES Professionally & Personally for a better life-style & society.

Sincerely,

Ujjwala Datta Kalluri.

uzval

If any Suggestion, please submit it below :

Getting MAC Address of Client Machine in C #

Usually MAC address is also used to keep track of the unique Identification, if IP Address are not static, Every then from same system it will generate different IP Address, so cannot be keep records for unique, unless it is Static IP.

But MAC is set in users hardware system it is easy to trace, it is also used in E-commerce website, even IRCTC uses MAC Address to traces the records to trace the number of new user per day.

A media access control address (MAC address), also called physical address, is a unique identifier assigned to network interfaces for communications on the physical network segment.

MAC addresses are used as a network address for most IEEE 802 network technologies, including Ethernet and WiFi. Logically, MAC addresses are used in the media access control protocol sublayer of the OSI reference model.
MAC addresses are most often assigned by the manufacturer of a network interface controller (NIC) and are stored in its hardware, such as the card’s read-only memory or some other firmware mechanism.

If assigned by the manufacturer, a MAC address usually encodes the manufacturer’s registered identification number and may be referred to as the burned-in address (BIA). It may also be known as an Ethernet hardware address (EHA), hardware address or physical address. This can be contrasted to a programmed address, where the host device issues commands to the NIC to use an arbitrary address.

How do I find out the MAC address of my computer? (Windows)
• Click the Start icon
• Click Control Panel
• Select Network and Internet
• Click Network and Sharing Centre
• Select Change Adapter Settings from the list on the left hand side
• You may have a separate icon for your Wireless connection, Ethernet (Wired) and a Virtual WiFi MiniPort. Each has its own MAC address.
• Right click on the connection you are trying to find the MAC address for and select Properties
• Hover your mouse over the text box underneath connect using . Your MAC address will appear in the tooltip and is made up of 12 characters e.g. 00:11:22:AA:66:DD
using System.Management;
using System.IO;

protected void Page_Load(object sender, EventArgs e)
{
string MacAddress = GetMACAddress();
}

public string GetMACAddress()
{
string macAddresses = “”;

foreach (System.Net.NetworkInformation.NetworkInterface nic in System.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces())
{
if (nic.OperationalStatus == System.Net.NetworkInformation.OperationalStatus.Up)
{
macAddresses += nic.GetPhysicalAddress().ToString();
break;
}
}
return macAddresses;
}