Hallo,

Ich habe eine Liste

markieren

Code:

class MyList<T> where T : MyObject
{
  public void Foobar()
}

Nun habe ich eine Methode mit folgender Signatur, der eine Instanz von MyList<?> übergeben wird:

markieren

Code:

void CallFooBar (object obj)
{
  // sowas will ich
  // ((MyList<???>)obj).FooBar;
}

Ich will also ein Objekt auf eine generische Liste casten, und dann eine bestimmte Methode dieser Listenklasse aufrufen. Es ist egal, von welchem Typ die Elemente sind ('T' ist also unerheblich).

Hiho,
Wenn du Kontrolle über die generische klasse hast, solltest du dort ein nicht-generisches Interface "implementieren" welches nur diese eine Methode kennt.

markieren

Code:

interface ISample
{
  void Fobar();
} 

class MyList<T> : ISample
{
   void Foobar()
  {
      ...
  }
}

markieren

Code:

 var miep = 0 new MyList<int>();
object untypedRef = miep;
var mööp = untypedRef as ISample;
if(mööp != null)
  mööp.Foobar();

Wenn du keine Kontrolle über besagte Klasse hast, musst du Reflection nehmen:

markieren

Code:

var mi = untypedRef.GetType().GetMethod("Foobar", BindingFlags.Public | BindingFlags.Instance);
mi.DynamicInvoke(untypedRef, null);

Da das ständige Nachslagen Zeit dauert, ist es dann besser, den Call in einem Delegate pro Type abzulegen:

markieren

Code:

 static class Miep
{
  static readonly IDictionary<Type, Action<Object>> FoobarCallsByType = new Dictionary<Type, Action<Object>>();

  public static void InvokeFoobar(Object callee)
  {
    var typeRef = callee.GetType();
    lock(FoobarCallsByType)
    {
      Action<Object> foobar;
      if(!FoobarCallsByType.TryGetValue(typeRef, out foobar))
      {
        var mi = typeRef.GetMethod("Foobar", BindingFlags.Public | BindingFlags.Instance);
        FoobarCallsByType.Add(typeRef,
                              foobar = (Action<Object>)Delegate.CreateDelegate(typeof(Action<Object>), mi));
      }
    }
    foobar(callee);
  }
}

Das ist zwar viel langsamer als die erste Variante (ohne Reflection), aber besser als ständig Reflection anzuwerfen ist es auf jeden Fall, gerade wenn man es öfter aufruft...