WinForm-Entwicklung, Formularanzeige und Formularwertübertragung

Ich wusste in der Vergangenheit nicht viel über die Anzeige von WinForm-Formularen und die Werteübertragung zwischen Formularen.
Ich habe kürzlich einige WinForm-Entwicklungen durchgeführt, und das verwendete relevante Wissen ist wie folgt organisiert

Formularanzeige in WinForm
Es gibt zwei Methoden zum Anzeigen eines Formulars:
Form.ShowDialog-Methode (das Formular wird als modales Formular angezeigt)
Form.Show-Methode (das Formular wird als modales Formular angezeigt)

Die spezifischen Unterschiede zwischen den beiden sind wie folgt:
1 Nach dem Aufruf der Form.Show-Methode wird der Code hinter der Show-Methode sofort ausgeführt
2. Es wird erst ausgeführt, wenn das Dialogfeld geschlossen wird.
3 Wenn das Formular als modales Formular angezeigt wird, wird das Formular durch Klicken auf die Schaltfläche „Schließen“ ausgeblendet und die DialogResult-Eigenschaft auf DialogResult gesetzt. Abbrechen
Im Gegensatz zu einem nichtmodalen Formular wird die Close-Methode
des Formulars nicht aufgerufen, wenn der Benutzer auf die Schaltfläche „Formular schließen“ des Dialogfelds klickt oder den Wert der Eigenschaft „DialogResult“ festlegt false und das Formular wird ausgeblendet
Auf diese Weise kann ein ausgeblendetes Formular erneut angezeigt werden, ohne eine neue Instanz des Dialogfelds zu erstellen
Da das Formular nicht geschlossen ist, rufen Sie bitte die Dispose-Methode auf, wenn die Anwendung das Formular nicht mehr benötigt des Formulars

Wie kann festgestellt werden, ob ein Formular ein modales Formular ist?
Wenn das Formular mit der Form.Modal-Eigenschaft im modalen Modus angezeigt wird, ist es wahr, andernfalls ist es falsch.
Gemäß der Modal-Eigenschaft des über Show und ShowDialog angezeigten Formulars entspricht es false und true bzw.
Besonderer Hinweis:
Da der Anzeigemodus vor der Formularerstellung nicht bekannt sein kann, entspricht das Modal-Attribut im Formularkonstruktor immer false, sodass wir den Modal-Attributwert nur im Load-Ereignis oder verwenden können danach

Wie bestimme ich die Besitzerbeziehung zwischen Formularen?
Besitzereigenschaft der Form-Klasse: der Besitzer des Formulars
Wenn ein Formular einem anderen Formular gehört, folgt es dem Besitzerfenster Der Körper wird minimiert und geschlossen.
Wenn beispielsweise Form2 dem Formular Form1 gehört und Form1 geschlossen oder minimiert wird, wird auch Form2 geschlossen oder minimiert.

Zum Beispiel in Form Form1
Form2 f2 = new Form2 ( );
f2.ShowDialog ( this );
//oder
f2.Show ( this );
//oder
f2.Owner = this;
f2.ShowDialog( );

Auf diese Weise ist der Besitzer von f2 Form1

B.WinForm-Formularwert
Nachdem wir uns mit der Anzeige von Formularen vertraut gemacht haben, fassen wir die Methoden zur Wertübergabe von Formularen zusammen:

1. Durch den Konstruktor
Eigenschaften: Die Wertübergabe erfolgt in eine Richtung (Werte können nicht sein). aneinander übergeben), die Implementierung ist einfach
Der Implementierungscode lautet wie folgt:
In der Form Form2 
int value1;
string value2;

public Form2 (int value1 , string value2)
{
InitializeComponent ( );

this.value1 = value1;
this.value2 = value2;
}

Rufen Sie dies in Form auf Form1
new Form2 ( 111, "222" ).Show ( ); //Dies überträgt die beiden Werte ​​111, "222" an Form2

2 > Funktionen: Die Wertübertragung erfolgt bidirektional. Ja, die Implementierung ist einfach.
Der Implementierungscode lautet wie folgt:
Definieren Sie einen statischen Mitgliedswert in einer App-Klasse.
Public Class App
{
public static string value;
}

Rufen Sie dies in Form Form1 auf

app.value = "f2"; //Weisen Sie statischen Elementen Werte zu
new Form2 ( ).Show ( ) ; //Form2 anzeigen

in Form2,

this.Text = app.value; //Wert von app.value abrufen
app.value = "Form2"; Weisen Sie app.value einen Wert zu, damit andere Formulare ihn aufrufen können

3. Über den öffentlichen Attributwert des Formulars

Merkmale: Einfache Implementierung
Der Implementierungscode lautet wie folgt:

Definieren Sie ein öffentliches Attribut Form2Value im Formular Form2, um den Textwert von textBox1 abzurufen und festzulegen.

öffentliche Zeichenfolge Form2Value
{
get
{
return this.textBox1.Text;
}
set
{
this.textBox1.Text = value ;
}
}

Call this in form Form1

Form2 f2 = new Form2 ( );
f2.Form2Value = "Ok"; //Gib textBox1 an Form2 Zuweisung Ok
f2.ShowDialog ( );

4. empfohlen)

Features: Einfache Implementierung, flexibel
Der Implementierungscode lautet wie folgt:
In Form Form1
public int Form1Value = 1;

Form2 f2 = new Form2 ( );

f2.ShowDialog ( this ); // Übergeben Sie Form1 als Eigentümer von Form2. Geben Sie Form2

in Formular Form2

// Der Eigentümer von Form2 ist Form1
Form1 f1 = (Form1) this.Owner;
//Der Wert von Form1 ist 1
MessageBox.Show ( f1.Form1Value .ToString ( ) );
//Weisen Sie Form1Value von Form1 den Wert 222 zu
f1.Form1Value = 222;

5. Über den öffentlichen Eigenschaftswert des Formulars und der Application.OpenForms-Eigenschaft

Beschreibung: Application.OpenForms-Eigenschaft: Ruft die Sammlung offener Formulare ab, die zur Anwendung gehören. (Diese Eigenschaft ist in .NET Framework Version 2.0)
Der Implementierungscode lautet wie folgt:
In Form Form1
public int Form1Value = 1;

Form2 f2 = new Form2 ( );
f2.Show ( );

In form Form2
string formName = "Form1";
Form fr = Application.OpenForms [ formName ];

if ( fr != null )
{
Form1 f1 = ( Form1 ) fr;
//Der Wert von Form1 ist 1
MessageBox.Show ( f1. Form1Value.ToString ( ) );
// Weisen Sie dem Form1Value von Form1 den Wert 222 zu:
Definieren Sie die öffentliche Eigenschaft Form2Value im Formular Form2, rufen Sie den Textwert von textBox1 ab und legen Sie ihn fest
und definieren Sie außerdem eine Annahme event

public string Form2Value

{
get
{
           return this.textBox1.Text;
private void button1_Click ( object sender , EventArgs e )
{
if (akzeptieren != null )
{
akzeptieren ( this , EventArgs.Empty ); //Wenn das Formular ein Ereignis auslöst, übergeben Sie die Selbstreferenz
}

In das Formular Form1
Form2 f2 = new Form2 ();
f2.accept += new EventHandler (f2_accept);
f2.Show ( );

void f2_accept ( object sender , EventArgs e )
{
//Der Empfänger des Ereignisses erhält durch eine einfache Typkonvertierung einen Verweis auf Form2
Form2 f2 = (Form2) sender;
//Erhielt textBox1.Text
von Form2 this.textBox1.Text = f2.Form2Value;
}