如何在控制台程序和DLL之间使用通用的类/接口？

Question

I"m developing an application (.NET framework + C#) where I have a bunch of DLLs developed and sent to me by clients, which I put in a folder and read from my main console program. For the sake of simplicity, I'll explain it using a rather abstract example which properly represent my original problem.

I want the DLLs to have one function, which creates and returns an object of the data type "PersonData". PersonData has three variables, namely, personName, personAge, and personNationality. The data type PersonData, which is a structure, look like this:

namespace CommonStuff
{
    public static class Common
    {
        public struct PersonData
        {
            string name;
            int age;
            string nationality;

            // Properties go here.

            // Constructor goes here.
        }
    }
}

The above is saved in a file called Common.cs.

Then I have an interface, which is saved in IPerson.cs which looks like this:

namespace CommonStuff
{
    public interface IPerson
    {
        Common.PersonData GetPerson();
    }
}

Basically, my interface has one function that returns an object of type PersonData.

I want to distribute these two files to my clients, so they can code their DLLs based on these. So one client would create a DLL which returns a PersonData object, with nationality set to "American", and another would return a PersonData object with nationality set to Japanese. For instance, a DLL would look like this:

namespace CreateAmerican
{
    public class CreateAmerican : CommonStuff.IPerson
    {
        public CommonStuff.Common.PersonData GetPerson()
        {
            CommonStuff.Common.PersonData person = new CommonStuff.Common.PersonData();
            person.Name = "Jennifer";
            person.Age = 23;
            person.Nationality = "American";
            return person;
        }
    }
}

Then, in my Main program, I want to read those DLLs - which I've put in a folder in advance - at runtime, and get the object returned by GetPerson() in each DLL. That means, I want to have the same two IPerson.cs and Common.cs files included in my Main program, then create an object of type PersonData, and get the return value of GetPerson() method into it, and then do some work with it. My main looks like this:

static void Main(string[] args)
{
    List<object> dllResultList = null;
    LoadDllClassesToList(Directory.GetCurrentDirectory(), out dllResultList);

    foreach(object item in dllResultList)
    {
        CommonStuff.Common.PersonData person = (CommonStuff.Common.PersonData)item;
        Console.WriteLine(String.Format("Name : {0}, Age : {1}, Nationality : {2}", person.Name, person.Age, person.Nationality));
    }
    Console.ReadLine();
}

The LoadDllClassesToList() method reads the DLLs at runtime, and put the return value of GetPerson() method into a list of "object" type.

When I run the program, everything works fine until I reach the line:

CommonStuff.Common.PersonData person = (CommonStuff.Common.PersonData)item;

There, it throws an exception as follows:

An unhandled exception of type 'System.InvalidCastException' occurred in MainProgram.exe

From what I understand, even though I have the same data type PersonData in my main program, the program sees it as something different to the PersonData object that my DLL returns.

So here's my question; how would I use an interface like IPerson, and a common data type such as PersonData, which both my DLLs and main program can share? My actual program has more complex data types, so I can't return something like an array of standard data types. I need to be able to return a user-defined data type like PersonData.

Thanks in advance!

Answer 1

Provide assembly instead of source for shared classes and interfaces. Clients and you will link to the same assembly and code will work fine.

Alternatively you can give up type safety and use reflection or dynamic to use client's objects.

Answer 2

The best option would be to set your interfaces in separated library, which could have been used by Clients.

If sharing of your assembly is impossible because of any reasons, I'm affraid the only option is using of dynamic type or reflection .

dynamic person = item;

Same structure of class or interface like in 3rd party DLL is still different class or interface, as long as those classes/interfaces coming from different assembly.

You may like to give a try to AutoMapper which could later translate type to your local one. here