C# restituisce diversi tipi?

Question

Ho qualcosa di simile:

public [What Here?] GetAnything() 
{ 
    Hello hello = new Hello(); 
    Computer computer = new Computer(); 
    Radio radio = new Radio(); 

    return radio; or return computer; or return hello //should be possible?!  
} 

Ho un metodo e questo metodo mi restituisce a volte diversi tipi di valori (classi).

Come posso farlo comunque e naturalmente in seguito per lavorare con le variabili, b.e radio.Play(); e così lontano?

Devo usare i farmaci generici? Come?

Answer 1

Se non esiste un tipo di base o un'interfaccia comune, quindi public object GetAnything() {...} - ma di solito sarebbe preferibile avere una sorta di astrazione come un'interfaccia comune. Ad esempio se Hello, Computer e Radio sono tutti implementati IFoo, quindi è possibile restituire uno IFoo.

Answer 2

È possibile impostare il tipo di ritorno come una superclasse delle tre classi (definite dall'utente o utilizzate semplicemente object). Quindi è possibile restituire uno qualsiasi di questi oggetti, ma sarà necessario eseguire il cast di nuovo al tipo corretto quando si ottiene il risultato. Come:

public object GetAnything() 
{ 
    Hello hello = new Hello(); 
    Computer computer = new Computer(); 
    Radio radio = new Radio(); 

    return radio; or return computer; or return hello //should be possible?!  
} 

Poi:

Hello hello = (Hello)getAnything(); 

Answer 3

Se si può fare una classe astratta per tutte le possibilità poi che è altamente raccomandato:

public Hardware GetAnything() 
{ 
    Computer computer = new Computer(); 

    return computer;  
} 

abstract Hardware { 

} 

class Computer : Hardware { 

} 

o un'interfaccia:

interface IHardware { 

} 

class Computer : IHardware { 

} 

Se può essere qualsiasi cosa il n puoi considerare di usare "oggetto" come tipo di ritorno, perché ogni classe deriva dall'oggetto.

public object GetAnything() 
{ 
    Hello hello = new Hello(); 

    return hello;  
} 

Answer 4

Ecco come si potrebbe fare con i generici:

public T GetAnything<T>() 
{ 
    T t = //Code to create instance 

    return t; 
} 

ma dovreste sapere che tipo si voleva tornato in fase di progettazione. E ciò significherebbe che puoi semplicemente chiamare un metodo diverso per ogni creazione ...

Answer 5

Potrebbe essere necessario il tipo "dinamico"?

public dynamic GetAnything() 
{ 
    Hello hello = new Hello(); 
    Computer computer = new Computer(); 
    Radio radio = new Radio(); 

    return /*what boject you needed*/ ;`enter code here` 
} 

Answer 6

La risposta di Marc dovrebbe essere quella corretta, ma in .NET 4 non si poteva andare anche con il tipo dinamico.

Questo dovrebbe essere usato solo se non si ha il controllo sulle classi che si ritornano e non ci sono antenati comuni (di solito con interop) e solo se non si usa la dinamica è molto più doloroso che usare (gettare ogni oggetto in ogni passaggio :)).

Pochi post sul blog cercando di spiegare quando usare dinamica: http://blogs.msdn.com/b/csharpfaq/archive/tags/dynamic/

public dynamic GetSomething() 
{ 
    Hello hello = new Hello(); 
    Computer computer = new Computer(); 
    Radio radio = new Radio(); 
    return // anyobject 

} 

Answer 7

avete alcune opzioni a seconda del motivo si desidera restituire tipi diversi.

a) È possibile restituire un oggetto e il chiamante può eseguire il cast (eventualmente dopo i controlli di tipo) su ciò che desidera. Ciò significa ovviamente che si perdono molti vantaggi della digitazione statica.

b) Se i tipi restituiti hanno tutti un "requisito" in comune, è possibile utilizzare generics with constriants.

c) Creare un'interfaccia comune tra tutti i tipi di restituzione possibili e quindi restituire l'interfaccia.

d) Passare a F # e utilizzare pattern matching e unioni discriminate. (Mi dispiace, un po 'di lingua sotto controllo lì!)

Answer 8

Lascia che il metodo restituisca un oggetto da una comune base o interfaccia.

public class TV:IMediaPlayer 
{ 
    void Play(){}; 
} 

public class Radio:IMediaPlayer 
{ 
    void Play(){}; 
} 

public interface IMediaPlayer 
{ 
    void Play(): 
} 

public class Test 
{ 
    public void Main() 
    { 
    IMediaPlayer player = GetMediaPlayer(); 
    player.Play(); 
    } 


    private IMediaPlayer GetMediaPlayer() 
    { 
    if(...) 
     return new TV(); 
    else 
     return new Radio(); 
    } 
} 

Answer 9

Si potrebbe semplicemente restituire un oggetto poiché tutti i tipi discendono da Object.

public Object GetAnything() 
{ 
    Hello hello = new Hello(); 
    Computer computer = new Computer(); 
    Radio radio = new Radio(); 

    return radio; or return computer; or return hello //should be possible?!  
} 

Si potrebbe quindi lanciare al suo tipo rilevanti:

Hello hello = (Hello)GetAnything(); 

Se non sapevano cosa del tipo sarebbe stata allora si potrebbe utilizzare la parola chiave is.

Object obj = GetAnything(); 
if (obj is Hello) { 
    // Do something 
} 

Detto questo, sarei riluttante a scrivere un codice del genere. Sarebbe molto meglio avere un'interfaccia che è implementata da ciascuna delle tue classi.

