mit Klick in Form2 alles beenden

[Marcel@Beginning]

Hallo, und noch eine Frage hab ich.

Habe leider keine Antworten bei Google gefunden.

Ich habe eine Form1 und eine Form2.

Ich öffne nun mit einem button in Form1 Form2.
und nun möchte ich mit Klick auf button in Form2, Form2 und Form1 beenden.

habs mal so probiert:


private void button1_Click(object sender, EventArgs e)
{
this.Close();
new Form1().Close();

}


doch so schliesst es mir nur Form2. Was mache ich falsch?

Vielen Dank für eure Antworten.

Lg Marcel

[gfoidl]

Zum Beenden der Anwendung:
[highlight=c#]
private void button1_Click(object sender, EventArgs e)
{
Application.Exit();
}
[/highlight]

In deinem Beispiel wird zwar Form2 geschlossen und gleichzeitig Form1 erneut erstellt und geschlossen - ist eher Murks.

mfG Gü

[gfoidl]

Lies aber zuerst das OpenBook . Dann sind die meisten (alle) deiner Fragen auch für dich einfach zu beantworten

mfG Gü

[Marcel@Beginning]

OK, mach ich mal. Is aber extrem gross...

Vielen Dank für all deine Antworten.

Lg

[gfoidl]

Is aber extrem gross...

und noch nicht alles wird dabei behandelt. Ist halt programmieren

[Frischmilch]

Alternative Methode, wenn du nicht gleich die ganze Application beenden willst (just in case):
Übergib deiner Form2 im konstrukter eine Referenz der aufrufenden Form1 Instanz, damit lässt sich dann gezielt die aufrufende Form1 Instanz beenden. Dein "Denk"-Fehler liegt in
[highlight=c#]
new Form1().Close()
[/highlight]
Damit erzeugst du eine neue Instanz der Form1 Klasse, welche du sofort, durch Aufruf der Methode Close(), wieder zerstörst . Du beendest also eine Form1 Instanz, aber eben nicht die Gewünschte.

Alternative Lösung
Form2 Klasse
[highlight=c#]
private Form1 _myForm;

public Form2 (ref Form1 form)
{
_myForm1 = form;
}

private void button1_Click(object sender, EventArgs e)
{
this.Close();
_myForm1.Close();
}
[/highlight]

Eventuell muss man den Aufruf zum schließen der Form1 Instanz in den Eventhandler des Closing-Events verschieben, wenn nach this.Close() nichts mehr abgearbeitet wird.

Eine noch viel schönere Lösung (wegen weniger starker Abhängigkeit), wäre es über eine Property der Form2 zu bestimmen, ob Form1 auch geschlossen werden soll und diese beim zurückkehren von Form2 in Form1 zu prüfen.

[gfoidl]

@Frischmilch:

Einige Anmerkungen:

• Ein Verweis auf eine andere Form braucht nicht im Konstruktor übergeben werden, sondern es kann die Owner-Eigenschaft dazu verwendet werden.
• public Form2 (ref Form1 form) Das ref-Schlüsselwort muss nicht verwendet werde da eine Form ein Referenztyp ist. Es wäre nur notwendig wenn in der Methode (hier Konstruktor) eine neues Instanz erstellt wird und sich somit der Verweis ändert, das ist hier aber nicht der Fall.

mfG Gü

[Jürgen Thomas]

Ergänzend zu Gü's Hinweis: Das rufende Formular darf etwas über ein abhängiges Formular wissen, also Form1 hat Kontrolle über Form2. Umgekehrt darf das nicht sein: Form2 darf keine Kontrolle über Form1 haben. Also sollte es auch keine Kenntnis über eine Instanz von Form1 haben.

Für solche Querverbindungen sind Delegates sinnvoll: Wenn Form1 will, dass Form2 etwas mit sich (also Form1) macht, dann wird in Form1 ein EventHandler z.B. für FormClosed erstellt (einschließlich this.Close), dieser EventHandler wird an Form2 übergeben und dort an Form2.FormClosed gehängt. (Bitte nicht schimpfen: diese Anleitung ist sehr knapp formuliert und soll nur das Prinzip verdeutlichen; ich hoffe, das ist ansatzweise gelungen.)

Jürgen

[gfoidl]

Das rufende Formular darf etwas über ein abhängiges Formular wissen, also Form1 hat Kontrolle über Form2. Umgekehrt darf das nicht sein: Form2 darf keine Kontrolle über Form1 haben. Also sollte es auch keine Kenntnis über eine Instanz von Form1 haben.

Das ist eher Anschauungssache ob ein "Slave" etwas von seinem "Master" weiß oder nicht.

ZB verfügen alle Controls über Eigenschaften die den Parent, also den übergeordneten Container (Master) zurückgegeben. Viele Aufgaben werden dadurch vereinfacht.

Mit diesem Beispiel, indem der Slave (Form2) weiß wer sein Master (Form1) ist, geht das ganz einfach.

Form1:
[highlight=c#]
using System;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
Form2 form2 = new Form2();
form2.Owner = this;
form2.Show();
}
}
}
[/highlight]

Form2:
[highlight=c#]
using System;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
public partial class Form2 : Form
{
public Form2()
{
InitializeComponent();
}

private void button1_Click(object sender, EventArgs e)
{
this.Owner.Close();
}
}
}
[/highlight]

mfG Gü

[Frischmilch]

Man möge auch meinem letzten Satz meines vorherigen Posts lesen, daraus wird man erschließen können, dass ich auch noch eine andere Methode genannte habe um der etwas zu starken Kopplung zu entgehen, (jaja Publisher-Subscriber winkt) was aber für diesen Fall kaum eine Rolle spielen dürfte. Zumal Form2 ja sowieso über die Owner Property Form1 bereits kennt (Merci gfoidl).
P.S. gfoidl: Das ref Schlüsselwort ist in der Tat unnötig, da bei Objekten immer die Referenz übergeben wird, aber ich dachte man sieht schöner, dass man mit der wirkklich gleichen Instanz arbeitet. Im übrigen versteh ich nicht ganz was bei einem einem new Aufruf anderst sein soll? Referenz bleibt Referenz.

[gfoidl]

Im übrigen versteh ich nicht ganz was bei einem einem new Aufruf anderst sein soll? Referenz bleibt Referenz.

Schau dir mal dieses Beispiel an und achte auf die Ausgaben:
[highlight=c#]
using System;

namespace ConsoleApplication1
{
class Program
{
static void Main()
{
Foo foo = new Foo { Name = "Main" };
Console.WriteLine(foo.Name); // Main

Do1(foo);
Console.WriteLine(foo.Name); // Main

Do2(ref foo);
Console.WriteLine(foo.Name); // Do2

Do3(out foo);
Console.WriteLine(foo.Name); // Do3

Console.ReadKey();
}

private static void Do1(Foo foo)
{
foo = new Foo { Name = "Do1" };
}

private static void Do2(ref Foo foo)
{
foo = new Foo { Name = "Do2" };
}

private static void Do3(out Foo foo)
{
foo = new Foo { Name = "Do3" };
}
}

public class Foo
{
public string Name { get; set; }
}
}
[/highlight]

Erklärung(sversuch):

Wenn eine Instanz eines Objekts erstellt wird dann wird im Speicher (RAM) dafür Platz gemacht und die Startadresse dieses Speicherbereichs als int-Wert zurückgegeben. Dieser int-Wert ist die Referenz (Verweis).

D.h. beim Methoden-Aufrufen in denen ein Referenz-Typ übergeben wird wird tatsächlich nur ein int-Wert zum Beginn des Speicherblocks des Objekts übergeben.
Wird dann ein neues Objekt erstellt - also ein neuer Speicherbereich - und somit ein neuer int-Wert, der wiederrum ein Wert-Typ ist, dann kennt die aufrufende Methode das neue Objekt nicht da der int-Wert nach Rücksrpung aus der Methode wieder den ursprünglichen Wert hat (Wert-Typ).

Um diesem zu begegnen kann man die Schlüsselwörter ref oder out verwenden.

Hoffe ich habs ein bisserl verständlich machen können.

mfG Gü

[Frischmilch]

Okay ich glaub ich habs verstanden.. sieht für mich letzten endes aber etwas unkonsequent aus. Zumal der Nutzen im Zusammenhang mit new doch sehr... fragwürdig ist. Einfach ein Objekt austauschen, macht man doch nur, um jemanden zu ärgern ;-).

[gfoidl]

Ja, stimmt ist eher von akademischer Natur

Schadet aber trotzdem nicht wenn man das weiß

mfG Gü