Hallo,

ich arbeite mich gerade erst in VB.net ein und stehe gerade vor einem Problem. Eine Lösung hierfür habe ich auch nach längerem Suchen nicht finden können. Vielleicht fehlt mir einfach das richtige Schlagwort.

Bsp.: Ich habe eine Regler-Klasse geschrieben, welche einige Klasseneigenschaften aufweist, die genullt sind

Public Class Regler

Dim IstWert As Double = 0
Dim SollWert As Double = 0
Dim ZulAbweichung As Double = 0
Dim AusgangsZust As Boolean = False

Public Sub Verarbeitung ( usw.
...
End Sub
End Class

Nun möchte ich 2 oder mehrere Instanzen dieses Reglers instantiieren, was auch klappt. Allerdings möchte ich dem Nutzer die Möglichkeit geben, z.B. den SollWert und die ZulAbweichung zur Laufzeit jeder der Instanzen zu verändern. Ich möchte also für jede Instanz eine Form öffnen, in der der Nutzer die zugänglichen Klaseneigenschaften konfigurieren kann.

Wie kann ich das anstellen?

Aus der Klasseninstanz heraus ein Formular aufzurufen, welches entsprechende Einstellfunktionen hätte,klappt nicht, weil der Kompiler natürlich noch nicht die instantiierten Klasseneigenschaften kennt, z.B. ReglerA.SollWert = ...

Kann mir einer von euch einen Fingerzeit in die richtige Richtung geben?

Mit Dank und Gruß

Joseph

Hallo (phi)-Const (mir ist die Phi-Taste abhanden gekommen...)

Danke für deine Nachricht.

Mein Gedanke bei dem "DIM" war, dass diese Größen außerhalb der Klassen nicht modifiziert werden können sollen. So schreiben es zumindest die Bücher. Daher war mein Gedanke, eine Form aus meiner Klasse selbst heraus aufzurufen. Damit hätte diese Form dann ja Zugriffsrechte.

Ich glaube das Problem ist, dass die Form nicht "sieht", dass Sie aus der Klasse Regler heraus instantiiert wird, also nicht dazugehört. Es müsste irgendwie mitgeteilt werden, dass sie aus dem gleichen Raum wie die Reglerklasse kommt.

Ich habe es gerade mal probiert. Auch ein Public bringt hier keinen Fortschritt.


Mit Dank und Gruß

Joseph

Hallo,

nein, das ist nicht mein Problem. Klar, dass ich die Klasse erst instantiieren muss wenn ich sie nutzen möchte.

Mein Problem ist: wie kann ich eine Form aus einer instantiierten Klasse heraus aufrufen, um mit dieser dann seine Klasseneigenschaften zu verändern. Das Formular soll zunächst den aktuellen Zustand der gewünschten Klasseneigenschaften anzeigen und dann ggf. die über Steuerelemente geänderten Werte wieder zurück schreiben.

Mein Ansatz bislang stark vereinfacht:

Public Class Regler

Dim IstWert As Double = 0
Dim SollWert As Double = 0
Dim ZulAbweichung As Double = 0
Dim AusgangsZust As Boolean = False

PrivateSub Verarbeitung ( ) 'Funktion, die irgendwas mit den Werten macht
...
End Sub

Public Sub SollWertSetzen (ByVal wert As Double)
'Prozedur, welche die Eigenschaft SollWert für jede Instanz nach außen schreibbar macht
SollWert = wert
End Sub

Public Function SollWertLesen () As Double
'Funktion, welche die Eigenschaft SollWert für jede Instanz nach außen lesbar macht
return SollWert
End Function

Public Sub WerteAendern ()
'Formularaufruf, welches über SollWertLesen und SollWertSchreiben die jeweiligen Objekteigenschaften verändern soll
Form_Konfig.ShowDialog()
End Sub

End Class


Die aufzurufende Formularklasse habe ich erzeugt und in der Datei steht grob

Public Class Form_Konfig

Private Form_Konfig_Load(....)

'Der NumericUpDown soll den aktuellen SollWert aus der jeweiligen Instanz anzeigen
NumericUpDown_SollWert.Value =SollWertLesen()

End Sub
End Class

Natürlich kann das Formular außerhalb der Laufzeit die Methode SollWertLesen() noch nicht erkennen -> der Kompiler meckert.

Doch wie mache ich das richtig? Im Idealfall sollen n Instanzen der Klasse Regler instanziiert sein und jedes Reglerobjekt auf ein eigenes, unabhängiges Formular zugreifen und darüber konfiguriert werden können.

Prozedural programmiert hätte ich das über ein globales Array gelöst, in welches die Regler-Methode (dann ja Funktion) und die Konfigurations-Form gleichberechtigt schreiben und lesen können. Unter OOP wird das umständlicher.

Ich hoffe, dass ich mich etwas klarer ausgedrückt habe.

Mit Dank und Gruß

Joseph

Hallo,

"Du hast eine Klasse Regler.. die größte Frage die ich mir persönlich stelle ist, wieso du Form_Konfig.ShowDialog() aufrufst, ohne ein Objekt der Klasse Form_Konfig zu haben."

Genau das ist ja auch der wunde Punkt. Ich wollte verdeutlichen, was ich erreichen möchte. Aber so kann es nicht klappen.

Ja, die Funktion von Konstruktoren ist mir bekannt. Nein, oft verwendet habe ich sie noch nicht. Wenn, dann in der Form

Dim Reglerobjekt As New Regler

Ich werde mir deinen Ansatz morgen mit klarerem Kopf ansehen. Ich glaube, dass das der gesuchte Ansatz sein könnte.

Ich melde mich morgen.

Vielen Dank!

Mit Gruß

Joseph

Hallo,

wow, vielen Dank für die Antworten.

@EaranMaleasi:

Ich hoffe, du meintest mit deinem Hinweis nur die Darstellungsform, also die Formatierung meines Beitrages. Sonst sag mir bitte, wie ich meine Beiträge verbessern kann.
Was die Formatierung anbelangt: ich hoffe, dass ich das nun besser mache

φConst:

Ich kann deinen Code leider nicht nachvollziehen. Die Stelle verstehe ich und der Kompiler nicht.



Was machst du in der Zeile?



Ich konnte eine solche Form auch nicht nachschlagen.

@ErfinderDesRades:

Danke für deine Arbeit. Ich hoffe, das hilft.

Ich würde deinen Ansatz gerne verstehen, denn offenbar verfolgst du einen ganz anderen Ansatz als ich.



Du erzeugst ein List(of T) Objekt _Reglers mit den Eigenschaften der Klasse Regler. Gut.
Dann übergibst du dem Klassenkonstruktor eine Klasseneigenschaft "Name", mit der du die Instanzen unterscheiden kannst. Dafür legst du in der Klasse Regler eine zusätzliche Public Eigenschaft "Name" an.



Soweit gut. Jede Instanz bekommt nun über den Konstruktor einen mit i indizierten Namen. Jedes erzeugte Objekt wird dann in die List (of T) übernommen. Anschließend kann man die entsprechenden Members der Instanzen über die ListBox ansehen.



Wie die Verarbeitung der Objekteigenschaften nun genau aussieht, ist zunächst zweitrangig. Was mich aber interessiert ist:
Das jeweilige Reglerobjekt ist instantiiert unter einem Objektnamen rgl.



Die instantiierten Objekte unterscheiden sich nach der Instantiierung nur durch die Eigenschaft ".Name".
Nach seiner Erschaffung wird jedes der Objekte in die List(of T) aufgenommen oder nur seine Eigenschaft in diese Liste abgebildet?



Wenn sie nur zum Instantiierungszeitpunkt abgebildet würde, so könnte zwar auf die Eigenschaften im Instanziierungszustand als Kopie zugegriffen werden, eine Veränderung der Eigenschaften über einen Listenzugriff wäre aber nicht möglich.
Oder ist die Abbildung der Objekteigenschaften über die List(of T) transparent, also eine Art Zeiger auf das Objekt zur Laufzeit? Das wäre natürlich eine mächtige Sache.

Ich habe nur eine Ahnung was List(of T) grob macht aber so tief ist mein Verständnis noch nicht. Ich habe es bislang für Protokolllisten verwendet, bei denen statische Größen abgelegt wurden.

Wie könnte ich nach deinem Beispiel schreibend z.B. die Objekteigenschaft



während der Lebenszeit z.B. des Reglerobjekts mit rgl.Name = Regler1 verändern?

Ich danke dir sehr für die ausführliche Darstellung. Als Anfänger ist ein konkretes Beispiel viel mehr Wert als eine abstrakte Darstellung.

Mit Dank

Joseph