Map the interface to Class (dynamically) that doesnt implement interface C#

Question

This is my first post in Stackoverflow. Thanks to Stackoverflow.

My Question:

I have one interface in class library.

namespace TestClient
{
   public interface IMobileStore
   {
        List<string> GetMobileDetails();

        int AddMobile(string mobile);
   }
}

And i have class named MobileLibrary in another class library and implemented IMobileStore interface (While development)

namespace MobileLibrary
{
    public class MobileLibrary  : IMobileStore
    {
        List<string> GetMobileDetails()
        {
             return new List<string>();
        }

        int AddMobile(string mobile)
        {
             return 1;
        }
    }
 }

And consumed the MobileLibrary library in console application and used.

But now i want to use the IndianMobileLibrary (which is having same structure of MobileLibrary class as below, but it doesn't implement the interface) instead of MobileLibrary

Note: IndianMobileLibrary available in another class library (don't have any control on this library - 3rd party library)

namespace IndianMobileLibrary 
{
     public class IndianMobileLibrary  //(doesn't implement the interface)
    {
         List<string> GetMobileDetails()
         {
             return new List<string>();
         }

         int AddMobile(string mobile)
         {
             return 1;
         }
     }
 }

Here how to map the IMobileStore dynamically to IndianMobileLibrary (as implementation), and dynamically create object for IMobileStore that implements IndianMobileLibrary class.

As i heard enterprise library dependency injection will help for this. but i dint use the enterprise library still. could you please share the idea for this.

Answer 1

You should be interested in the great impromptu interface library (available via nuget). With its help, you can simply do a magic like:

var indian = new IndianMobileLibrary();
IMobileStore iface = indian.ActLike<IMobileStore>();
var mobile = iface.AddMobile("test");

And you have full intellisense support for ActLike returned object of course. Another magic advantage of this is you do not have to know the type of indian at all.