[TUT VB.net] Zugriffsmodifikatoren & Schlüsselwörter

[DeinMud]

Wollte hier einfach mal die Bedeutung aller Zugriffsmodifikatoren & Schlüsselwörter in VB.net verdeutlichen mit Beispiel:
Zugriffsmodifikatoren:

Private:
Nur innerhalb der Klasse nutzbar:

Public Class Form1
    'Nur innerhalb dieser Klasse Nutzbar
    Private yumYum As String
    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    End Sub
End Class

Public:
'Global Nutzbar:

Public Class Form1
    Private yum As New Objekt
    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        MessageBox.Show(yum.yumYum)
    End Sub
End Class
Public Class Objekt
    'Global nutzbar
    Public yumYum As String
End Class

Protected:
Nur innerhalb der Klasse & von Klassen, die die Klasse geerbt haben, nutzbar (wird mit vererbt, d.h. keine instanziierung der Klasse benötigt):

Public Class Objekt
    Protected yumYum As String
End Class
Public Class Lampe
    Inherits Objekt
    Private Sub Show()
        MessageBox.Show(yumYum)
    End Sub
End Class

Friend:
Nur Innerhalb des Projektes nutzbar (Eigtl wie Public, nur dass mit Public auch ausserhalb des Projektes auf das Feld zugegriffen werden kann).
Partial:
(Nur für Klassen)
Die Methoden & Objekte der Klasse werden an eine bereits existierende Klasse drangehängt.

Public Class Form1
    Private Sub aufrufen()
        Me.Hi()
    End Sub
End Class
Partial Class Form1
    Private Sub Hi()
        'Do something
    End Sub
End Class

Schlüsselwörter:


Overloads:
Dies kennzeichnet eine Überladung, das dient dazu 2 Methoden mit den gleichen Namen, aber anderen Signaturen erstellen zu können:

    Private Overloads Sub Test(ByVal input As String)
        'Do something
    End Sub
    Private Overloads Sub Test(ByVal input As Integer)
        'Do something
    End Sub

Overridable

Kennzeichnet eine Methode, dass Klassen welche von der Klasse Erben, diese Überschreiben können (jedoch nicht müssen, d.h. es muss eine Prozedur angegeben werden für den Falle, dass die Methode nicht überschrieben wird, wird diese Prozedur ausgeführt.)

Public Class Form1
    Private yummy As New Yummy
    Private yum As New Yum
    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        yummy.Test() 'Methode Test in der Klasse yummy wird ausgeführt
        yum.Test() 'Methode Test in der Klasse yum wird ausgeführt
    End Sub
End Class
Public Class Yum
    Public Overridable Sub Test()
        MessageBox.Show("Yum")
    End Sub
End Class
Public Class Yummy
    Inherits Yum
    Public Overrides Sub Test()
        MessageBox.Show("Yummy")
    End Sub
End Class

MustOverride
Dieses Schlüsselwort ist ähnlich wie Overridable, nur mit zwei Unterschieden:
1. Es wird keine Prozedur in der Basisklasse angegeben, da die Methode überschrieben werden MUSS --> Die Prozedur in der Basisklasse würde nie aufgerufen werden.
2. Muss die Basisklasse mit MustInherit gekennzeichnet werden, damit nicht direkt auf diese Zugegriffen werden kann & damit die Methode aufgerufen.

Public MustInherit Class Test
    Public MustOverride Sub Test()
End Class
Public Class Hallo
    Inherits Test
    Public Overrides Sub Test()
        'Do something
    End Sub
End Class

Overrides:
Um eine Methode in einer geerbten Klasse, welche als Überschreibbar (Overridable) oder MustOverride gekennzeichnet ist, zu überschreiben, nutzt man dieses Schlüsselwort:

Beispiel siehe Overridable

Default:
(Nur Eigenschaften)
Das Schlüsselwort sorgt dafür, dass über den Klassennamen direkt auf die Eigenschaft zugegriffen werden kann.

Public Class Form1
    Private yum As New Hallo
    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        MessageBox.Show(yum("Hallo"))
    End Sub
End Class
Public Class Hallo
    Default Public ReadOnly Property Test(ByVal input As String) As String
        Get
            Return input
        End Get
    End Property
