Funktion gliedern, nur mit punkten

  • VB.NET

Es gibt 8 Antworten in diesem Thema. Der letzte Beitrag () ist von VaporiZed.

    Funktion gliedern, nur mit punkten

    Hay na,

    es muss doch eine Möglichkeit geben, seine Funktionen zu gliedern.
    Man hat ja in Net die Möglichkeit einige Funktionen aufzurufen. Diese sind ja auch untergliedert und durch Punkte(.) getrennt. Wie z.B.

    Quellcode

    1. ListView_Playlist.Columns.Add("bla")


    Das ist ja auch nichts anderes, als eine Funktion- nur eben gegliedert. (Durch Punkte)

    Ich habe eine Funktion, bei der ich ähnliches erreichen möchte.
    Ich will AccountManager().Create_Acc aufrufen, um einen Account zu erstellen. Aber in der selben Funktion soll auch ein Account gelöscht werden können. Wie stelle ich das am geschicktesten an?


    Fantasiecode:

    Quellcode

    1. Public Shared Function AccountManager()
    2. Function Create_Acc()
    3. 'Create
    4. End Function
    5. Function Delete_Acc()
    6. 'Delete
    7. End Function
    8. End Function

    Hallo @Twerpyfie

    Die einfachste Art mal so was zu machen ist der Weg über Extension.
    docs.microsoft.com/en-us/dotne…cedures/extension-methods

    Hab hier mal ein Beispiel gemacht, für eine ganz normale Integer. Solche Extension lassen sich auch für ListView etc. machen.
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Option Strict On
    2. Option Explicit On
    3. Imports System.Runtime.CompilerServices
    5. Public Module TestExtentionsHelper
    6. Public Sub Main()
    7. Dim numeric = 10
    8. Dim summand = 10
    9. Dim subtrahend = 4
    10. Dim multiplikand = 3
    11. Dim divisor = 6
    13. Dim result = numeric.
    14. Addition(summand).
    15. Subtraction(subtrahend).
    16. Multiplication(multiplikand).
    17. Division(divisor)
    19. Stop
    20. End Sub
    21. End Module
    23. Public Module ExtentionHelpers
    24. <Extension>
    25. Public Function Addition(numeric As Int32, summand As Int32) As Int32
    26. Return numeric + summand
    27. End Function
    28. <Extension>
    29. Public Function Subtraction(numeric As Int32, subtrahend As Int32) As Int32
    30. Return numeric - subtrahend
    31. End Function
    32. <Extension>
    33. Public Function Multiplication(numeric As Int32, multiplikand As Int32) As Int32
    34. Return numeric * multiplikand
    35. End Function
    36. <Extension>
    37. Public Function Division(numeric As Int32, divisor As Int32) As Int32
    38. Return numeric \ divisor
    39. End Function
    40. End Module


    Des weiteren gäbe es noch die Lambda expressions. Ein sehr mächtiges Werkzeug.
    Die kann man auch selber machen. Man muss sich dafür aber gründlich einarbeiten.
    docs.microsoft.com/en-us/dotne…edures/lambda-expressions
    docs.microsoft.com/en-us/dotne…rators/lambda-expressions

    Freundliche Grüsse

    exc-jdbi

    Mach die ne separate Klasse. Dort wiederum kannst du Shared Functions implementieren. Der aufruf wäre dann z.B. MyClass.DoSomeStuff()
    "Gib einem Mann einen Fisch und du ernährst ihn für einen Tag. Lehre einen Mann zu fischen und du ernährst ihn für sein Leben."

    Wie debugge ich richtig? => Debuggen, Fehler finden und beseitigen
    Wie man VisualStudio nutzt? => VisualStudio richtig nutzen

    @Twerpyfie Vielleicht bemühen wir uns erst mal, Dinge beim selben Namen zu nennen.
    In VB.NET gibt es Klassen und Module.
    Um auf die Funktionalität von Klassen zugreifen zu können, muss diese Klasse instanziiert werden,
    auf die Funktionalität von Modulen kann unmittelbar zugegriffen werden.
    Funktionalität steht hier für Methoden (Subs, Functions), Properties, Variablen usw.
    Dazu steht zwischen dem Namen der Klassen-Instanz bzw. dem Namen des Moduls und der Funktionalität ein ..
    Diese Abtrennung würde ich nicht "Untergliederung" nennen wollen, weil es da kein gemeinsames Ordnungsschema gibt.
    Tatsächlich ermöglicht ein . den Zugriff auf die Funktionalität der Funktionalität, wenn ich das mal so nennen darf.

    VB.NET-Quellcode

    1. Dim frm = New Form1() ' Instanziierung der Klasse Form1
    2. frm.Text = "bla" ' Text ist Property von Form1
    3. MessageBox.Show(frm.Text.Length.ToString() ' Length ist Property von String
    4. ' ToString() ist Basis-Methode von Object, hier speziell von Integer
    5. frm.ShowDialog() ' ShowDialog() ist Methode von Form.
    Versuch das ganze mal zu verstehen und formuliere Dein Problem so, dass wir es so verstehen, wie Du es meinst.
    Ansonsten reden wir von Spekulatius.
    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!

    Meinst du sowas?

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Namespace AccountManager
    3. Public Class Account
    5. Public Property ID As Integer
    6. Public Property AccountName As String
    7. Public Property FirstName As String
    8. Public Property LastName As String
    10. Public Shared Function Create() As Account
    11. Return New Account
    12. End Function
    14. End Class
    16. Module Manager
    18. Private ActiveID As Integer
    19. Private ReadOnly Property GetNextID As Integer
    20. Get
    21. ActiveID += 1
    22. Return ActiveID
    23. End Get
    24. End Property
    26. Public Property Accounts As New List(Of Account)
    28. Public Sub Delete(Acc As Account)
    29. Accounts.Remove(Acc)
    30. End Sub
    32. Public Sub Add(Acc As Account)
    33. Accounts.Add(Acc)
    34. End Sub
    36. Public Sub Clear()
    37. Accounts = New List(Of Account)
    38. End Sub
    40. Public Sub Add(AccountName As String, FirstName As String, LastName As String, Optional ID As Nullable(Of Integer) = Nothing)
    41. Dim Acc As Account = Account.Create
    43. With Acc
    44. If ID IsNot Nothing Then
    45. .ID = ID.Value
    46. Else
    47. .ID = GetNextID
    48. End If
    50. .AccountName = AccountName
    51. .FirstName = FirstName
    52. .LastName = LastName
    53. End With
    54. Accounts.Add(Acc)
    55. End Sub
    57. End Module
    59. End Namespace

    Bilder

    • Accounts.PNG

      6,31 kB, 278×170, 192 mal angesehen

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

    Vielen Dank für eure ausführlichen Antworten!

    Jede Antwort in diesem Thread hat mir bisher geholfen.
    Ich sehe aber, dass ich da noch viel Nachholbedarf hab.

    EDIT:
    Ich hab mal meine Frage durchgelesen. Jetzt ist mir auch klar, warum man das nicht versteht.
    Was ich ursprünglich meinte war, dass man Funktion an Funktion reiht:
    Aber es sollte noch viel tiefer gehen. So wie ich es erklärt hatte ließe es sich ja einfach mit einer Funktion regeln.

    Egal

    Jetzt heißt es lernen, Danke :)

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

    Twerpyfie schrieb:

    VB.NET-Quellcode

    1. ListView_Playlist.Columns.Add("bla")
    Das ist ja auch nichts anderes, als eine Funktion- nur eben gegliedert. (Durch Punkte)
    na doch schon was ganz anneres:
    Also es ist ein Objekt, nämlich das ListView.
    Dieses Objekt hat viele Eigenschaften und Methoden, unter anderem die Eigenschaft Columns.
    Columns ist auch ein Objekt mit vielen Eigenschaften und Methoden, unter anderen die Methode Add()
    Also es ist nicht eine "Funktion- nur eben gegliedert", sondern es ist die Funktion eines Objekts eines Objekts. Und mit "es" ist hier die Methode Add() gemeint.

    Siehe auch Grundlagen: Fachbegriffe

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „ErfinderDesRades“ ()

    @Twerpyfie meinst du so etwas:


    Falls ja, sowas nennt sich FluentAPI und ist oft in ORMs (Object-Relational-Mapper) vorallem aber fast überall im neuen .NET Core zu finden, was nicht schon vom alten .NET Framework übernommen wurde.

    Sowas kann man natürlich selbst Implementieren, hier mal zwei einfache Beispiele dafür:
    c-sharpcorner.com/article/crea…luent-api-in-c-sharp-net/
    assist-software.net/blog/how-d…luent-interface-pattern-c

    Letztenendes hat das auch was von funktionaler Programmierung. Man gibt ein Objekt in eine Funktion rein, ein (ggf. verändertes) Objekt wird zurückgegeben und dann ruft man dafür ebenfalls wieder eine Klassenfunktion auf.
    Also z.B. A.B().C(). B ist eine Funktion von A, diese gibt ein Objekt zurück. Und für dieses Objekt ruft man Funktion C auf.
    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.

Facebook
Telefonspende