Функция, возвращающая универсальный тип, значение которого известно только во время выполнения

Question

Мне нужно использовать универсальный интерфейс, например:

public interface IContainer<T>
{
    IEnumerable<IContent<T>> Contents { get; }
}

Объект, реализующий этот интерфейс, возвращается универсальным методом, подобным следующему:

IContainer<T> GetContainer<T>(IProperty property);

Тип T неизвестно до времени выполнения.

Используя отражение, я могу вызвать метод GetContainer<T> и получить результат.

Моя проблема в том, что я не знаю, как перечислить результат, имеющий тип Object (поэтому я не могу привести его к IEnumerable).

Я также пробовал приводить какследует, но не работает (он говорит: «Ожидается тип»):

var myContainer = genericMethodInfo.Invoke(
                           myService, 
                           new object[] { property })
    as typeof(IContainer<>).MakeGenericType(type);

, где type - тип времени выполнения, myService - служба, предоставляющая метод GetContainer<T>, и property имеет тип IProperty по мере необходимости.

ОБНОВЛЕНИЕ : см. Мое полное решение в моем блоге: http://stefanoricciardi.com/2010/02/18/generics-with-type-uknown-at-compile-time/

Answer 1

Во-первых, при касте вам нужен тип (double, int); typeof принимает аргумент типа и возвращает класс типа Type.

     object x = 0.0;
     Type t = typeof(double);
     double y = x as t; //does not compile - t is not a type - it's an instance of type Type
     double y = x as typeof(double); //same as above
     double y = x as double; //compiles - double is a type
     Type z = x as Type; //compiles - Type is a type

Во-вторых, вот пример кода:

using System;
using System.Collections.Generic;
using System.Collections;
using System.Reflection;
using System.Diagnostics;

namespace TryThis
{
   public interface IContainer<T>
   {
      IEnumerable<IContent<T>> Contents { get; }
   }
   public interface IContent<T>
   { 
      T GetMyContent(); 
   }
   public interface IProperty 
   { }

   public class Content<T> : IContent<T>
   {
      T m_content = default(T);
      public T GetMyContent() { return m_content; }
      public Content(T val) { m_content = val; }
   }

   public class Contents<T> : IEnumerable<IContent<T>>
   {
      List<IContent<T>> m_contents = new List<IContent<T>>();
      IEnumerator<IContent<T>> IEnumerable<IContent<T>>.GetEnumerator() { return m_contents.GetEnumerator(); }
      IEnumerator IEnumerable.GetEnumerator() { return m_contents.GetEnumerator(); }
      public Contents(params T[] contents) { foreach (T item in contents) m_contents.Add(new Content<T>(item)); }
   }

   public class TestGenericContent : IContainer<int>
   {
      public IContainer<int> GetContainer(IProperty property) { return this; }
      public IEnumerable<IContent<int>> Contents { get { return new Contents<int>(1, 2, 3); } }
   }

   public static class TryThisOut
   {
      static void Test2(object o)
      {
         Type t = o.GetType();
         Type tInterface = t.GetInterface("IContainer`1"); //could be null if o does not implement IContainer<T>
         Type tGenericArg = tInterface.GetGenericArguments()[0]; //extracts T from IContainer<T>
         MethodInfo info = t.GetMethod("GetContainer");
         IProperty propArg = null; //null in this example
         object oContainer = info.Invoke(o, new object[] { propArg });

         PropertyInfo prop = tInterface.GetProperty("Contents");
         object oContents = prop.GetGetMethod().Invoke(oContainer, null);
         //oContents is of type IEnumerable<IContent<T>>, which derives from IEnumerable, so we can cast
         IEnumerable enumeratedContents = oContents as IEnumerable;

         MethodInfo getContentItem = typeof(IContent<>).MakeGenericType(tGenericArg).GetMethod("GetMyContent");
         foreach (object item in enumeratedContents)
         {            
            object oContentItem = getContentItem.Invoke(item, null);
            Debug.Print("Item {0} of type {1}", oContentItem, oContentItem.GetType());
            //...
         }
      }

      public static void Test()
      {
         object o = new TestGenericContent();
         Test2(o);
      }
   }
}

Answer 2

typeof (IContainer <>). MakeGenericType (type) будет вычислять только во время выполнения, тогда как «as» должен знать тип во время компиляции.

Что я действительно не понимаю, так это комментарий: моя проблема в том, что я не знаю, как перечислить результат, имеющий тип Object (поэтому я не могу привести его к IEnumerable).

myContainer может быть объектом, но он может быть точно приведен к IEnumerable? Если не может, то не может быть перечислено.

Answer 3

Ваш тип T должен быть известен компилятору, поэтому это не будет работать. Вы можете попробовать сделать не универсальную версию вашего интерфейса, например:

public interface IContainer
{
    IEnumerable<IContent> Contents { get; }
}

public interface IContainer<T> : IContainer { ... }

Таким образом, у вас есть что-то, что вы можете использовать, и можете это использовать.

Answer 4

Извините, если я неправильно понял, у меня были проблемы с пониманием, какова ваша цель. Вы искали что-то подобное?

var myContainer = typeof(ClassWithGetContainer)
                 .GetMethod("GetContainer")
                 .MakeGenericMethod(runtimeType)
                 .Invoke(InstanceOfClassWithGetContainer, new object[] { property });

Answer 5

Я предполагаю, что ваш объект будет возвращен только как один из ограниченного числа типов, так почему бы не проверить его перед приведением, например если объект это класс?

Answer 6

Если вы думаете о переходе на .Net 4, это то, что обеспечивает тип dynamic .