Déléguer le paramètre Method de IEnumerable <T> au type spécifique

Question

J'ai trouvé cette question: Is it possible to specify a generic constraint for a type parameter to be convertible FROM another type? Je suis à la recherche d'un moyen plus intelligent.

Class A { 
    public A(string){} 
} 

Class foo 
{ 
    private List<A> content = new List<A>(); 

    public void Add(A a){ 
     content.Add(a); 
    } 
    public void Add(string str){ 
     content.Add(new A(str)); 
    } 
    public void AddRange<T>(IEnumerable<T> iterable) // where T : ??? 
    { 
     foreach(T t in iterable) 
      content.Add((A)t); //Error 
    } 
} 

L'erreur est:

Cannot convert type 'T' to 'A'

Question: une expression where T : ? Exists comme "convertable"?

Mise à jour: J'ai deux méthodes: Add(A) surcharges et Add(string) i essayer actuellement de convertir T à A. Mais mon principal problème est que je veux utiliser différentes méthodes Add relatives à T. Ce que je besoin est quelque chose comme:

public void AddRange<T>(IEnumerable<T> iterable) where T : Add(T) 
{ 
    foreach (T t in iterable) 
     this.Add(t); 
} 

Answer 1

Je pense que ce que vous cherchez contrainte de saisir qui doit avoir explicitement opérateur T, mais étant donné que la spécification dit:

conversion-operator-declarator: 
    implicit operator type ( type identifier ) 
    explicit operator type ( type identifier )

WHI ch signifie généralement que vous ne pouvez pas avoir un opérateur explicite et implicite générique, je ne pense pas que ce soit possible.

Vous pouvez faire votre cas possible si vous avez des types concrets mais comme ceci:

public class A 
{ 
    public static explicit operator B(A a) 
    { 
     return new B(); 
    } 
} 

public class B { } 

public class Convert 
{ 
    public static T To<T>(dynamic obj) 
    { 
     return (T) obj; 
    } 
} 

class Foo 
{ 
    private List<A> content = new List<A>(); 
    public void AddRange<T>(IEnumerable<T> iterable) where T : B 
    { 
     foreach (T t in iterable) 
      content.Add(Convert.To<A>(t)); // This will invoke the implicit operator defined in A 
    } 
} 

Peut-être que vous pouvez abstraites vos T génériques types être de type de type B et limiter comme ça, ou peut-être vous définissez tous les opérateurs implicites des types qui veulent que vous convertissiez en A dans le type T.

Answer 2

Si vous voulez T être le type A ou toute utilisation de type dérivé where T : A.

EDIT (après votre commentaire):

Si vous voulez T être A ou String vous ne pouvez pas faire quelque chose comme ceci: where T : A, String. Vous pouvez limiter la classe, l'interface, le type, mais il n'est pas possible d'effectuer l'opération OR. Donc, dans votre cas si vous voulez seulement String ou A alors vous devriez utiliser différentes implémentations. Si vous voulez une classe - where T : class

Answer 3

Vous pouvez utiliser A au lieu de T:

public void Add(IEnumerable<A> iterable) 
{ 
    foreach(A t in iterable) 
     content.Add(t); 
} 

et:

public void Add(IEnumerable<string> iterable) 
{ 
    foreach(string t in iterable) 
     content.Add(t); 
}