(Implizite) Typ-Konvertierung Enum <-> bool

  • C#

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

    (Implizite) Typ-Konvertierung Enum <-> bool

    Ich hab hier eine Bibliothek, die ursprünglich native vorliegt und für die passende .NET-Wrapper existieren. Die Wrapper-Klassen stehen zwar als Quellcode zur Verfügung, aber es gilt die Vorgabe, an diesen Quelltexten nichts zu ändern, damit Updates der Bibliothek (samt Updates in diesen mitgelieferten Quelltexten) ohne Nachziehen solcher Änderungen eins zu eins übernommen werden können.

    Im ursprünglichen C++-Code dieser Bibliothek wurden für Boolsche Parameter eigene Konstanten namens TRUE und FALSE deklariert (sic), im .NET-Wrapper wurde analog dazu ein eigener Enumtyp namens "Bool" (im Gegensatz zum .NET Werttyp "Boolean" bzw. dem C#-Typ "bool") definiert:

    C#-Quellcode

    1. public enum Bool
    2. {
    3. TRUE = 1,
    4. FALSE = 0
    5. }


    Die zugehörigen Parameter würde ich nun innerhalb meines Programms aber gerne als "echte" Boolean/bool-Werte speichern. Einfach der Übersichtlichkeit und Wartungsfreundlichkeit wegen. Dumm nur, dass die Wrapper-Funktion einen Parameter vom Enum Bool erwartet und nicht Boolean/bool.

    Ein erster (und auch funktionierender) Ansatz war, eine Erweiterungsmethode zu schreiben, die die Klasse bool um eine Methode .ToLibBool() (o.ä.) erweitert, die den boolschen Wert in o.g. Enum umwandelt. Sieht aber doof aus, und macht das ganze imho unnötig umständlich.

    Also kam ich auf die Idee mit impliziten Operatoren.

    C#-Quellcode

    1. public static class Globals
    2. {
    3. public static implicit operator bool(Lib.Bool libBoolValue)
    4. {
    5. return libBoolValue == Lib.Bool.TRUE;
    6. }
    8. public static implicit operator Lib.Bool(bool bValue)
    9. {
    10. return bValue ? Lib.Bool.TRUE : Lib.Bool.FALSE;
    11. }
    12. }

    Scheint aber nicht so funktionieren wie ich dachte.

    C#-Quellcode

    1. bool b;
    2. // ...
    3. ret = Lib.IrgendeineFunktion(b);
    4. ret = Lib.IrgendeineFunktion((Lib.Bool)b);

    Weder das eine oder das andere will mein VS2010 durchgehen lassen.
    Variante 1 ergibt den Fehler "Die beste Übereinstimmung für die überladene Lib.IrgendeineFunktion(Lib.Bool)-Methode hat einige ungültige Argumente.".
    Variante 2 ergibt den Fehler "Eine Konvertierung vom Typ "bool" in "Lib.Bool" ist nicht möglich."

    Wieso "nicht möglich"? Ich hab ihm doch extra den "implicit Operator" zur Verfügung gestellt?

    Wo ist der Denkfehler? Wie kriege ich das hin?
    Weltherrschaft erlangen: 1%
    Ist dein Problem erledigt? -> Dann markiere das Thema bitte entsprechend.
    Waren Beiträge dieser Diskussion dabei hilfreich? -> Dann klick dort jeweils auf den Hilfreich-Button.
    Danke.

    @Arby:: Hast Du die Quellen von dem Wrapper in der Hand?
    Ja: Nimm Boolean.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    @RodFromGermany:

    Arby schrieb:

    Die Wrapper-Klassen stehen zwar als Quellcode zur Verfügung, aber es gilt die Vorgabe, an diesen Quelltexten nichts zu ändern
    Weltherrschaft erlangen: 1%
    Ist dein Problem erledigt? -> Dann markiere das Thema bitte entsprechend.
    Waren Beiträge dieser Diskussion dabei hilfreich? -> Dann klick dort jeweils auf den Hilfreich-Button.
    Danke.

    Wie kann die Globals-Klasse bei dir überhaupt kompilieren? Implizite Operatoren müssen entweder im Ausgangs- oder im Zieltyp deklariert werden, deklariert man sie in einem Typen, der weder Rückgabetyp noch Parameter ist, sollte man einen Compilerfehler erhalten.

    @Artentus: Du hast recht. Sie kompiliert erst gar nicht. Ich hatte die Kompilierung erst gar nicht durchgeführt wegen der o.g. Fehler im Code-Editor, und das Design der Klasse löst im Editor zunächst keinen Fehler aus. Darum ist mir das nicht aufgefallen.

    Besteht dann überhaupt eine Möglichkeit, Typumwandlungs-Operatoren für Enums oder den bool-Typ nachzudefinieren? Scheint mir nämlich so, als wäre das dann gar nicht möglich. Also doch über Extensions?
    Weltherrschaft erlangen: 1%
    Ist dein Problem erledigt? -> Dann markiere das Thema bitte entsprechend.
    Waren Beiträge dieser Diskussion dabei hilfreich? -> Dann klick dort jeweils auf den Hilfreich-Button.
    Danke.

    Ne, so geht das nicht. Allerdings könntest du mal mit deinem Auftraggeber besprechen, ob nicht einfach Überladungen für alle Funktionen erstellt werden könnten, die bool statt Bool annehmen. Das würde bestehende Codes nicht beeinträchtigen. Wenn nicht, dann wirds wohl auf Extensions rauslaufen, ja.

    Die Überladung der entsprechenden Methoden wäre wohl eine Möglichkeit, die "Befugnis" dazu hätte ich auch, aber ich halte das für keine gute Idee, weil ich hier von einer Lib spreche, die mehrere hundert Methoden beinhaltet und ich bei einem Software-Update doch wieder mindestens alle eigenen Überladungen auf Änderungen hin überprüfen müsste.

    Ich werde dann bei den Extensions bleiben. Mit impliziter Konvertierung hätte es mir zwar wesentlich besser gefallen, aber so rum ist es am Ende ja auch wartungsfreundlicher, weil einfacher nachvollziehbar.
    Weltherrschaft erlangen: 1%
    Ist dein Problem erledigt? -> Dann markiere das Thema bitte entsprechend.
    Waren Beiträge dieser Diskussion dabei hilfreich? -> Dann klick dort jeweils auf den Hilfreich-Button.
    Danke.

    Arby schrieb:

    aber es gilt die Vorgabe
    die sich offensichtlich als im Widerspruch zu Deinem Plan stehend erwiesen hat.
    Ändere sie und feddich.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Du hättest noch die Möglichkeit, mit einem 3., selbst erstellten Typen zu arbeiten, welcher implizite Cast-Operatoren zu bool und Lib.Bool hat. Den verwendest du dann bei der Initialisierung und du hast an allen passenden Stellen den Typen, den du brauchst.
    Von meinem iPhone gesendet

    RodFromGermany schrieb:

    Ändere sie und feddich.

    Nein.
    Wieso sollte ich auch? Da lebe ich lieber damit, die Typen "bool" und "Bool" um entsprechende Konvertierfunktion zu erweitern und diese zu verwenden als mir die Arbeit aufzuhalsen, bei jedem Software-Update die mitgelieferten Quellen des .NET-Wrappers von Bool auf bool umzuarbeiten.

    nikeee13 schrieb:

    Du hättest noch die Möglichkeit, mit einem 3., selbst erstellten Typen zu arbeiten,

    Interessanter Ansatz. Denk ich mal drüber nach.
    Weltherrschaft erlangen: 1%
    Ist dein Problem erledigt? -> Dann markiere das Thema bitte entsprechend.
    Waren Beiträge dieser Diskussion dabei hilfreich? -> Dann klick dort jeweils auf den Hilfreich-Button.
    Danke.

    Arby schrieb:

    Wieso sollte ich auch?
    Dann mach doch einfach um diesen Wrapper noch einen eigenen für Boolean, der dürfte sich nur selten ändern.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!