End Class

Ihr könnt jedoch nur eine Default Eigenschaft pro Klasse festlegen.

Shared:

Falls nur eine Instanz einer Klasse benötigt wird, d.h. diese Klasse einzigartig sein soll, benutzt man das Schlüsselwort um auf die Methoden zuzugreifen:

Public Class Form1
    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        Gott.Move()
    End Sub
End Class
Public Class Gott
    Public Shared Sub Move()
        MessageBox.Show("Gott bewegt dich")
    End Sub
End Class

Iterator:
Dieses Schlüsselwort benötigt ihr um das Yield Schlüsselwort in einer Funktion benutzen zu können. Damit könnt ihr sogesehen, mehrere Elemente in einer IEnumerable(of t) zurückgeben lassen & nach jedem Yield merkt sich das Programm wo der Enumerator sich derzeit befindet --> neue Elemente werden an das Ende der Aufzählung rangefügt.

Public Class Form1
    Private Iterator Function Test() As IEnumerable(Of String)
        Yield "eins" 'eins wird in die Aufzählung hinzugefügt & MoveNext wird aufgerufen --> Der Enumerator wird auf das nächste Element gesetzt
        Yield "zwei" 'zwei wird in die Aufzählung hinzugefügt & MoveNext wird aufgerufen --> Der Enumerator wird auf das nächste Element gesetzt
        Yield "drei" 'drei wird in die Aufzählung hinzugefügt & MoveNext wird aufgerufen --> Der Enumerator wird auf das nächste Element gesetzt
    End Function
    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        For Each item In Test() 'Alle drei Items befinden sich jetzt in Test und können ohne Probleme in ein Array bzw in eine List(of string) konvertiert werden, da die beiden IEnumerable(of t) implementieren
            MessageBox.Show(item)
        Next
    End Sub
End Class

Shadows:
Dies dient dazu, dass die aufgerufene Methode der geerbten Klasse des typen des Feldes der Deklaration aufgerufen wird & nicht die des Typen
(Wenn keine Klasse geerbt wurde, wird die Methode des Typen aufgerufen)
Das ist meiner Meinung nach etwas schwerer zu erklären & der Unterschied zum Overrides liegt hierrin, dass beim Overrides nicht die Methode des Typen aufgerufen wird):

Public Class Form1
    Private Test As Eins = New Drei
    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        Test.Aufruf()
    End Sub
End Class
Public Class Eins
    Public Overridable Sub Aufruf()
        MessageBox.Show("Eins")
    End Sub
End Class
Public Class Zwei
    Inherits Eins
    Public Overrides Sub Aufruf()
        MessageBox.Show("zwei")
    End Sub
End Class
Public Class Drei
    Inherits Zwei
    Public Overrides Sub Aufruf()
        MessageBox.Show("Drei")
    End Sub
End Class

Kommt "Drei"

Public Class Form1
    Private Test As Eins = New Drei
    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        Test.Aufruf()
    End Sub
End Class
Public Class Eins
    Public Shadows Sub Aufruf()
        MessageBox.Show("Eins")
    End Sub
End Class
Public Class Zwei
    Inherits Eins
    Public Shadows Sub Aufruf()
        MessageBox.Show("zwei")
    End Sub
End Class
Public Class Drei
    Inherits Zwei
    Public Shadows Sub Aufruf()
        MessageBox.Show("Drei")
    End Sub
End Class

Kommt "eins"

NotInheritable & NotOverridable:
Diese beiden sollten klar sein, wenn der obige Abschnitt gelesen wurde.

Async:
Dies ist eine kleine Neuheit in vb 2012 womit man nicht extra einen neuen Thread aufmachen muss damit die GUI nicht einfriert:

    Private Async Sub Test()
        'Task.Run(Lambda Ausdruck oder eine Methode die asynchron ausgeführt werden soll, angeben)
        Await Task.Run(Sub()
                           While True
                               Debug.Print("Hallo")
                           End While

                       End Sub
          )
    End Sub
    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Test()
    End Sub

Das waren erstmal einige wichtige Schlüsselwörter, es gibt noch welche wie Withevents, ReadOnly/WriteOnly, usw aber diese sind meist selbsterklärend.