Firma del metodo generico e firma standard identica

Question

Si supponga di avere una classe che ha metodi che utilizzano T. E si hanno anche metodi standard con lo stesso nome.

Cosa succede se T è dello stesso tipo del metodo standard? Il metodo standard è chiamato.

C'è un modo per costringerlo a chiamare comunque il metodo T?

utilizzando Sistema;

namespace ConsoleApplication3 
{ 
class Program 
{ 
    static void Main() 
    { 
     Generics<Int32> anInt = new Generics<Int32>(4); 
     Generics<String> aString = new Generics<String>("test"); 
    } 
} 

public class Generics<T> 
{ 
    public T Member; 

    public String ErrorMessage; 

    public Generics(T member) 
    { 
     this.Member = member; 
    } 

    public Generics(String errorMessage) 
    { 
     this.ErrorMessage = errorMessage; 
    } 
} 
} 

Answer 1

Siamo spiacenti, non c'è.

La soluzione più semplice consiste nell'utilizzare due diversi nomi di metodo per indicare la differenza di comportamento. Poiché i nomi dei metodi in questione sono costruttori, non si ha il controllo sui nomi, quindi è necessario modificare almeno uno di essi in un metodo normale. Ad esempio:

public class Generics<T> 
{ 
    public T Member; 

    public String ErrorMessage; 

    public Generics(T member) 
    { 
     this.Member = member; 
    } 

    private Generics() 
    { 
     // empty constructor just to allow the class to create itself internally 
    } 

    public static Generics<T> FromError(String errorMessage) 
    { 
     return new Generics<T> { ErrorMessage = errorMessage }; 
    } 
} 

Personalmente cambierebbero entrambe costruttori come metodi statici, in modo che la differenza di comportamento è assolutamente chiaro per l'utente. Tuttavia, se cambi solo un costruttore, fallo l'errore uno.

Answer 2

Ok, farò il mio commento in una risposta.

Prima di tutto, NON farlo. NON. Vuoi che gli umani siano in grado di leggere il tuo codice, non solo i computer. (Lì, ho fatto il mio dovere come membro dello spazio programmatore C#)

Secondo.

Come descritto here:

Se si progetta il codice in modo che il compilatore non può dire quando è la compilazione di quale tipo si sta chiamando con, è possibile forzarlo ad utilizzare il metodo generico.

static Generics<T> Test<T> (T parameterToTest) { 
    return new Generics<T>(parameterToTest); 
} 

static void Main() 
{ 
    Generics<Int32> anInt = Test<Int32>(4); 
    Generics<String> aString = Test<String>("test"); 
} 

Answer 3

ho semplicemente fatto questo (per questo caso specifico):

ho aggiunto un costruttore protetto vuoto per Generics

protected Generics() { } 

E poi ho derivato per il caso specifico di T = stringa

public class GenericsOfString : Generics<String> 
    { 
     public GenericsOfString(String text, Boolean isErrorMessage) 
     { 
      if (isErrorMessage) 
      { 
       this.ErrorMessage = text; 
      } 
      else 
      { 
       this.Member = text; 
      } 
     } 
    }