是否可以从采用字符串的工厂方法实例化泛型类型？

Question

I am writing an application that consists of an Importer and a Processor. The Importer will take a type and instantiate a List<> of that type. The Processor needs to take that returned list.

For example, I want to call Importer<Organisation>.GetObjects() and have it return a List<Organisation> . Then pass the List to my OrganisationProcessor.

Similarly, I want to call Importer<Address>.GetObjects() and have it return a List<Address> . Then pass the List to my AddressProcessor.

I would like to put the creation of the Importer<> and *Processor into a factory. I have removed all code and produced an uncontaminated sample below. My attempts have been met with no success and may be down to topics like variance which I don't fully understand.

class Program
{
    static void Main(string[] args)
    {
        //What I am currently doing
        Importer<Organisation> importer = new Importer<Organisation>();
        List<Organisation> list = importer.GetObjects();
        OrganisationProcessor processor = new OrganisationProcessor();
        processor.Process(list);


        //***What I want to do*** 
        string name = "Organisation";  //Passed in from external source
        var importer = Factory.GetImporter(name);  //returns Importer<Organisation>
        var processor = Factory.GetProcessor(name); //returns OrganisationProcessor
        processor.Process(importer.GetObjects()); //.Process takes List<Organisation>
    }
}

public class Importer<T>
{
    public List<T> GetObjects()
    {
        return new List<T>();
    }
}


public class OrganisationProcessor
{
    public void Process(List<Organisation> objects)
    {
        //Do something
    }
}

public class AddressProcessor
{
    public void Process(List<Address> objects)
    {
        //Do something
    }
}

public class Organisation { }

public class Address { }

Answer 1

This should do the trick, note that your initial intention hasn't been changed, which is surprise even for me. Also note that you have to add namespaces to type literals in Factory. Using LINQ to find types is more flexible, but it's much readable to enter path to type with namespace in one line. I have executed this sample on project without namespaces and it worked fine.

void Main()
{
    string name = "Organisation";  //Passed in from external source
    var importer = Factory.GetImporter(name);  //returns Importer<Organisation>
    var processor = Factory.GetProcessor(name); //returns OrganisationProcessor
    processor.Process(importer.GetObjects()); //.Process takes List<Organisation>
    Console.WriteLine (importer.GetObjects().GetType());
}

public static class Factory
{
    public static Importer GetImporter(string name)
    {           
            //add namespace to name here
        var desiredType = Type.GetType(name);

        return new Importer(desiredType);
    }
    public static Processor GetProcessor(string name)
    {
            //add namespace to name here
        var desiredType = Type.GetType(name+"Processor");

        return (Processor)Activator.CreateInstance(desiredType);
    }
}

public class Importer 
{
    Type _typeOfEntities;

    public Importer(Type typeOfEntities)
    {
        _typeOfEntities = typeOfEntities;
    }
    public IList GetObjects()
    {
        Type generic = typeof(List<>);

        Type constructed = generic.MakeGenericType(new Type[] {_typeOfEntities});

        return (IList)Activator.CreateInstance(constructed);
    }
}
public interface Processor
{
    void Process(IList objects);
}

public class OrganisationProcessor : Processor
{
    public void Process(IList objects)
    {
        var desiredTypedObject = objects as List<Organisation>;
        if(desiredTypedObject != null)
        ProcessImp(desiredTypedObject);
    }
    private void ProcessImp(List<Organisation> objects)
    {
        Console.WriteLine ("processing Organisation");
    }
}

public class AddressProcessor
{
    public void Process(List<Address> objects)
    {
        //Do something by analogy
    }
}

public class Organisation { }

public class Address { }

Answer 2

The return types of the GetImporter and GetProcessor will have to be object . There is no way to have those methods use the run-time information in a string and return an object whose type is known at compile-time.

Your sample will have to look something like this:

string name = "Organisation";  //Passed in from external source
dynamic importer = Factory.GetImporter(name);  //returns Importer<Organisation>
dynamic processor = Factory.GetProcessor(name); //returns OrganisationProcessor
processor.Process(importer.GetObjects()); //.Process takes List<Organisation>

Second, the GetImporter method will be something like

public static object GetImporter(string name)
{
    Type type = Type.GetType(name);
    Type importerType = typeof(Importer<>).MakeGenericType(type);
    return Activator.CreateInstance(importerType);
}

Last, the GetProcessor will be something like

public static object GetProcessor(string name)
{
    Type type = Type.GetType(name + "Processor");
    return Activator.CreateInstance(type);
}

Note that the string names passed in must be the full name of the type including namespace, and this is restricted to types (Organization, Address) that are in the same assembly as those methods. If you want to use types in other assemblies, you must work with the assembly qualified name , but then that string concatenation to produce the name of the processor type isn't going to work.

I would probably use a custom attribute on the processor types and then find all types in the assembly with the custom attribute instead of the simple string concatenation to produce the type name above. The above scheme is brittle and could easily break if some of the types are renamed.

Answer 3

Yes, it's possible. Assumption is your classes are in the same assembly, this code below is not optimized much but will solve the problem:

public static class Factory
{
    public static object GetImporter(string name)
    {
        var assembly = Assembly.GetExecutingAssembly();

        var type = assembly.GetTypes().Single(t => t.Name.Equals(name));
        var importType = typeof (Importer<>).MakeGenericType(type);

        return Activator.CreateInstance(importType);

    }

    public static object GetProcessor(string name)
    {
        var assembly = Assembly.GetExecutingAssembly();
        var type = assembly.GetTypes()
               .Single(t => t.Name.Equals(string.Format("{0}Processor", name)));

        return Activator.CreateInstance(type);
    }
}

So, you use Factory above like below:

dynamic importer = Factory.GetImporter(name);
dynamic processor = Factory.GetProcessor(name);
processor.Process(importer.GetObjects());

Answer 4

Within your Factory the Get... Methodes could use the Activator.CreateInstance Method . This Method can create Instances of a class by assamby-name and type-name with additional parameters.