Methode mit Kombinationen verschiedener Argumenttypen

Question

Ich frage mich, ob es möglich ist, eine C# -Methode zu schreiben, die eine Kombination verschiedener Argumenttypen verwenden kann.

Zum Beispiel würde diese Methode vier überladene Methoden zu einer kombinieren.

Answer 1

Nein, Sie können keine einzelne Methodenüberladung erstellen, die einen von zwei festen Typen für einen bestimmten Parameter akzeptiert.

Das Beste, was Sie (während noch mehr Überlastungen zu vermeiden) tun können, ist eine neue Art zu schaffen, mit dem Sie eine Instanz durch einen von zwei verschiedenen Arten schaffen könnten, und eine Instanz von dass zu akzeptieren.

public class MyJSON 
{ 
    public MyJSON(JObject json) 
    { 
     FirstOption = json; 
     FirstOptionValid = true; 
    } 
    public MyJSON(File json) 
    { 
     SecondOption = json; 
     SecondOptionValid = true; 
    } 
    public JObject FirstOption { get; private set; } 
    public bool FirstOptionValid { get; private set; } 
    public File SecondOption { get; private set; } 
    public bool SecondOptionValid { get; private set; } 

    public static implicit operator MyJSON(File json) 
    { 
     return new MyJSON(json); 
    } 
    public static implicit operator MyJSON(JObject json) 
    { 
     return new MyJSON(json); 
    } 
} 

Sie könnten sogar implizite Konvertierungen von JObject und File-MyJSON erstellen, so dass ein Benutzer tatsächlich ein JObject oder File Objekt MyMethod, ohne auch nur, um überhaupt einen Vermittler Objekt explizit zu konstruieren passieren kann.

In der Tat, es ist eigentlich sehr einfach durch Verwendung von Generika dies für jede festgelegte Anzahl von Arten zu verallgemeinern:

public class Option<T1, T2> 
{ 
    public Option(T1 value) 
    { 
     FirstOption = value; 
     FirstOptionValid = true; 
    } 
    public Option(T2 value) 
    { 
     SecondOption = value; 
     SecondOptionValid = true; 
    } 
    public T1 FirstOption { get; private set; } 
    public bool FirstOptionValid { get; private set; } 
    public T2 SecondOption { get; private set; } 
    public bool SecondOptionValid { get; private set; } 

    public static implicit operator Option<T1, T2>(T2 value) 
    { 
     return new Option<T1, T2>(value); 
    } 
    public static implicit operator Option<T1, T2>(T1 value) 
    { 
     return new Option<T1, T2>(value); 
    } 
} 

Wir haben jetzt Ihre Methode als schreiben:

public static void MyMethod(Option<JObject, File> json1, Option<JObject, File> json2) 

Answer 2

Zwei mögliche, aber schmutzige Lösungen:

One (Annahme Objekte und Typprüfung)

public static void MyMethod(object one, object two) 
{ 
    if(one is JObject) // handle 
    else if(one is File) // handle 
    else throw SomeException(); 
    ... 

gleiche gilt für die zweite param

Zwei: optional params

public static void MyMethod(JObject jone = null, File fone = null, 
    JObject jtwo = null, File ftwo = null) 
{ 
    if(jone == null && fone == null) 
     throw SomeException(); 
    else 
     // use set values and do stuff 
    ... 

Answer 3

Siehe Code unten:

interface IDo { 
    void DoSomething(); 
} 

class MyFile : File, IDo { 
    void DoSomething() { 
     // blah blah 
    } 
} 

class MyJObject : JObject, IDo { 
    void DoSomething() { 
     // blah blah 
    } 
} 

public static void MyMethod<T1, T2>(T1 one, T2 two) 
    where T1 : IDo 
    where T2 : IDo 
{ 
    one.DoSomething(); 
    two.DoSomething(); 
} 

Wenn Datei- und/oder JObject versiegelt sind, dann Haltung anstelle von Vererbung :

class MyFile : IDo { 
    File file; 
    void DoSomething() { 
     // blah blah 
    } 
} 

class MyJObject : IDo { 
    JObject jObject; 
    void DoSomething() { 
     // blah blah 
    } 
}