Valori di ritorno del metodo di sovraccarico

Question

In C# Devo essere in grado di definire un metodo, ma è necessario restituire uno o due tipi di ritorno. Il compilatore mi dà un errore quando provo a farlo, ma perché non è abbastanza intelligente da sapere quale metodo devo chiamare?

int x = FunctionReturnsIntOrString(); 

Perché il compilatore mi impedisce di avere due funzioni con tipi di ritorno diversi?

Answer 1

Mentre può essere ovvio in questo particolare scenario, ci sono molti scenari in cui questo in realtà non è ovvio. Consente di prendere la seguente API per un esempio

class Bar { 
    public static int Foo(); 
    public static string Foo(); 
} 

Non è semplicemente possibile per il compilatore a sapere quali Foo chiamare nei seguenti scenari

void Ambiguous() { 
    Bar.Foo(); 
    object o = Bar.Foo(); 
    Dog d = (Dog)(Bar.Foo()); 
    var x = Bar.Foo(); 
    Console.WriteLine(Bar.Foo()); 
} 

Questi sono solo alcuni esempi veloci. Esistono sicuramente dei problemi inventati e malvagi.

Answer 2

Il tipo di reso non fa parte della firma del metodo, ma solo del nome e dei tipi di parametro. Per questo motivo, non è possibile avere due metodi che differiscono solo per il tipo restituito. Un modo per aggirare il problema è che il metodo restituisca un oggetto, quindi il codice chiamante deve eseguirlo su un int o una stringa.

Tuttavia, potrebbe essere preferibile creare due metodi diversi oppure creare una classe da restituire dal metodo che può contenere una stringa int o una stringa.

Answer 3

Hai pensato di utilizzare i generici per restituire il tipo corretto.

public T SomeFunction<T>() 
{ 
    return T 
} 

int x = SomeFunction<int>(); 
string y = SomeFunction<string>(); 

Nota: Questo codice non è stato testato

Answer 4

In C# non c'è nessun tipo di ritorno overridin, IL supporta questo tipo di rilevante, ma C# non ... ancora.

Answer 5

Perché a volte davvero non si può dire che uno dovrebbe quindi utilizzare (il tuo esempio potrebbe, ma non tutti i casi sono che chiara):

void SomeMethod(int x) { ... } 
void SomeMethod(string x) { ... } 

In questo contesto, se si chiama SomeMethod(FunctionReturnsIntOrString()) cosa dovrebbe fare il compilatore?

Answer 6

Le funzioni che differiscono solo per i valori di ritorno non sono valide per il sovraccarico.

int x = FunctionReturnsIntOrString(); 
double y = FunctionReturnsIntOrString(); 

Nel caso compilatore sopra può identificare le funzioni corrette ma considerare i casi in cui restituiscono valori non sono specificate, è ambigua.

FunctionReturnsIntOrString(); //int version 
FunctionReturnsIntOrString(); //double version 

Il compilatore non è in grado di risolvere i metodi sovraccaricati qui.

Answer 7

Penso che si desidera a riconsiderare seriamente quello che stai facendo e come, ma si può fare questo:

int i = FunctionReturnsIntOrString<int>(); 
string j = FunctionReturnsIntOrString<string>(); 

implementando in questo modo:

private T FunctionReturnsIntOrString<T>() 
{ 
    int val = 1; 
    if (typeof(T) == typeof(string) || typeof(T) == typeof(int)) 
    { 
     return (T)(object)val; 
    } 
    else 
    { 
     throw new ArgumentException("or some other exception type"); 
    } 
} 

ma ci sono talmente tante ragioni per non farlo

Answer 8

Dalla ultimo paragrafo della sezione 1.6.6 della C# 3.0 language specification:

The signature of a method must be unique in the class in which the method is declared. The signature of a method consists of the name of the method, the number of type parameters and the number, modifiers, and types of its parameters. The signature of a method does not include the return type.

In IL due metodi possono differire a seconda della tipologia di ritorno da solo, ma al di fuori di riflessione non ci sono mezzi per chiamare un metodo che differisce solo essere di ritorno.

Answer 9

Non è inoltre necessario assegnare un valore a un metodo chiamato. Per esempio:

int FunctionReturnsIntOrString() {return 0;} 
string FunctionReturnsIntOrString() {return "some string";} 

//some code 
//... 

int integer = FunctionReturnsIntOrString(); //It probably could have figured this one out 

FunctionReturnsIntOrString(); //this is valid, which method would it call? 

Answer 10

è possibile ottenere la sintassi hai mostrato in questione, ma è necessario impegnarsi in abbastanza una buona quantità di intelligenza per arrivarci.

Impostiamo il problema un po 'più concretamente. Il punto chiave qui, penso, è la sintassi. Vogliamo che questo:

int intValue = GetData(); 
string stringValue = GetData(); 
DateTime[] dateTimeArrayValue = GetData(); 

Tuttavia, non vogliamo far funzionare tutto questo:

double doubleValue = GetData(); 
DateTime? nullableDateTimeValue = GetData(); 

Al fine di raggiungere questo obiettivo, dobbiamo usare un oggetto intermediario il valore restituito da GetData(), la cui definizione assomiglia a questo:

public class Data 
{ 
    public int IntData { get; set; } 
    public string StringData { get; set; } 
    public DateTime[] DataTimeArrayData { get; set; } 

    public MultiReturnValueHelper<int, string, DateTime[]> GetData() 
    { 
     return new MultiReturnValueHelper<int, string, DateTime[]>(
      this.IntData, 
      this.StringData, 
      this.DataTimeArrayData); 
    } 
} 

La tua implementazione, ovviamente, sarebbe molto diversa, ma lo farà. Ora definiamo MultiReturnValueHelper.

public class MultiReturnValueHelper<T1, T2, T3> : Tuple<T1, T2, T3> 
{ 
    internal MultiReturnValueHelper(T1 item1, T2 item2, T3 item3) 
     : base(item1, item2, item3) 
    { 
    } 

    public static implicit operator T1(MultiReturnValueHelper<T1, T2, T3> source) 
    { 
     return source.Item1; 
    } 

    public static implicit operator T2(MultiReturnValueHelper<T1, T2, T3> source) 
    { 
     return source.Item2; 
    } 

    public static implicit operator T3(MultiReturnValueHelper<T1, T2, T3> source) 
    { 
     return source.Item3; 
    } 
} 

Ripetere questa definizione per T1, T2, T3, ecc per il caso generico.

È anche possibile associare l'helper del valore di ritorno molto vicino alla classe o al metodo che lo restituisce, consentendo di creare questo stesso tipo di effetto per gli indicizzatori, in cui è possibile ottenere e assegnare un insieme discreto di tipi. È lì che l'ho trovato più utile.

Un'altra applicazione è quello di consentire sintassi simile alla seguente:

data["Hello"] = "World"; 
data["infamy"] = new DateTime(1941, 12, 7); 
data[42] = "Life, the universe, and everything"; 

L'esatto meccanismo per raggiungere questo sintassi è lasciato come esercizio al lettore.

Per una soluzione più generale a questo problema (che è, penso, lo stesso di un problema di unione discriminato), vedere my answer to that question.