C# appel méthode générique avec la contrainte plus forte

Question

namespace Test 
{ 
    #region Not my code 
    public interface IAdditional 
    { 
    } 
    public interface ISome 
    { 
     ISomeOther<T> GetSomeother<T>() where T : class; 
    } 
    public interface ISomeOther<T> where T : class 
    { 
     void DoFoo(T obj); 
    } 
    public class AnotherClass<T> where T : class 
    { 
    } 
    public static class StaticClass 
    { 
     public static void DoBar<T>(AnotherClass<T> anotherClass, T obj) where T : class, IAdditional 
     { 
     } 
    } 
    #endregion 

    #region MyCode 
    public class SomeOtherImp<T> : ISomeOther<T> where T : class, IAdditional //Have to add IAdditional constraint to call StaticClass.DoBar 
    { 
     private AnotherClass<T> _anotherClass; 
     public void DoFoo(T obj) 
     { 
      StaticClass.DoBar<T>(_anotherClass, obj); //I do need to call StaticClass.DoBar here.... 
     } 
    } 
    public class ISomeImp : ISome 
    { 
     public ISomeOther<T> GetSomeother<T>() where T : class 
     { 
      return new SomeOtherImp<T>(); //Can't do this no IAdditional constraint on T 
     } 
    } 
    #endregion 
} 

j'ai été obligé d'ajouter icomplémentaire à SomeOtherImp pour pouvoir appeler StaticClass.DoBar Et maintenant je ne peux pas mettre en œuvre ISome avec SomeOtherImp ....

Answer 1

-vous signifie que vous voulez être en mesure d'appeler la méthode Get? Si vous pouvez modifier le ISome d'interface, essayez ceci:

public interface ISome 
{ 
    T Get<T>() where T:class, ISomeInterface 
} 

... sinon vous allez devoir utiliser la réflexion:

public class Foo : ISome 
{ 
    public T Get<T>() where T:class 
    { 
     if (!typeof(ISomeInterface).IsAssignableFrom(typeof(T))) throw new Exception(); 
     return (T)typeof(SomeStaticClass).GetMethod("Create").MakeGenericMethod(new [] {typeof(T)}).Invoke(); 
    } 
} 

Answer 2

Vous pouvez simplement faire

public class Foo : ISome 
{ 
    public T Get<T>() where T : class 
    { 
     return SomeStaticClass.Create<ISomeInterface>() as T; 
    } 
} 

Si elle renvoie null, vous avez transmis un type qui n'était pas un ISomeInterface.

Answer 3

Il semble que vous essayez d'implémenter le modèle de conception d'usine. Jetez un oeil à la partie de code suivante. J'ai enlevé l'interface des restrictions de SomeClass. Il compile et fonctionnera. A mon avis, ISome et sa classe Foo d'implémentation sont obsolètes.

public static class SomeStaticClass 
{ 
    public static T Create<T>() where T:class 
    { 
     //Replace with actual construction of T 
     return (T)(new object()); 
    } 
} 

public interface ISome 
{ 
    T Get<T>() where T : class; 
} 

public class Foo : ISome 
{ 
    public T Get<T>() where T:class 
    { 
     return SomeStaticClass.Create<T>(); 
    } 
}