Angepinnt Beispiele für guten und schlechten Code (Stil)

  • VB.NET

Es gibt 269 Antworten in diesem Thema. Der letzte Beitrag () ist von Hinti.

    Stylisch in VB.2010:

    VB.NET-Quellcode

    1. Private Sub foo()
    2. Dim n As Integer = 10
    3. Dim f As Func(Of Integer) = New Func(Of Integer)(Function()
    4. For i = 1 To n
    5. For j = 1 To n
    6. If i = 5 AndAlso j = 5 Then Return -1
    7. Next
    8. Next
    9. Return 1
    10. End Function)
    11. Dim k As Integer = f()
    12. End Sub


    vorteil einer solchen "inline" (quasi) Funktion ist, dass man die nötigen Variablen nicht als Parameter übergeben muss, da sie ja im selben block schon definiert sind.

    Man kanns natürlich auch mit einer äußeren "dummy" Schleife lösen:

    VB.NET-Quellcode

    1. Do
    2. For i = 1 To 1
    3. For j = 1 To 1
    4. Exit Do
    5. Next
    6. Next
    7. Loop Until True

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

    TheCokeSideOf schrieb:

    Zitat von »Vatter«
    @TheCokeSideOf,
    denkbar wäre vielleicht auch Exit For für die innere Schleife und eine Wiederholung der gleichen If vor dem 2. Next.

    Aber ist das dann tatsächlich noch "stilvoller" als mit GoTo?

    Wenn die Schleife im Normalfall zwischendrin abbricht, wäre wahrscheinlich im Sinne der hier erwähnten eleganten Programmierung ein anderes Konstrukt wie "While" sinnvoller.
    Ich würde For-Schleifen eigentlich nur benutzten, wenn ich sicher bin, dass jedes Element verarbeitet werden muss. Aber auch da würde ich eher "For Each" benutzen... ich glaub "For i As Integer = ...." kommt in meinem aktuellen Projekt gar nicht mehr vor ^^


    T1g0r schrieb:

    Ich prüfe auch immer mit String.Empty.
    Wie würdet ihr denn einen optionalen String-Parameter initialisieren?

    VB.NET-Quellcode

    1. Optional ByVal optParameter As String = String.Empty
    geht nicht, da String.Empty keine Konstante ist (?!?).
    Und ich würde gerne unterscheiden können, ob nichts - also der Parameter nicht gesetzt - oder ein leerer String "" übergeben wurde.

    Gruß,
    nickname

    nickname777 schrieb:

    Und ich würde gerne unterscheiden können, ob nichts - also der Parameter nicht gesetzt - oder ein leerer String "" übergeben wurde.

    Dann arbeite mit Überladung nicht nicht optionalen Params:

    VB.NET-Quellcode

    1. Private Sub bar()
    2. ' String nicht gesetzt
    3. End Sub
    4. Private Sub bar(ByVal s As String)
    5. ' String gesetzt
    6. End Sub

    picoflop schrieb:

    nickname777 schrieb:

    Und ich würde gerne unterscheiden können, ob nichts - also der Parameter nicht gesetzt - oder ein leerer String "" übergeben wurde.

    Dann arbeite mit Überladung nicht nicht optionalen Params:

    VB.NET-Quellcode

    1. Private Sub bar()
    2. ' String nicht gesetzt
    3. End Sub
    4. Private Sub bar(ByVal s As String)
    5. ' String gesetzt
    6. End Sub

    Ist aber auch eher schlecht möglich, wenn ich mehrere optionale Parameter habe, die in verschiedenen Kombinationen gesetzt werden können. Dann müsste ich ja für jede mögliche Kombination eine Überladung definieren... ?

    Edit 2:
    Verlesen

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

    also bei mir ist eine Klasse(jenachdem so aufgebaut):

    VB.NET-Quellcode

    1. Public Class Test
    2. #Region "Variablen"
    3. 'Deklerationen
    4. Private m_Name As String
    5. #End Region
    6. #Region "Properties"
    7. ReadOnly Property Name As String
    8. Get
    9. Return m_Name
    10. End Get
    11. End Property
    12. #End Region
    13. #Region "Events"
    14. ...
    15. #End Region
    16. #Region "Enumeratoren"
    17. ...
    18. #End Region
    19. #Region "InClasses"'hierhzu gehören für mich auch Strukturen ;) :P
    20. #End Region
    21. End Class
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---
    Sowas hier wird wenn es viele Verschachtelungen sind auch übel:

    VB.NET-Quellcode

    1. Dim element As String = "PfadZurDateiAusVorherigenFunktionen"
    2. If element IsNot Nothing Then
    3. If existiertDatei(element) Then
    4. If habIchRechteZumLöschen(element) Then
    5. If istloeschbar(element) Then
    6. loscheDatei(element)
    7. Else
    8. MsgBox("Datei gerade in Verwendung")
    9. End If
    10. Else
    11. MsgBox("Keine Rechte")
    12. End If
    13. Else
    14. MsgBox("Datei nicht gefunden")
    15. End If
    16. Else
    17. MsgBox("Kein Pfad übergeben")
    18. End If


    Besser finde ich:

    VB.NET-Quellcode

    1. If element Is Nothing Then MsgBox("Kein Pfad übergeben") : Exit Sub
    2. If existiertDatei(element) = false Then MsgBox("Datei nicht gefunden") : Exit Sub
    3. If habIchRechteZumLöschen(element) = false Then MsgBox("Keine Rechte") : Exit Sub
    4. If istloeschbar(element) = false Then MsgBox("Datei gerade in Verwendung") : Exit Sub
    5. loscheDatei(element)

    VB.NET-Quellcode

    1. If a = False Then

    ist langsamer als

    VB.NET-Quellcode

    1. If Not a Then

    ausserdem ist letzteres näher an der "gesprochenen" Variante

    Kleine nette Sache:

    VB.NET-Quellcode

    1. If a IsNot Nothing AndAlso Not String.IsNullOrEmpty(a) AndAlso FileIO.FileSystem.FileExists(a) Then
    2. 'haha
    3. Else
    4. 'O!nk
    5. End If
    also ich hätte das wenn dann so geschrieben, was wirklich schneller wäre :P

    VB.NET-Quellcode

    1. If a Is Nothing AndAlso String.IsNullOrEmpty(a) AndAlso Not FileIO.FileSystem.FileExists(a) Then
    2. 'O!nk
    3. Else
    4. 'haha
    5. End If
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---

    FAtheone schrieb:

    ist langsamer als

    Ist nach dem kompilieren ... IDENTISCH!

    VB.NET-Quellcode

    1. Private Sub foo()
    2. Dim a As Boolean
    3. If a = False Then
    4. a = True
    5. End If
    6. End Sub

    IL-Code:

    Quellcode

    1. .method private instance void foo() cil managed
    2. {
    3. // Code size 14 (0xe)
    4. .maxstack 2
    5. .locals init ([0] bool a,
    6. [1] bool VB$CG$t_bool$S0)
    7. IL_0000: nop
    8. IL_0001: ldloc.0
    9. IL_0002: ldc.i4.0
    10. IL_0003: ceq
    11. IL_0005: stloc.1
    12. IL_0006: ldloc.1
    13. IL_0007: brfalse.s IL_000b
    14. IL_0009: ldc.i4.1
    15. IL_000a: stloc.0
    16. IL_000b: nop
    17. IL_000c: nop
    18. IL_000d: ret
    19. } // end of method Form1::foo


    VB.NET-Quellcode

    1. Private Sub bar()
    2. Dim a As Boolean
    3. If Not a Then
    4. a = True
    5. End If
    6. End Sub


    IL-Code:

    Quellcode

    1. .method private instance void bar() cil managed
    2. {
    3. // Code size 14 (0xe)
    4. .maxstack 2
    5. .locals init ([0] bool a,
    6. [1] bool VB$CG$t_bool$S0)
    7. IL_0000: nop
    8. IL_0001: ldloc.0
    9. IL_0002: ldc.i4.0
    10. IL_0003: ceq
    11. IL_0005: stloc.1
    12. IL_0006: ldloc.1
    13. IL_0007: brfalse.s IL_000b
    14. IL_0009: ldc.i4.1
    15. IL_000a: stloc.0
    16. IL_000b: nop
    17. IL_000c: nop
    18. IL_000d: ret
    19. } // end of method Form1::bar


    Mag das eine schöner sein, so ist's im Endeffekt egal, weil der Compiler das ganze sowieso umoptimiert
    != gibt es doch nicht in VB^^
    a = a = False = False bzw isnot false

    Quellcode

    1. a = True
    2. a = a = False = False
    3. a = True
    4. a = False
    5. a = a = False = False
    6. a = False

    bzw.

    Quellcode

    1. a = True
    2. a = True Isnot false
    3. a = True
    4. a = False
    5. a = a IsNot False
    6. a = False

    das ergibt a = a und ist mal wirklich unnötig, sogar a = a ist bereits unnötig...
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---
    @Vorposter: muss man das verstehen? Meinst du den IL-Code, das ist übersetzter VB/C#/C++ .Net/J# Code, welcher dann erst später endgültig in Maschinencode übersetzt wird...
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---