public ISpeak GetAnything() 
{ 
    Hello hello = new Hello(); 
    Computer computer = new Computer(); 
    Radio radio = new Radio(); 

    return radio; or return computer; or return hello //should be possible?!  
} 

interface ISpeak 
{ 
    void Speak(); 
} 

e hanno ciascuna delle classi implementare l'interfaccia:

public class Hello : ISpeak 
{ 
    void Speak() { 
     Console.WriteLine("Hello"); 
    } 
} 

È quindi possibile fare qualcosa di simile:

GetAnything().Speak(); 

Answer 10

soluzione di Rick è il modo 'migliore' per andare in più casi. A volte, quando non è disponibile, si desidera utilizzare l'oggetto come tipo di base. E si potrebbe utilizzare il metodo come questo:

public object GetAnything() 
{ 
    Hello hello = new Hello(); 
    Computer computer = new Computer(); 
    Radio radio = new Radio(); 

    return hello; // or computer or radio 
} 

Per usarlo, si vuole utilizzare l'operatore as, in questo modo:

public void TestMethod() 
{ 
    object anything = GetAnything(); 
    var hello = anything as Hello; 
    var computer = anything as Computer; 
    var radio = anything as Radio; 

    if (hello != null) 
    { 
     // GetAnything() returned a hello 
    } 
    else if (computer != null) 
    { 
     // GetAnything() returned a computer 
    } 
    else if (radio != null) 
    { 
     // GetAnything() returned a radio 
    } 
    else 
    { 
     // GetAnything() returned... well anything :D 
    } 
} 

Nel tuo caso si desidera chiamare un metodo play. Quindi questo sembra più appropriato:

interface IPlayable 
{ 
    void Play(); 
} 

class Radio : IPlayable 
{ 
    public void Play() { /* Play radio */ } 
} 

class Hello : IPlayable 
{ 
    public void Play() { /* Say hello */ } 
} 

class Computer : IPlayable 
{ 
    public void Play() { /* beep beep */ } 
} 

public IPlayable GetAnything() 
{ 
    Hello hello = new Hello(); 
    Computer computer = new Computer(); 
    Radio radio = new Radio(); 

    return hello; // or computer or radio 
} 

Answer 11

È possibile utilizzare la classe esterna, impostare i tipi di proprietà come desiderato, quindi utilizzarli nella funzione.

public class MultipleOpjects 
{ 
    private List<string> _ObjectOne; 
    public List<string> ObjectOne { 
     get { return _ObjectOne; } 
     set { _ObjectOne = value; } 
    } 
    private List<object> _ObjectTwo; 
    public List<object> ObjectTwo { 
     get { return _ObjectTwo; } 
     set { _ObjectTwo = value; } 
    } 
    private object _ObjectThree; 
    public object ObjectThree { 
     get { return _ObjectThree; } 
     set { _ObjectThree = value; } 
    } 
} 
public MultipleOpjects GetAnything() 
{ 
    MultipleOpjects Vrble = new MultipleOpjects(); 
    Vrble.ObjectOne = SomeThing1; 
    Vrble.ObjectTwo = SomeThing2; 
    Vrble.ObjectThree = SomeThing3; 

    return Vrble;  
} 

Answer 12

costruire sulla risposta da @RQDQ utilizzando farmaci generici, è possibile combinare questo con Func<TResult> (o qualche variazione) e delegare la responsabilità al chiamante:

public T GetAnything<T>(Func<T> createInstanceOfT) 
{ 
    //do whatever 

    return createInstanceOfT(); 
} 

allora si può fare qualcosa di simile:

Computer comp = GetAnything(() => new Computer()); 
Radio rad = GetAnything(() => new Radio()); 

Answer 13

ho un'idea per la restituzione di più tipi .......

public object GetAnything(object o) 
{ 
    Hello hello = new Hello(); 
    Computer computer = new Computer(); 
    Radio radio = new Radio(); 
    if(o == Hello){return hello;} 
    if(o == Computer {return computer;} 
    if(o == Radio) {return radio;} 
} 

Answer 14

Definire un singolo tipo per tutti non è sempre possibile. Anche se quando è possibile, l'implementazione è raramente facile. Preferisco usare i parametri out. L'unica avvertenza è che è necessario conoscere tutti i tipi restituiti in avanzato:

public void GetAnything(out Hello h, out Computer c, out Radio r) 
{ 
    /// I suggest to: 
    h = null; 
    c = null; 
    r = null; 
    // first, 

    // Then do whatever you have to do: 
    Hello hello = new Hello(); 
    Computer computer = new Computer(); 
    Radio radio = new Radio(); 
} 

Il tipo di ritorno può essere una void, o qualcos'altro, come bool un int o un predefinito enum che può aiutare a controllare per le eccezioni o diversi casi in cui viene utilizzato il metodo.

Answer 15

utilizzare la parola chiave dynamic come tipo restituito.

private dynamic getValuesD<T>() 
    { 
     if (typeof(T) == typeof(int)) 
     { 
      return 0; 
     } 
     else if (typeof(T) == typeof(string)) 
     { 
      return ""; 
     } 
     else if (typeof(T) == typeof(double)) 
     { 
      return 0; 
     } 
     else 
     { 
      return false; 
     } 
    } 

     int res = getValuesD<int>(); 
     string res1 = getValuesD<string>(); 
     double res2 = getValuesD<double>(); 
     bool res3 = getValuesD<bool>(); 

saluti,

Abhijit