Interface and its Implementation

Adalat Khan

Hi,

I have a question.

Why we declare an object from a class or interface as property object? whats the logic behind this. Why we not declare an object instead of property?. Following is the example:

public interface ICacheManager
{
    T GetData(CacheDataType type, string location = null, string client = null, string customKey = null);
    Task GetDataAsync(CacheDataType type, string location = null, string client = null, string customKey = null);
    List GetList(CacheDataType type, string location = null, string client = null, string customKey = null);
    Task GetListAsync(CacheDataType type, string location = null, string client = null, string customKey = null);
    void ReloadData(string location = null, string client = null);
    void ReloadData(CacheDataType type, string location = null, string client = null);
    void StoreData(CacheDataType type, T data, TimeSpan? slidingExpiry = null, string location = null, string client = null, string customKey = null);
}

//Implementation class
public class LocationService : ILocationService
{
    ICacheManager _cacheManager { get; set; }
    public LocationService(IConfigManager configManager)
    {
        _cacheManager = cacheManager;
    }
}

In the above class LocationService we declared a property object from the interface ICacheManager. Why we not declare an object instead of property? Whats the purpose behind this?

4 Replies

Know the answer? Post it — somebody with the same question will find it here.

Sachin Singh5y ago
And, don't say object, the word object is very different from the word member and variable.
private ICacheManager _cacheManager2;
means, a member of type ICacheManage, not an object,
it is just in the disk and will go to Ram when it will be instantiated by the UI.
Sachin Singh5y ago
Actually, is bad practice to create a property in your case, property means both getter and setter. you don't need a getter/setter while implementing DI. it is the UI that will pass the concrete object, so in your Location Service, a property doesn't make any sense to me.

so instead of

ICacheManager _cacheManager { get; set; }

you should have used this

private ICacheManager _cacheManager2;
private ICacheManager _cacheManager2;
public LocationService(IConfigManager configManager)
{
_cacheManager = cacheManager;
}
Adalat Khan5y ago
Hi Sachin,

Thanks for your great reply but my question was why we declared an object property from ICachManager Interface?. Please explain the bellow point:

ICacheManager _cacheManager { get; set; }
public LocationService(IConfigManager configManager)
{
_cacheManager = cacheManager;
}

what is the difference between the following in my case:

ICacheManager _cacheManager { get; set; }
ICacheManager _cacheManager2;

Property object and object only
Sachin Singh5y ago
In object-oriented programing, polymorphism is the heart and I consider it a boon to us. Without polymorphism, i just can't consider the programming.
Now, changing the behavior at run time is called polymorphism, great power isn't it.
Now, let's come to your point.
First is an interface, there is the only 3 main reason of using an interface, first is to standardize the vocabulary means any class that inherits from it will have to implement those methods and the signature will be same throughout the application means it doesn't matter, how many developers are working on a project all will use the same method name otherwise the compiler will shoe them.

second, an interface hides the internal mechanism, which means you now expose the method via an interface and not through the concrete class object which can be instantiated. so it hides the implementation or better say gives us a high level of abstraction.

the 3rd and the most important is to achieve polymorphism, what exactly you are doing in your example.
The D--> of SOLID principle says a class should always invert the object creation of other classes to some third person means an inversion of control, and the most famous technique to achieve it is DI, yes the Dependency injection, though people also use factory pattern etc, but the point i am trying to make is it is all to achieve the IOC.

But why?? the reason is simple, if a class will create the object of another class, it will mean that both are tightly coupled, which means any change in one class will affect the other class, in short, if you change class B then class A will ask you to recompile him.

So, the better is to create an interface and use it in the class's constructor, now the collie means the client who will call the method will actually pass the concrete object, in this way you inverted the control, you just gave the power of object creation to the client and now your UI (controller in MVC or Code-behind in webform) is independent of object creation of the BLL class, so you achieved loose coupling.

now, by example
public interface ICacheManager
    {
        T GetData(CacheDataType type, string location = null, string client = null, string customKey = null);
        Task GetDataAsync(CacheDataType type, string location = null, string client = null, string customKey = null);
        List GetList(CacheDataType type, string location = null, string client = null, string customKey = null);
        Task> GetListAsync(CacheDataType type, string location = null, string client = null, string customKey = null);
        void ReloadData(string location = null, string client = null);
        void ReloadData(CacheDataType type, string location = null, string client = null);
        void StoreData(CacheDataType type, T data, TimeSpan? slidingExpiry = null, string location = null, string client = null, string customKey = null);
    }
Hey, I am BLL's CacheManager, I will implement the interface.
public class CacheManager: ICacheManager
{
// some method implementaion

}
Hey, who the hell are you CacheManager, Don't you know, the requirement is now changed and your implementation has no value now, just go to hell.
I am CacheManger2, I will give some awesome implementation.
public class CacheManger2: ICacheManager

    {

// new method implementation here

}
good, now, which implementation will the UI use? Doesn't matter, whichever he will like he will pass the object of that, and in this way you achieved loose coupling.
The interface gave the UI the power to point anyone and at run time by the virtue of polymorphism, it will be resolved.
UI
  LocationService ls= new LocationService (new Cachemanager2());
ls.GetData();

LocationService ls= new LocationService (new Cachemanager());
ls.GetData(); // easily pointing to new implementation, great.