Konstruktor einer Klasse

  • VB.NET

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

    Konstruktor einer Klasse

    Hallo Community

    Ich habe eine allgemeine Frage zum Konstruktor.

    Bei der Instanzierung und Initialisierung von MyClass, dürfen nur Variablen verwendet werden.
    Kann das irgendwie sichergestellt werden? Ansonsten soll der Compiler eine Fehlermeldung
    abgeben.

    Gibt es eine Möglichkeit in VB.NET bzw. C#.

    Danke für die Antworten.

    exc-jdbi

    VB.NET-Quellcode

    1. Public Class MyClass
    2. Public Value as Int32
    3. Public Array as Int32()
    4. Public Sub New(_value as Int32)
    5. 'Code
    6. End Sub
    7. Public Sub New(_array() as Int32)
    8. 'Code
    9. End Sub
    10. End Class


    Folgende Bedingung sollte bestehen.

    VB.NET-Quellcode

    1. 'Erlaubt sind
    2. Dim i = 15I
    3. Dim a = {0,1,2,3,4,5,6,7,8,9}
    4. Dim myc1 = New MyClass(i)
    5. Dim myc2 = New MyClass(a)
    6. 'Nicht erlaubt
    7. Dim myc1 = New MyClass(15I) 'Soll als Fehler anzeigen
    8. Dim myc2 = New MyClass({0,1,2,3,4,5,6,7,8,9})'Soll als Fehler anzeigen



    Ich sollte mir angewöhnen, dass ich bei solchen Fragen nur antworte, wenn ich den Weg kenne, da meine Unwissenheit nichts über die Existenz einer Lösung aussagen kann.
    Spekulatiusantwort:
    Den Zweck hinter Deinem Vorhaben sehe ich nicht, aber das ist ja auch irrelevant. Da eine Variable doch immer nur ein Platzhalter für einen konkreten Wert (im Normalfall) ist, gehe ich davon aus, dass es effektiv unmöglich ist, das eine zu erlauben, das andere aber zu verhindern.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.
    @VaporiZed

    Danke für die Antwort.

    Bis jetzt hat mich das auch nie gestört. Ganz im Gegenteil. Ich verwende es viel.

    Ich könnte mir vorstellen dass es in C# mit dem ref-Parameter funktioniert. Kann es aber erst am Abend testen. In VB.NET hingegen weiss ich, das es mit ByRef nicht funktioniert.

    Es geht mir nur darum, dass instanzierte bzw. initialisierte Variable verwendet werden.

    Nochmals danke für die Antwort.

    Freundliche Grüsse

    exc-jdbi
    In »Clean Code« von Bob Martin heißt es in Kapitel 7.8 »Keine Null übergeben«:
    In den meisten Programmiersprachen gibt es keine gute Methode, mit einem Wert null umzugehen, der aus Versehen von einem Aufrufer übergeben wird. Deswegen besteht die rationale Lösung darin, die Übergabe von null standardmäßig zu verbieten. Denn dann können Sie mit dem Wissen codieren, dass der Wert null in einer Argumentenliste ein Problem anzeigt, und machen viel weniger Fehler aus Unachtsamkeit.
    Das Problem: Ich kenne keinen Weg das umzusetzen. Ich hatte das zwar anfangs mal mit Code Contracts versucht, aber erfolgreich fertig geworden bin ich damit nicht. Vielleicht nicht tief genug recherchiert.

    ##########

    Zur Sicherheit: Ich verstehe den Text so, dass zur Designzeit oder zur Laufzeit ohne zusätzliche Wertprüfung ein Problem angezeigt werden soll. Eine Wertprüfung zur Laufzeit ist ja schließlich nix Besonderes.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

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

    VaporiZed schrieb:

    Das Problem: Ich kenne keinen Weg das umzusetzen.


    Falls du C# nutzt: Seit C# 8.0 gibt es dafür Nullable Reference Types: docs.microsoft.com/en-us/dotnet/csharp/nullable-references
    Wenn du dieses Feature aktivierst (was man in C# ab heute immer machen sollte, insbesondere bei Libraries), kannst du explizit definieren, was null sein darf und was nicht. Wenn du dich nicht an diese Regeln hälst, wird der Compiler Warnungen werfen. Als kleines Beispiel:

    C#-Quellcode

    1. string cannotBeNull = null; // Compiler Warning: Cannot be null.
    2. string? canBeNull = null; // Is okay.
    3. // Methods:
    4. void Foo(string cannotBeNull, string? canBeNull) {
    5. }
    6. Foo(null, null);
    7. // ^ Compiler Warning: This parameter cannot be null.


    Das ganze ist ein richtig gutes Feature (welches es eigentlich schon viel früher hätte geben sollen). Es lohnt sich wirklich, das mal anzuschauen.
    Danke für den Hinweis, den sicherlich der ein oder andere nutzen kann. Ich bin aber seit über 10 Jahren in VB.NET unterwegs - mal sehen, wie lange es das noch gibt. Da ist Mikrosaft ja etwas relativierend geworden.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.
    Ich denke ich schliesse diesen Thread.

    Der Nullable Reference Types so wie beschrieben hat seine Berechtigung, und wird sicher auch noch seinen Weg ins Vb.Net finden. Beantwortet aber nicht meine Frage.

    C# gibt bei folgendem eine Compiler-Meldung aus, sofern eine Zahl direkt als Argument hingeschrieben wird.
    Out: Entspricht nicht genau dem was ich gemeint habe,
    da ich nicht den Wert wieder zurückholen möchte.
    var mc = new MyClasses<int>(out 12);

    Ref: Funktioniert sieht aber ein bisschen
    gewöhnungsbedürftig aus. Auch ref gibt den
    Wert wieder zurück in die Variable.
    var mc = new MyClasses<int>(ref 12);

    Wäre für mich interessant (rein vollständigkeitshalber) gewesen so etwas nachzubilden, mittels einer z.B. Compiler-Anweisung (und wenn möglich auch noch örtlich begrenzt). Ich vermute aber, dass es nicht möglich ist, auch nicht in C#.

    Nochmals danke für die Antworten.

    Freundliche Grüsse

    exc-jdbi