Implement decouple architecture in Interface

Develop decouple architecture using interface in C#

In general, the term coupling represents the relationship between two objects. Couplings are two types

1)      Tight coupling

2)      Loose coupling

Tight coupling:-

Tight coupling represent very close relationship between two entities.  And most of the time one entity is very closely dependent on another entity. And if you change one entity then it’s effect on another one.  Let me give one small example in programming perspective. Let’s Think, there is three layer architecture in project.  Where each layer is very heavily related with other one. Now if you change one layer say User interface layer then you might have to change business layer also ,because your layer are tightly couple with each other. And always we will try to avoid this pattern

Loose coupling:-

Loose couple represents very slight dependency between entities.  And if we represent three layer architecture as a loosely couple then change of one layer will not much effect to another one. Or with very little amount of change we can get full functionality. And in software development always we should build de couple architecture.

Now question is how we can achieve de-coupling ?  

There are no shortcuts for that or there is no single line answer. It will come from your experience.  If you practice few guideline and good practice then you can achieve this. Now speak technically .

Use interface to implement de couple architecture.

Yes , using interface you can reduce coupling between classes. When two classes want to communicate with each other just use interface between them and through interface, let them communicate. In below example I am giving one example

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
using System.Data;
using System.Diagnostics;
using System.Data.SqlClient;
 
namespace BlogProject
{
    interface IPerson
    {
        void ShowCountry();
    }
 
    class IndianPerson:IPerson
    {
        public void
ShowCountry()
        {
            Console.WriteLine("I
am Indian Person");
        }
    }
    class USPerson :IPerson
    {
        public void
ShowCountry()
        {
            Console.WriteLine("I
am US Person");
        }
    }
 
 
    class PersonSupplyer
    {
        public static IPerson ReturnPerson(String
country)
        {
            if (country == "INDIA")
               
return new
IndianPerson();
            else if (country == "US")
               
return new
USPerson();
            else
               
return null;
        }
 
    }
 
   class Program
    {
        static void Main(string[] args)
         {
             IPerson objPerson = PersonSupplyer.ReturnPerson("INDIA");
            
objPerson.ShowCountry();
             Console.ReadLine();
         }
    }
}
 

Here I have created one Interface like

    interface IPerson
    {
        void ShowCountry();
    }

This interface contains one function .And now I am implementing this interface in two classes in my middle layer or business layer. Like below

class IndianPerson:IPerson
    {
        public void
ShowCountry()
        {
            Console.WriteLine("I
am Indian Person");
        }
    }
    class USPerson :IPerson
    {
        public void
ShowCountry()
        {
            Console.WriteLine("I
am US Person");
        }
    }

 And one more class I have kept in middle layer to supply proper object of concrete class.

class PersonSupplyer
    {
        public static IPerson ReturnPerson(String
country)
        {
            if (country == "INDIA")
               
return new
IndianPerson();
            else if (country == "US")
               
return new
USPerson();
            else
               
return null;
        }
    }

The purpose of this class is to generate appropriate object of concrete class. Now my client is here

static void Main(string[] args)
         {
             IPerson objPerson = PersonSupplyer.ReturnPerson("INDIA");
            
objPerson.ShowCountry();
             Console.ReadLine();
         }

And my client is totally unaware about my concrete class. It only knows which parameter need to send to get which class’s object .

Now, what is Advantage of that?

The main advantage of this design is client is totally unaware about concrete class representation. Because,  ersonsupplyer class is making abstraction over my concrete class.

The second advantage is , if we add one more person class in my middle layer then no need to change any code in client layer. Just it’s enough to inform client developer which parameter need to supply to get object of newly added class.

The third advantage is we can control new keyword in our client code. As only in one place we are creating new keyword.