Wie erzeugt man dynamisch ein generisches C#-Objekt mit Reflection?

Question

In C# habe ich das folgende Objekt:

public class Item
{ }

public class Task<T>
{ }

public class TaskA<T> : Task<T>
{ }

public class TaskB<T> : Task<T>
{ }

Ich möchte dynamisch TaskA oder TaskB mithilfe von C#-Reflection erstellen ( Aktivator.CreateInstance ). Da ich den Typ jedoch nicht im Voraus kenne, muss ich TaskA dynamisch auf der Grundlage einer Zeichenfolge wie "namespace.TaskA" oder "namespace.TaskAB" erstellen.

Answer 1

Sehen Sie sich das an Artikel und dies einfaches Beispiel . Schnelle Übersetzung desselben in Ihre Klassen ...

var d1 = typeof(Task<>);
Type[] typeArgs = { typeof(Item) };
var makeme = d1.MakeGenericType(typeArgs);
object o = Activator.CreateInstance(makeme);

Zu Ihrer Bearbeitung: Für diesen Fall können Sie Folgendes tun ...

var d1 = Type.GetType("GenericTest.TaskA`1"); // GenericTest was my namespace, add yours
Type[] typeArgs = { typeof(Item) };
var makeme = d1.MakeGenericType(typeArgs);
object o = Activator.CreateInstance(makeme);

Wie ich auf backtick1 als Namen für die generische Klasse gekommen bin, erfahren Sie unter dieser Artikel .

Hinweis: Wenn Ihre generische Klasse mehrere Typen akzeptiert, müssen Sie die Kommas einfügen, wenn Sie z. B. die Typnamen auslassen:

Type type = typeof(IReadOnlyDictionary<,>);

Answer 2

Sie wären nämlich nicht in der Lage, die letzte Zeile zu schreiben.

Aber wahrscheinlich wollen Sie das Objekt nicht einfach nur um des Erstellens willen erstellen. Wahrscheinlich wollen Sie eine Methode für Ihre neu erstellte Instanz aufrufen.

Sie benötigen dann so etwas wie eine Schnittstelle :

public interface ITask 
{
    void Process(object o);
}

public class Task<T> : ITask
{ 
   void ITask.Process(object o) 
   {
      if(o is T) // Just to be sure, and maybe throw an exception
        Process(o as T);
   }

   public void Process(T o) { }
}

und rufen Sie es mit auf:

Type d1 = Type.GetType("TaskA"); //or "TaskB"
Type[] typeArgs = { typeof(Item) };
Type makeme = d1.MakeGenericType(typeArgs);
ITask task = Activator.CreateInstance(makeme) as ITask;

// This can be Item, or any type derived from Item
task.Process(new Item());

In jedem Fall werden Sie nicht statisch auf einen Typ gecastet, den Sie vorher nicht kennen (in diesem Fall "makeme"). ITask ermöglicht es Ihnen, zu Ihrem Zieltyp zu gelangen.

Wenn Sie das nicht wollen, müssen Sie wahrscheinlich etwas genauer formulieren, was Sie damit erreichen wollen.

Answer 3

Es scheint mir, dass die letzte Zeile Ihres Beispielcodes einfach lauten sollte:

Task<Item> itsMe = o as Task<Item>;

Oder übersehe ich etwas?

Answer 4

Stellen Sie sicher, dass Sie dies aus einem guten Grund tun, eine einfache Funktion wie die folgende würde statische Typisierung ermöglichen und erlaubt Ihrer IDE Dinge wie "Find References" und Refactor -> Rename zu tun.

public Task <T> factory (String name)
{
  Task <T> result;

  if (name.CompareTo ("A") == 0)
  {
    result = new TaskA ();
  }
  else if (name.CompareTo ("B") == 0)
  {
    result = new TaskB ();
  }

  return result;
}

Answer 5

Ich weiß, dass diese Frage geklärt ist, aber für alle anderen, die es lesen: Wenn Sie alle beteiligten Typen als Zeichenketten haben, können Sie dies als Einzeiler tun:

IYourInterface o = (Activator.CreateInstance(Type.GetType("Namespace.TaskA`1[OtherNamespace.TypeParam]") as IYourInterface);

Immer, wenn ich so etwas gemacht habe, hatte ich eine Schnittstelle, die der nachfolgende Code nutzen sollte, also habe ich die erstellte Instanz auf eine Schnittstelle gecastet.