Verständnisfrage zu Mustinherit, Overrides, Protected Sub New(), ...

  • VB.NET
  • .NET 4.5

Es gibt 22 Antworten in diesem Thema. Der letzte Beitrag () ist von Bartosz.

    Verständnisfrage zu Mustinherit, Overrides, Protected Sub New(), ...

    Moin zusammen,

    ich experimentiere gerade mit Klassen herum, um zu lernen.

    Als Erstes habe ich meine Form1-Klasse:

    VB.NET-Quellcode

    1. Public Class Form1
    2. 'Was hier schreiben, um Instanz zu bauen?
    3. Public Pfad As String = ""
    4. Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
    5. Using OFD As New CommonOpenFileDialog
    6. OFD.Title = "Bild auswählen"
    7. OFD.Filters.Add(New CommonFileDialogFilter("JPEG", ".jpg"))
    8. OFD.Filters.Add(New CommonFileDialogFilter("Bitmap", ".bmp"))
    9. OFD.Filters.Add(New CommonFileDialogFilter("PNG", ".png"))
    10. OFD.Multiselect = False
    11. OFD.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop)
    12. OFD.IsFolderPicker = False
    13. OFD.RestoreDirectory = True
    14. If OFD.ShowDialog() = DialogResult.OK Then
    15. Pfad = OFD.FileName
    16. Else
    17. Exit Sub
    18. End If
    19. End Using
    20. '' Wie aufrufen?
    21. End Sub
    22. Private Sub Form1_FormClosing(sender As Object, e As FormClosingEventArgs) Handles MyBase.FormClosing
    23. PictureBox1.Image = Nothing
    24. End Sub
    25. End Class


    So, nun möchte ich eine Public MustInherit Class verwenden.
    Ich habe noch Schwierigkeiten mit allem. Sobald ich einen Fehler korrigiere, kommen 2 neue..Ich muss gestehen, dass ich keine Ahnung vom MustInherit habe

    VB.NET-Quellcode

    1. Public MustInherit Class Abstrakte_Klasse : Inherits SharedPtrObject
    2. Protected Sub New()
    3. End Sub
    4. Public Shared Function Create() As Abstrakte_Klasse
    5. Return New abstrakte_Klasse_1 'Fehler! ?? Der Typ abstrakte_klasse_1 ist nicht definiert.
    6. End Function
    7. Public ReadOnly Property Ptr1 As IntPtr
    8. End Class
    An die Neulinge: verwendet bei VB.Net Option Strict On :!: Nur dann ist es konkurrenzfähig zu C#.
    Ok, Du hast ne Basisklasse SharedPtrObject. Die Klasse Abstrakte_Klasse erbt von SharedPtrObject. Aber was ist abstrakte_Klasse_1? Die hast Du nicht definiert. Sieht mir irgendwie so aus, als willst Du ein Singleton-Pattern nachbauen. Aber das geht ja ohne abstrakte Klasse. Hm. Was hast Du vor?
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Häufig von mir verwendete Abkürzungen: CEs = control elements (Labels, Buttons, DGVs, ...) und tDS (typisiertes DataSet)
    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht in den Spekulatiusmodus gehen.
    @VaporiZed Danke für die schnelle Antwort.
    Das ist nur ein Beispiel.
    ich weiß auch nicht, was ein Singleton-Pattern ist.

    Am besten, ich fange ganz einfach an. Kennst du noch diesen Thread hier? Drehzahlmesser grafisch visualisiert
    Da habe ich auch ne andere Klasse für das Painten in der PictureBox verwendet, das war aber einfach nur ne stinknormale Klasse. Jetzt will ich etwas mehr lernen und muss mich mal ein bisschen mit diesen Schlagwörtern MustInherit (und wie sie alle heißen) beschäftigen.

    Ich habe vorhin auch schon Threads gesucht, bin auf RFGs und EDRs Antworten gestoßen und habe das einfach mal kopiert, jedoch kamen immer Fehler.

    Ich würde euch gerne bitten, ein Beispiel mit mir durchzugehen.

    Aber was ist abstrakte_Klasse_1? Die hast Du nicht definiert.
    Das verstehe ich nicht. Gerade die mache ich doch neu ?! :|
    An die Neulinge: verwendet bei VB.Net Option Strict On :!: Nur dann ist es konkurrenzfähig zu C#.
    He? Bisher hast Du nur Abstrakte_Klasse und SharedPtrObject. Aber für den Compiler ist abstrakte_Klasse_1 etwas, was noch nicht existiert. Das ist wie mit
    Public Class Auto. Wenn Du die hast, kannst Du schreiben: Dim MeinAuto As New Auto
    Aber wenn Du Public Class Auto nicht hast, weiß der Compiler auch nicht, von welchem Typ MeinAuto sein soll. Und daher: Du hast nirgends stehen Public Class abstrakte_Klasse_1. Nur Public Class Abstrakte_Klasse. Das sind aber 2 paar Schuhe. Genauso könntest Du statt New abstrakte_Klasse_1 auch New Bartosz schreiben. Damit kann der Compiler auch nix anfangen.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Häufig von mir verwendete Abkürzungen: CEs = control elements (Labels, Buttons, DGVs, ...) und tDS (typisiertes DataSet)
    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht in den Spekulatiusmodus gehen.
    Ok, da muss ich niedriger ansetzen. Gebe ich zu xD

    ich habe hier mal etwas Fertiges herausgesucht. Hoffe, das ist OK. Was sind die einzelnen Abläufe in Post #31 (von @fichz)

    VB.NET-Quellcode

    1. Public MustInherit Class Tower
    2. Private _Reichweite As Integer
    3. Public Property Reichweite() As Integer
    4. Get
    5. Return _Reichweite
    6. End Get
    7. Set(ByVal value As Integer)
    8. _Reichweite = value
    9. End Set
    10. End Property
    11. Private _Schaden As Double
    12. Public Property Schaden() As Double
    13. Get
    14. Return _Schaden
    15. End Get
    16. Set(ByVal value As Double)
    17. _Schaden = value
    18. End Set
    19. End Property
    20. Protected Sub New(ByVal Manager As TowerManager)
    21. Manager.TowerList.Add(Me)
    22. End Sub
    23. End Class
    24. Public Class LaserTurm : Inherits Tower
    25. Protected Sub New(ByVal manager As TowerManager)
    26. MyBase.New(manager)
    27. End Sub
    28. End Class
    29. Public Class TowerManager
    30. Private _TowerList As List(Of Tower)
    31. Public Property TowerList() As List(Of Tower)
    32. Get
    33. Return _TowerList
    34. End Get
    35. Set(ByVal value As List(Of Tower))
    36. _TowerList = value
    37. End Set
    38. End Property
    39. End Class
    An die Neulinge: verwendet bei VB.Net Option Strict On :!: Nur dann ist es konkurrenzfähig zu C#.
    Der Post ist etwas älter, es haben sich inzwischen Vereinfachungen ergeben:

    VB.NET-Quellcode

    1. Public MustInherit Class Tower
    2. Public Property Reichweite() As Integer
    3. Public Property Schaden() As Double
    4. Protected Sub New(Manager As TowerManager)
    5. Manager.TowerList.Add(Me)
    6. End Sub
    7. End Class
    8. Public Class LaserTurm : Inherits Tower
    9. Protected Sub New(manager As TowerManager)
    10. MyBase.New(manager)
    11. End Sub
    12. End Class
    13. Public Class TowerManager
    14. Public Property TowerList() As List(Of Tower)
    15. End Class

    Was haben wir nun:
    Wir haben eine Tower-Klasse. Da sie als MustInherit gekennzeichnet ist, kannst Du nicht schreiben: Dim MyTower = New Tower, da Tower durch jenes Schlüsselwort als abstrakte Basisklasse gekennzeichnet ist. Anderes Beispiel: Lebewesen. Es könnte als Eigenschaft z.B. Alter haben. Aber so ziemlich alles andere muss durch Unterklassen festgelegt werden, z.B. Prokaryonten und Eukaryonten. Oder Pflanzen, Tiere, Pilze, Bakterien, SonstigeEinzeller. Würdest Du also sagen: Ich erschaffe nun ein neues Lebebwesen, ergäbe das wenig Sinn, da diese Klasse viel zu unspezifisch ist, um ein konkretes Wesen zu erzeugen. Die Klasse ist einfach zu allgemein gehalten.
    Zurück zum Tower. Der Laserturm erbt von Tower und hat darüberhinaus … hm, keine weiteren Eigenschaften. Normalerweise wird Vererbung verwendet, um spezifischere Türme zu generieren, die eben noch zusätzliche Eigenschaften oder Funmtionen aufweisen. Daher: ungünstiges Beispiel.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Häufig von mir verwendete Abkürzungen: CEs = control elements (Labels, Buttons, DGVs, ...) und tDS (typisiertes DataSet)
    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht in den Spekulatiusmodus gehen.
    ich würd empfehlen, sich da nicht so drin zu verbeissen.
    MustInherit braucht man nur selten, und das einzige Beispiel dieses Threads (der LaserTower) ist sinnlos, denn der LaserTower hat nichts, was Tower nicht schon selbst hatte.

    Das halte ich für ganz wichtig, wenn man sich mit SprachFeatures auseinandersetzt: Dass man auch ein wirkliches Problem hat, was durch das SprachFeature auch überzeugend gelöst wird.
    Sonst wurstelt man sich ieinen Mist zusammen, und denkt hinterher "ich kanns" - und stimmt garnet, sondern ist eher ein AntiPattern.

    Ich hab zB. bislang insgesamt nur 3 mal MustInherit verwenden müssen, und meist für eher abgedrehte Sachen, die ich gefühlt kaum verständlich machen kann:
    • DatasetAdapterBase - das ist noch gut verstehbar:
      Davon ist abgeleitet der XmlDatasetAdapter, der ein typDataset einfach auf Platte speichert, und der DbDatasetAdapter, der in eine Datenbank persistieren kann
    • BinarySearcherBase
      ziemlich abgedreht: ein 'normaler' BinarySearcher für normale Binärsuchen - die Treffer sind unbestimmtt, wenn der Datenbestand einen Bereich gleicher Werte enthält (Dubletten). Und ein BinaryRangeSearcher - wenn Dubletten vorhanden, kann dieser BinarySearcher den ersten / letzten Eintrag des DublettenRanges auffinden
    • CompletionPreviewBase
      ZusatzFeature zu AutoCompletion. AutoCompletion gibts für Textboxen, aber auch für Comboboxen - intern tickt das verschieden.
    Also wie gesagt: Such dir erst ein Problem, was mit einer abstrakten Basisklassen überzeugend zu lösen ist.
    Sonst kann das eiglich nur BrainF** werden.

    Was du auch machen kannst ist nach "Strategy-Pattern" googeln, weil abstrakte Basisklassen sind eiglich der Königsweg, um diesen Pattern umzusetzen.
    Aber wie google so ist: kann natürlich auch sein, dass du an einen echten BrainF**er gerätst - vlt. posteste die Links, die dir vielversprechend erscheinen. (ein Anhaltspunkt z.B.: es muss eine BeispielSolution zum Download stehen (die auch funktioniert))
    @VaporiZed Danke für deine Metapher mit dem Lebewesen und für die gute Erklärung! :)
    @ErfinderDesRades Verstehe ich, ist ein bissl unnütz mit dem Tower-Beispiel. Und mit MustInherit... War vorhin nur auf die Schnelle rausgesucht.
    es muss eine BeispielSolution zum Download stehen (die auch funktioniert)
    Vielleicht finde ich morgen in der Suche etwas besseres zu Klassen allgemein, oder ich denke mir etwas Konkretes aus, vielleicht das mit Lebewesen. Danke dir für die gute Erklärung :)

    Noch 3 Sachen zum Verständnis:
    1.) Muss das so, wie im Anhang, mit der List? Nee oder? Das ist doch nur eine Liste mit den neuen Instanzen?
    2.) Verstehe ich das richtig: in der

    Quellcode

    1. Public MustInherit Class Tower
    muss es ein

    Quellcode

    1. Protected Sub New()
    geben, weil man das gewöhnliche

    Quellcode

    1. Dim MyTower = New Tower
    nicht schreiben kann? In der abgeleiteten Klasse (ist das Wort richtig?) gibt es auch ein

    Quellcode

    1. Protected Sub New()
    worin

    Quellcode

    1. MyBase.New(manager)
    steht. Was macht das? Muss das?
    3.) Wie rufe ich das, mit dem man arbeiten will (meinetwegen eine Prozedur, die hier noch nicht steht), aus Form1 auf?

    Viele Grüße
    Bilder
    • screenshot geschnitten rote Linie - Kopie.jpg

      77,37 kB, 548×460, 18 mal angesehen
    An die Neulinge: verwendet bei VB.Net Option Strict On :!: Nur dann ist es konkurrenzfähig zu C#.
    Nee, vergiss das Beispiel, das ist irreführend. Durch MustInherit ist Dim MyTower = New Tower schon nicht möglich, da meckert der Compiler rum, dass man abstrakte Klassen nicht instanziieren kann. Das mit Protected Sub New muss nicht sein. Und das mit der TowerList schon gleich 3x nicht. Mag damals relevant gewesen sein, weil spezifischer Fall. Aber eine Klasse sollte normalerweise nix über seinen Container wissen. Von CEs z.B. mal abgesehen. Da find/bastel ich ein besseres Beispiel.

    ##########

    Nehmen wir das Towerbeispiel. Ich hab zwar kein Spiel, aber brauchen wir ja auch nicht.

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public MustInherit Class Tower
    2. Protected ShootingRangeInPixels As Integer
    3. Protected LifeEnergyInPercent As Integer = 100
    4. Protected Damage As Integer
    5. Public Function IsAlive() As Boolean
    6. Return LifeEnergyInPercent > 0
    7. End Function
    8. Public MustOverride Sub Shoot()
    9. End Class
    10. Public Class CannonTower : Inherits Tower
    11. Public Sub New()
    12. ShootingRangeInPixels = 50
    13. Damage = 10
    14. End Sub
    15. Public Overrides Sub Shoot()
    16. MessageBox.Show("Kaboom!")
    17. End Sub
    18. End Class
    19. Public Class LaserTower : Inherits Tower
    20. Public Sub New()
    21. ShootingRangeInPixels = 100
    22. Damage = 8
    23. End Sub
    24. Public Overrides Sub Shoot()
    25. MessageBox.Show("Spratzel!")
    26. End Sub
    27. End Class

    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Häufig von mir verwendete Abkürzungen: CEs = control elements (Labels, Buttons, DGVs, ...) und tDS (typisiertes DataSet)
    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht in den Spekulatiusmodus gehen.

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

    jo, zumindest ein sauberes Beispiel ohne so komisches wie Protected Sub New etc. (nix gegen Protected Sub New - es gibt Probleme, die damit zu lösen sind)
    Aber nachwievoer nicht wirklich überzeugend, denn die Unterschiede der Tower-Erben sind marginal.
    Im Grunde sinds ja nur verschiedene Voreinstellungen. Aber um Default-Werte zu setzen braucht man nicht unbedingt ein KlassenSystem mit Abstrakta.

    Wie gesagt: Es ist garnet so einfach, ein geeignetes Problem zu finden.
    Dann geb ich Dir ein spezielles:

    VB.NET-Quellcode

    1. Public MustInherit Class TypedBindingSource(Of T) : Inherits BindingSource: End Class

    Den Rest der Funktionalität lass ich mal raus. Aber da - wie wir schon in einem anderen Thread vor einigen Wochen feststellten - WinForms keine generischen CEs akzeptiert, muss man hier mit MustInherit arbeiten:

    VB.NET-Quellcode

    1. Public Class BsProcesses : Inherits TypedBindingSource(Of Process) : End Class
    Und das Teil kann ich mir auf's Form ziehen und all die kleinen Feinheiten genießen, die ich in die Basisklasse eingebaut habe.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Häufig von mir verwendete Abkürzungen: CEs = control elements (Labels, Buttons, DGVs, ...) und tDS (typisiertes DataSet)
    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht in den Spekulatiusmodus gehen.
    @VaporiZed Cool, danke! Ich erkenne: 2 Gegner (Lasertower und Cannontower); beide erben von Tower, weil's halt beide Tower sind. Mit Public Sub New() werden die Integers des Tower jeweils befüllt. Prinzip verstanden :thumbsup:

    Ich bin jetzt so vorgegangen und es funktioniert. Da fehlt nur noch die Verarbeitung des Schadens. Noch ein bisschen ungewohnt, dass die .shoot() nicht im IntelliSense vorgeschlagen wird

    VB.NET-Quellcode

    1. Public Class Form1
    2. Dim myCannonTower = New CannonTower
    3. Dim myLaserTower = New LaserTower
    4. Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    5. End Sub
    6. Private Sub Button_Cannon_Click(sender As Object, e As EventArgs) Handles Button_Cannon.Click
    7. If myCannonTower.IsAlive() Then
    8. myCannonTower.shoot()
    9. End If
    10. End Sub
    11. Private Sub Button_Laser_Click(sender As Object, e As EventArgs) Handles Button_Laser.Click
    12. If myLaserTower.isAlive() Then
    13. myLaserTower.shoot()
    14. End If
    15. End Sub
    16. End Class
    17. Public MustInherit Class Tower
    18. Protected ShootingRangeInPixels As Integer
    19. Protected LifeEnergyInPercent As Integer = 100
    20. Protected Damage As Integer
    21. Public Function IsAlive() As Boolean
    22. Return LifeEnergyInPercent > 0
    23. End Function
    24. Public MustOverride Sub Shoot()
    25. End Class
    26. Public Class CannonTower : Inherits Tower
    27. Public Sub New()
    28. ShootingRangeInPixels = 50
    29. Damage = 10
    30. End Sub
    31. Public Overrides Sub Shoot()
    32. MessageBox.Show("Kaboom!")
    33. End Sub
    34. End Class
    35. Public Class LaserTower : Inherits Tower
    36. Public Sub New()
    37. ShootingRangeInPixels = 100
    38. Damage = 8
    39. End Sub
    40. Public Overrides Sub Shoot()
    41. MessageBox.Show("Spratzel!")
    42. End Sub
    43. End Class
    An die Neulinge: verwendet bei VB.Net Option Strict On :!: Nur dann ist es konkurrenzfähig zu C#.

    Bartosz schrieb:

    Noch ein bisschen ungewohnt, dass die .shoot() nicht im IntelliSense vorgeschlagen wird
    Hab ich was vergeigt?
    Bei mir wird's angezeigt:


    Der Vorteil der Vererbung ist auch, dass Du die verschiedenen Türme nun zusammenfassen kannst:

    VB.NET-Quellcode

    1. Dim TowerList As New List(Of Tower)
    2. TowerList.Add(New LaserTower)
    3. TowerList.Add(New CannonTower)
    4. For Each Tower In TowerList
    5. If Tower.IsAlive Then Tower.Shoot()
    6. Next

    andere Schreibweise:

    VB.NET-Quellcode

    1. Dim TowerList As New List(Of Tower) From {
    2. New LaserTower,
    3. New CannonTower
    4. }
    5. TowerList.Where(Function(x) x.IsAlive).ForEach(Sub(x) x.Shoot())


    Und ganz kurz noch: Das MustOverride in der Basisklasse ist eben dafür da, dass Du sagst: "Hey, alle, die von mir erben, müssen eine Shoot-Methode haben. Wie die aussieht, ist mir aber egal." Dadurch geht eben das mit der Schießen-For-Schleife. Würde die Shoot-Methode nicht bereits in der Tower-Basisklasse stehen, würde die Schleife nicht funktionieren.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Häufig von mir verwendete Abkürzungen: CEs = control elements (Labels, Buttons, DGVs, ...) und tDS (typisiertes DataSet)
    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht in den Spekulatiusmodus gehen.
    1.) Einmal das Bild von meinem IntelliSense. Kann das an meiner Version iegen?
    Microsoft Visual Studio Professional 2019 Version 16.6.1
    Ist aber nicht so schlimm. Ich weiß nun, dass die Subs in Wirlichkeit da sind. Ich hatte letztens einen ähnlichen Fall. Post 15 von EDR

    2.) Jetzt habe ich das mit der Liste verstanden. Ist demnach nur eine Zusammenfassung.
    Bilder
    • IntelliSense - Kopie.jpg

      108,85 kB, 986×433, 19 mal angesehen
    An die Neulinge: verwendet bei VB.Net Option Strict On :!: Nur dann ist es konkurrenzfähig zu C#.
    Tja, das dürfte daran liegen, dass Du Deine eigene Signator ignorierst: An die Neulinge: verwendet Option Strict On
    Denn Du hast Deine Tower nicht korrekt deklariert. Die gelten als Object und können daher nicht korrekt von IntelliSense als Tower erkannt werden.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Häufig von mir verwendete Abkürzungen: CEs = control elements (Labels, Buttons, DGVs, ...) und tDS (typisiertes DataSet)
    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht in den Spekulatiusmodus gehen.
    Grundsätzlich nochmal zu den Zugriffsebenen

    Dim
    Wird fast ausschließlich innerhalb von Methoden und Funktionen verwendet. Es gibt hier ein paar Ausnahmen, z.B. Property Get und Set, aber im Regelfall wird mit Dim (auch wenn es möglich ist) nicht klassenweit deklariert. Hierfür gibt es Private.

    Private
    Wird verwendet wenn eine Variable ausschließlich innerhalb der deklararierenden Klasse zugreifbar gemacht werden soll. Also ist die Variable von außerhalb der Klasse nicht erreichbar. Diese Zugriffsebene wird am häufigsten als Pendant zu Dim verwendet um auf Klassenebene zu deklarieren.

    Public
    Logischerweise das genaue Gegenteil von Private. Wird verwendet um klassenübergreifend oder (innerhalb von Modules) global zu deklarieren.

    Protected
    Ist ein geschütztes Element innerhalb einer Klasse und von außerhalb nicht zugreifbar. Der haupsächlich relevante Unterschied zu Private ist, dass Instanzen von erbenden Klassen dennoch auf die Variablen zugreifen können, was bei Private nicht der Fall ist. Beispiel In Klasse Alpha wird

    VB.NET-Quellcode

    1. Protected Property ModuleName As String

    deklarariert und Klasse Beta erbt von Alpha. Dann ist ModuleName auch in Klasse Beta zugreifbar.

    Friend
    Friend ist ähnlich wie Public innerhalb des Projektes / der Assembly zugreifbar jedoch anders als Public nicht Projekt / Assembly übergreifend.

    Es gibt noch einige Kombination aus diesen Schlüsseln beispielsweise Private Protected, um festzulegen dass die Variable nur dann in der Instanz der erbenden Klasse zugreifbar ist, wenn sich die erbende Instanz in der selben Assembly befindet. Oder Protected Friend wo ich bis heute kein gutes Anwendungsbeispiel für gefunden habe, wofür man das braucht, aber da gibt es bestimmt einen.


    Zur Vererbung:

    MustInherit
    Wird verwendet um Abstrakte Basisklassen zu schreiben, die bestimmte Methoden beinhalten müssen (siehe MustOverride).

    Inherit
    Wird verwendet um eine Klasse von einer anderen Klasse erben zu lassen.

    MustOverride
    Wird verwendet um erbende Klassen zu zwingen bestimmte Methoden oder Funktionen aus der Basisklasse zu überschreiben. Kann nur in abstrakten Basisklassen (siehe Mustinherit) verwendet werden.

    Overridable
    Ähnlich wir MustOverride nur ohne den Zwang. Ermöglicht es erbenden Klassen, einzelne Methoden und Funktionen zu überschreiben.

    Overrides
    Wird verwendet um eine Methode / Funktion einer vererbenden Klasse zu überschreiben.

    Shadows
    Shadows ist etwas abstrakter und schwieriger zu erklären. Es wird verwendet um in der Basisklasse deklarierte Elemente (Properties, Subs, Functions, etc.) in einer erbenden Instanz zu überladen und zu verbergen, also quasi auch bis zu einem gewissen Grad zu überschreiben.

    Ich versuche mal ein Anwendungsbeispiel zu geben:
    Wir haben 4 Klassen:

    - Alpha
    - AlphaModel
    - Beta
    - BetaModel

    In Alpha in eine Property deklariert die MyModel heißt und vom Typ AlphaModel ist. Beta erbt nun von Alpha, aber kann mit dem AlphaModel nichts anfangen, weil es das BetaModel braucht. Bedauerlicherweise ist MyModel, das bereits als AlphaModel deklariert ist in die gesamte Logik in Alpha eingebunden, die an Beta vererbt wird und dort auch benötigt wird. MyModel muss als in Beta zu einem BetaModel werden. Das geht mit Shadows sofern BetaModel von AlphaModel erbt und alle grundlegenden Eigenschaften besitzt, für die Logik in Alpha benötigt werden. Also wird in Beta MyModel wie folgt neu deklariert:

    VB.NET-Quellcode

    1. Protected Shadows MyModel As BetaModel


    Ich hoffe das war einigermaßen verständlich. Wie gesagt, Shadows ist abstrakt.


    Ein Computer wird das tun, was du programmierst - nicht das, was du willst.

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von „Yanbel“ ()

    Bartosz schrieb:

    Ups...ich habe heute Morgen ein neues Projekt aufgemacht, extra für diese Tower-Geschichte. Da habe ich Option Strict On nicht angestellt. :whistling:
    In Visual Studio - Empfohlene Einstellungen ist gezeigt, wie man das ProjectTemplate auf Strict On stellt.
    Also die Vorlage aller Projekte, die man neu anlegt.
    Dann kann das nicht mehr passieren, dass man ein neues Projekt anlegt und vergisst, die Deppen-Einstellungen zu korrigieren.