[] Rückgabewert überladen

  • C#
  • .NET (FX) 4.5–4.8

Es gibt 10 Antworten in diesem Thema. Der letzte Beitrag () ist von noelelias.

    [] Rückgabewert überladen

    Guten Abend.

    Ich suche eine Möglichkeit nur den Rückgabe-wert zu überladen.

    Hier mein Code: (type.getType() ist der Rückgabe-wert den ich haben möchte er bezieht sich auf type den ich übergebe)

    Type ist der Key in diesem Dictionary

    C#-Quellcode

    1. namespace nSpace
    2. {
    3. class nSpaceClass: Dictionary<Type,Data>
    4. {
    5. public type.getType() this[Type type]
    6. {
    7. get {
    8. return this[type];
    9. }
    10. set { //dont want to override that }
    11. }
    13. }
    14. }


    C#-Quellcode

    1. public type.getType() this[Type type]
    2. {
    3. get {
    4. return this[type];
    5. }
    6. set { //dont want to override that }
    7. }


    Edit: Vielleicht auch noch wichtig zu wissen ist das ich getType brauche da es sich um ein Interface handelt von welchem ich gerne den geCasteten Typ zurück erhaltet haben möchte

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „noelelias“ ()

    Könntest Du ein paar Beispiele geben, wie man dann Deine Klasse verwendet und was welchen Typ hat?
    Typen von Properties können auch generische Typenparameter sein, also so zum Beispiel:

    C#-Quellcode

    1. class nSpaceClass : Dictionary<Type,Data>
    2. {
    3. public Type this[Type type]
    4. {
    5. get
    6. {
    7. return this[type];
    8. }
    9. }
    10. }
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    Hey Niko herzlichen Dank für deine Antwort.

    Das Problem ist, dass ich ein Interface habe, welches eine Klasse hat die mehr Funktionen bietet als das Interface alleine.

    Ich habe mehrere Klassen, welche dieses Interface implementieren und in diesem Dictionary können all die vertreten sein. Das Problem ist nun, dass ich gerne Zugriff auf diese Zusätzlichen Funktionen haben möchte, welche wenn ich das Objekt so casten würde:

    C#-Quellcode

    1. ​
    2. public T to<T>()
    3. {
    4. return (T)Convert.ChangeType(this, typeof(T));
    5. }


    ja auch erhalten würde.
    Könnte man das aber bereits als Rückgabe-wert einstellen wäre dies um einiges angenehmer.

    Verstehe ich das richtig, dass Du sowas haben möchtest:

    C#-Quellcode

    1. // "Magische" Funktion
    2. public static Magic(t) GetMagic(Type t)
    3. {
    4. return irgendwas;
    5. }
    7. // Verwendung
    8. public class Foo
    9. {
    10. public void Frobnicate() { ... }
    11. }
    12. public class Bar
    13. {
    14. public void Barnanaize() { ... }
    15. }
    17. public static void DoIt()
    18. {
    19. // GetMagic gibt hier ein Foo-Objekt zurück, weil der Parameter ein Type-Objekt ist, das Foo repräsentiert.
    20. // Frobnicate ist eine Methode des Foo-Typs.
    21. GetMagic(typeof(Foo)).Frobnicate();
    22. // GetMagic gibt hier ein Bar-Objekt zurück, weil der Parameter ein Type-Objekt ist, das Bar repräsentiert.
    23. // Barnanaize ist eine Methode des Bar-Typs.
    24. GetMagic(typeof(Bar)).Barnanaize();
    25. }

    Sowas ist nicht mögilch. Der Compiler muss wissen, was für einen Return-Typ die GetMagic-Funktion hat. Der Typ kann nicht vom Wert eines Parameters abhängen.
    Wie würde denn dann das funktionieren?:

    C#-Quellcode

    1. public static void DoIt()
    2. {
    3. Type t;
    4. var Rnd = new Random();
    5. if (Rnd.NextDouble() < 0.5)
    6. {
    7. t = typeof(Foo);
    8. }
    9. else
    10. {
    11. t = typeof(Bar);
    12. }
    13. // Wie soll das hier überprüft werden? Woher soll der Compiler wissen, was GetMagic(t) denn jetzt zurückgibt?
    14. GetMagic(t).Frobnicate();
    15. GetMagic(t).Barnanaize();
    16. }

    Was allerdings schon gehen würde:

    C#-Quellcode

    1. public static T GetMagic<T>()
    2. {
    3. return irgendwas;
    4. // Zum Beispiel:
    5. return default(T);
    6. // Oder:
    7. var Items = new List<IRgendwas>();
    8. Items.Add(...);
    9. return Items.OfType<T>().First();
    10. }
    12. // Verwendung:
    13. public static void DoIt()
    14. {
    15. // GetMagic gibt hier ein Foo-Objekt zurück, weil das Argument für den generischen Typenparameter Foo ist.
    16. // Frobnicate ist eine Methode des Foo-Typs.
    17. GetMagic<Foo>.Frobnicate();
    18. // GetMagic gibt hier ein Bar-Objekt zurück, weil das Argument für den generischen Typenparameter Bar ist.
    19. // Barnanaize ist eine Methode des Bar-Typs.
    20. GetMagic<Bar>.Barnanaize();
    21. }

    Hier weiß der Compiler schon von vornherein, was zurückgegeben wird, und er kann dementsprechend die Methodenaufrufe korrekt kompilieren.
    Hier kann man natürlich für Foo und Bar nichts hinschreiben, was von einem Wert zur Laufzeit abhängt (weil es muss ja beim Kompilieren entschieden werden).
    Was aber funktioniert: Man kann Typenparameter von außen verwenden:

    C#-Quellcode

    1. public static void DoIt<U>()
    2. {
    3. // GetMagic gibt hier ein U-Objekt zurück, weil das Argument für den generischen Typenparameter Foo ist.
    4. // Daran kann alles aufgerufen werden, was U halt so kann. In diesem Fall kann U alles sein, deshalb sind nur die Methoden vom Object-Typ verfügbar.
    5. GetMagic<U>.ToString();
    6. }
    7. // Wenn man U aber Einschränkungen gibt, kann man mehr machen:
    8. public static void DoIt<U>() where U : Foo // U ist Foo oder ein von Foo abgeleiteter Typ
    9. {
    10. // GetMagic gibt hier ein U-Objekt zurück, weil das Argument für den generischen Typenparameter Foo ist.
    11. // Daran kann alles aufgerufen werden, was U halt so kann. In diesem Fall kann U Foo oder was abgeleitetes sein, deshalb sind die Methoden vom Foo-Typ verfügbar.
    12. GetMagic<U>.Frobnicate();
    13. }
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    ah okay danke für die lange Antwort ... tut mir leid das ich erst jetzt antworte wurde nach draussen geschleppt weil feuerwerk und so... :S

    Naja auf jeden Fall hab ich dann ne andere Ddee welche aber auch irgendwie nicht funktioniert:

    C#-Quellcode

    1. public T this<T>[Type type]
    2. {
    3. get {
    4. return this[type];
    5. }
    6. set { //dont want to override that }
    7. }


    das sollte doch eigentlich funktionieren oder?


    bzw dann so angesprochen:

    C#-Quellcode

    1. ​
    2. irgendwas<typeof(irgendeinobjekt)>[typeof(wasAuchImmer)]

    wurde schon gesagt: Den Rückgabewert einer Methode kannste nicht überladen. Ein und dieselbe Methode kann nicht verschiedene Rückgabe-Datentypen haben - basta.
    Mit Generica kannst vlt eine generische Methode schreiben, der du dann beim Aufruf immer einen TypParameter angeben musst.
    Aber wenn du eh beim Aufruf einen TypParameter angeben musst - dann kannste auch gleich casten - das ist in c# ja recht elegant zu notieren.

    Okay danke euch Ihr habt zwar das Problem nicht gelöst aber mir unglaublich geholfen :D

    hab die ULTIMATIVE Lösung ^^

    C#-Quellcode

    1. public T get<T>()
    2. {
    3. return (T)Convert.ChangeType(this[typeof(T)], typeof(T));
    4. }



    EDIT:

    hier das ganze :D


    Spoiler anzeigen

    C#-Quellcode

    1. class SOTObjectContainer : Dictionary<Type,Data>
    2. {
    3. public T get<T>()
    4. {
    5. return (T)Convert.ChangeType(this[typeof(T)], typeof(T));
    6. }
    8. }


Facebook
Telefonspende