Interfaccia di implementazione con tipo generico meno vincolata di quella di un metodo Devo chiamare

Question

Sto implementando un'interfaccia per iniettare la logica aziendale personalizzata in un framework che utilizza Microsoft Unity. Il mio problema principale è che un l'interfaccia I bisogno di attuare definisce il metodo seguente:

T InterfaceMethod<T>(); 

T ha vincoli. Nel mio codice, ho bisogno di chiamare un metodo da una diversa libreria di terze parti, con una firma del metodo di

T AnotherMethod<T>() where T: class; 

Il tipo T è significativo alla logica del AnotherMethod. C'è un modo per chiamare AnotherMethod<T>() all'interno della mia implementazione, senza usare la reflection? Ovviamente ho bisogno di prendere azioni alternative se T è un tipo di valore. C'è forse un modo per autobox per ovviare a questo?

Answer 1

Non penso che ciò che stai cercando sia possibile senza riflessione. Nella migliore delle ipotesi, puoi semplicemente chiamare AnotherMethod<object>() e trasmettere il risultato. Ma questo funzionerebbe davvero solo se AnotherMethod 's T non è importante per i vostri scopi.

Answer 2

Non sono sicuro che sia esattamente ciò di cui hai bisogno, ma questo ti permette di chiamare AnotherMethod da InterfaceMethod senza usare il reflection. Tuttavia usa ancora un Convert.ChangeType.

L'idea è di rendere l'implementazione della classe generica con un vincolo (qui Tin). Quindi converti il ​​tipo non vincolato T di InterfaceMethod in Tin. Finalmente puoi chiamare il AnotherMethod con il tipo vincolato. Quanto segue funziona bene con le stringhe.

public interface ITest 
{ 
    T InterfaceMethod<T> (T arg); 
} 

public interface ITest2 
{ 
    U AnotherMethod<U>(U arg) where U : class; 
} 

public class Test<Tin> : ITest, ITest2 where Tin : class 
{ 
    public T InterfaceMethod<T> (T arg) 
    { 
     Tin argU = arg as Tin; 
     if (argU != null) 
     { 
      Tin resultU = AnotherMethod(argU); 
      T resultT = (T)Convert.ChangeType(resultU,typeof(T)); 
      return resultT; 
     } 
     return default(T); 
    } 

    public U AnotherMethod<U> (U arg) where U : class { return arg; } 
} 

Answer 3

Quello che gli altri stanno dicendo è che si può passare attraverso oggetto come questo:

public interface ITest 
{ 
    T InterfaceMethod<T>(T arg); 
} 

public interface IAnotherTest 
{ 
    U AnotherMethod<U>(U arg) where U : class; 
} 

public class Test : ITest 
{ 
    private IAnotherTest _ianothertest; 

    public T InterfaceMethod<T>(T arg) 
    { 
     object argU = arg as object; 
     if (argU != null) 
     { 
      object resultU = _ianothertest.AnotherMethod(argU); 
      T resultT = (T)Convert.ChangeType(resultU, typeof(T)); 
      return resultT; 
     } 
     return default(T); 
    } 
}