Wertübergabe einer Form in aufrufende Klasse

[sspeedy]

Mir stellt sich im Moment folgendes Problem, bei dem ich denke, dass es sehr einfach zu lösen ist. Ich komme nur nicht drauf

Ich arbeite mit den WindowsForms und habe ein Hauptfenster, eine sqlVerbindungsklasse, und noch ein Fenster in dem (über 2 textboxes) Username und Passwort abgefragt werden.

Wenn ich nun in meinem Hauptfenster eine SQL Verbindung aufbauen möchte, erstelle ich mir eine Instanz der Verbindungsklasse und kann dann auf die entsprechenden Funktionen der Klasse zugreifen. Derzeit läuft es mit voreingestellten Werten. Also username und passwort fest im Code integriert.

Nun ist das natürlich unsinnig und ich möchte diese vom User eingeben lassen.
Also habe ich mir eine neue Form erstellt mit 2 Textboxes und Buttons (OK, CANCEL).
Wenn ich also nun die Werte benötige erstelle ich mir diese Form und lasse sie anzeigen.

Wie genau übergebe ich dann aber die Werte aus den Textboxes an die Verbindungsklasse?

-----------------------

Oder gibt es vielleicht schon vorgefertigte Forms für Passwortabfragen, so in der Art wie eine MessageBox ?

P.S.: Ich arbeite übrigens mit C# in VS2005

[robert.oh.]

Hallo!

Ich wuerde sagen du erstellst in deiner Form 2 public Properties, ueber welche du auf Username und Password zugreifen kannst.

Beispiel:

public string GetUsername
{
    get { return this.txUsername.Text.Trim(); }
}

In deiner Verbindungsklasse rufst du diese Form mit ShowDialog() auf - die Form ist dann modal. Nach diesem ShowDialog() - Aufruf kannst du in der Klasse ueber die Properties die Werte abfragen.

Beispiel:

InputForm frm = new InputForm();
frm.ShowDialog();
string username = frm.GetUsername;

Hoffe das hilft dir weiter.

[Martin#]

Hallo,

Also ein mögliches Konzept wäre:
Die Hauptform F1 instanziert die Configurationsform F2 und Zeigt diese dann mittels ShowDialog() modal an.
Die F2 hat ausßer den TextBoxen moch einen Cancel und Ok Button welche die "DialogResult" eigenschaft der F2 beschreiben bevor die Form geschlossen wird.
Da es sicher sinnvoll ist, wenn die F2 ihre Daten nach Schließen beibehält, würde ich empfählen eine "Singleton" Klasse daraus zu machen.
Mittels statischer GetInstance methode welche die Form nur einmal instanziert und diese Instanz zurückgibt.

private static F2 instance = null;
public static F2 GetInstance()
{
    if(instance==null)
    {
        instance = new F2();
    }
    return instance;
}

Die Aufrufende Form Sollte nach Schließen der F2, nur über Eigenschaften der F2 auf die Informationen zugreifen (nicht die TextBoxen als public deklarierren um an den Text zu kommen).
In diesem Fall genügt ja sogar nur ein getter bei der Eigenschaft (natürlich kann auch eine methode verwendet werden):
F2 code:

public string Password
{
    get
    {
         return textBoxPassword.Text;
    }
}

Der F1 code würde dann so aussehen:

F2 myF2 = Namespace.F2.GetInstance();
if(myF2.ShowDialog() == DialogResult.OK)
{
    string password = myF2.Password;
}

Eine Erweiterung wäre zum Beispiel ein validierungs methode in der F2.

public bool ValidateInput()
{
    bool ok = false;
    if(Password!=string.Empty && .....)
    {
        ok = true;
    }
    return ok;
}

Hoffe es hilft weiter und ich habe nicht zu viele Fehler gemacht!

[sspeedy]

Super! Vielen Dank euch beiden!
Habs dank euch jetzt endlich geschafft

[Norbert Eder]

Im Sinne der Wartbarkeit, der Vereinfachung würde ich hier eine Datenaustausch-Klasse vorschlagen. Öffentliche Eigenschaften für einen solchen Zweck in Formulare einzubauen ist keine saubere und zukunftssichere Variante.

[Martin#]

Bitte gib uns ein Beispiel für diesen Zweck der Anwendung!

[Norbert Eder]

Beispielsweise indem man eine "Konfigurationsklasse" hat, welche Daten aus der Anwendungskonfiguration (oder woher auch immer) hält. Das könnten unterschiedlichste Dinge sein (muss also nicht nur Username + Passwort sein). D.h. die Konfiguration wird aus einer Konfigurationsdatei in ein Objekt geladen. Die Klasse dazu könnte wie folgt aussehen:

public class DbmsConfiguration
{
    private string _dataProviderFactoryInvariant;
    private string _connectionString;
    private string _username;
    private string _password;
    private string _initialCatalog;

    public string InitialCatalog
    {
        get { return _initialCatalog; }
        set { _initialCatalog = value; }
    }

    public string Password
    {
        get { return _password; }
        set { _password = value; }
    }

    public string Username
    {
        get { return _username; }
        set { _username = value; }
    }

    public string ConnectionString
    {
        get { return _connectionString; }
        set { _connectionString = value; }
    }

    public string DataProviderFactoryInvariant
    {
        get { return _dataProviderFactoryInvariant; }
        set { _dataProviderFactoryInvariant = value; }
    }
}

Der Vorteil dieser Variante liegt darin, dass die Form für die Credential-Eingabe mit diesem Objekt arbeiten kann (auch wenn andere Einstellungen nicht benötigt werden) und das Objekt als gesamtes ohnehin für andere Teile der Anwendung benötigt wird. D.h. keine eigenen Konstrukte für etwas, das allgemein verwendet wird. Zusätzlich könnte man noch einen Validator drüberhängen, der die enthaltenen Daten validiert und entsprechend reagiert. Dies würde dann sowohl beim Laden der Konfiguration funktionieren, als auch bei der Eingabe über die Form.

Hier sind viele Varianten denkbar und das nette dabei: Alles an einem Fleck im Gegensatz zu vielen kleinen Stellen, an denen irgendwelche Änderungen vorgenommen werden.

Weiters: Da hierbei zb. auch der ConnectionString vorhanden ist bzw. der Initial Catalog würden sich noch weitere Möglichkeiten anbieten, auch wenn diese anfangs nicht benötigt werden. Beispielsweise als Liste implementiert kann sehr einfach implementiert werden, auf welchen Catalog zugegriffen werden soll (könnte ja irgendwann einmal gefordert sein).

Der Rest deines Beispiels kann ja so bleiben. Es gibt eben nur eine einzige Property. Über diese wird eben das Konfigurationsobjekt ausgetauscht.