Wie kann ich einen Button "fernclicken"?

Csharp-programmierer · Verfasst: Mo 27.04.15 12:18

Hallo Leute. Wenn ich einen Button2 clicke, dann soll auch der Button1 automatisch geclickt werden. Dafür kenne ich zwei Beispiele:

markieren

C#-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:

private void button2_click(object sender, EventArgs e)
{
 this.button1(sender, e);

 // ODER:

 this.button1.PerformClick();
}

Wenn ich aber auf der Form1 einen Button clicke, dann soll ein Button auf der Form2 automatisch geclickt werden. Ich dachte so:

markieren

C#-Quelltext

1:	public static bool = false;

Wenn ich nun dden Button clicke, wird der Wert true. Und wenn der Wert true ist, dann soll der Button geclict werden.
Wie mache ich das, das der Button überprüft, ob der wert true oder false ist? Ihr könnt mir aber auch andere Ideen vorschlagen. MFG

Moderiert von Th69: C#-Tags hinzugefügt

Ralf Jansen · Verfasst: Mo 27.04.15 12:53

Form1 muß dann Form2 kennen. Genau wie Form1 seinen button1 kennen (ein Variable mit referenz auf den Button) muss damit er daran was aufrufen kann. Wenn Form1 diejenige ist die Form2 erzeugt einfach die konkrete Form2 in einer Klassenvariablen aufheben.

Im bößen Fall das die Form ihre Controls veröffentlicht hat (es gilt auch bei Formen eigentlich das Geheimnisprinzip) kannst du dann aus form1 einfach form2.button1.PerformClick() aufrufen.

Th69 · Verfasst: Mo 27.04.15 13:22

Hallo Csharp-programmierer,

Man sollte nicht GUI-Aktionen auslösen, sondern passende Methoden aufrufen. Also definiere dir eine Methode, und rufe diese dann sowohl im Button1-Click als auch beim Button2-Click auf.

Und bitte lies mal deine PN (oben über "Meine Ecke") und füge demnächst selber die C#-Tags hinzu.

Danke.

Palladin007 · Verfasst: Mo 27.04.15 13:42

Wie Th69 schon geschrieben hat: Lieber passende Methoden definieren und nutzen.

Diesen Gedanken setzt das MVC oder das MVVM-Pattern um.
MVVM (Model-View-ViewModel) funktioniert in Verbindung mit WPF ganz hervorragend, mit Windows Forms geht das aber sicher auch recht gut.
In dem Fall erstellst Du eine Klasse, die alle diese Informationen und Funktionen bereit stellt, welche die Form benötigt - das ViewModel. Die Form (sie ist die View) ruft dann nur noch die Informationen ab und die Methoden für jede einzelne Funktion ab.
Wenn Du dann eine bestimmte Funktion "fernsteuern" willst, dann brauchst Du dafür nicht die Form, sondern nur das Objekt dieser Klasse, wo die Form ihre Daten und Methoden her holt. Das hat auch gleich den schönen Nebeneffekt, dass Du allgemein nicht mehr wissen musst, wie die Form optisch und funktional aufgebaut ist, schließlich kann sich eine GUI auch mal ändern.

Die konkrete Nutzung würde ich dann ungefähr so machen:
Ein Interface, das jede konkrete GUI kapselt. Es muss nicht viel können, nur solche Methoden wie Show oder Hide, außerdem muss es eine Property oder Methode bieten, wo Du dann das ViewModel ablegen kannst. Die konkrete Implementierung des Interfaces für jede View ist dann über eine Factory (such nach Factory Pattern) erreichbar.
Wie die View dahinter aus sieht, ist komplett unwichtig, Du reichst nur noch das benötigte ViewModel umher und überall, wo Du es brauchst, rufst Du über die Factory die benötigte View ab, oder Du rufst die benötigte Funktion direkt auf - fernsteuern eben.

Als kleine Ergänzung: Das Model (nicht ViewModel) bezeichnet die reine Datenklasse, die die Datenbank-Daten bereit hält. Es wird in der Regel vom ViewModel verwendet.

Wie das MVC-Pattern konkret umgesetzt wird, kann ich dir nicht sagen. Ich weiß, wie es strukturiert ist, da ich aber ausschließlich mit WPF arbeite und dabei das MVVM-Pattern nutze, kann ich dir auch nur dazu mehr sagen. Es sollte aber ähnlich ausfallen, da das MVVM-Pattern auf der Idee vom MVC-Pattern aufbaut.

Csharp-programmierer · Verfasst: Mo 27.04.15 18:41

Hallo. Ich weiß nicht, welche Methoden bzw. Klassen ich aufrufen muss. Mit der Variable für einen Button mit referenz, weiß ich auch nicht, wie ich das machen muss. Könnt iht vielleicht ein paar Code- Beispiele machen ?

MFG

Th69 · Verfasst: Di 28.04.15 08:26

markieren

C#-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:

public void DoSomething()
{
  // hier die Aktion ausführen
}

private void button1_click(object sender, EventArgs e)
{
  DoSomething();
}

So kannst du dann ganz normal die Methode DoSomething (natürlich dafür einen passenderen Namen finden) auch von einer anderen Form aus ausführen - sofern diese einer Referenz auf die obige Form-Klasse hat:

markieren

C#-Quelltext

1:	form1.DoSomething();

Csharp-programmierer · Verfasst: Di 28.04.15 13:26

Ich kenne folgende Idee, damit ich von Form2 auf die Funktion zugreifen kann:

markieren

C#-Quelltext

1:
2:
3:
4:

public static void DoSomethin()
{
 //...
}

Aber mit referenzen kenne ich mich nicht aus. MFG

Palladin007 · Verfasst: Di 28.04.15 16:24

Dann schau dir objektorientierte Programmierung an, ohne das Wissen wirst Du nicht weit kommen.

Was ich beschrieben habe, sähe ungefähr so aus:

markieren

C#-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:

public class MyViewModel
{
    public string MyText { get; set; }

    public void DoSomething()
    {
        // TODO: ...
    }
}

public class MyView : Form
{
    public MyViewModel ViewModel { get; set; }

    private void button1_click(object sender, EventArgs e)
    {
        ViewModel.DoSomething();

        // Hierfür ist DataBinding besser geeignet, ich kenne das aber nur unter WPF, daher muss das kleine Beispiel reichen
        MyTextBox.Text = ViewModel.MyText; 
    }
}

public class CoolClass
{
    public void ShowMyViewDialog()
    {
        var myViewModel = new MyViewModel();
        var myView = new MyView() { ViewModel = viewModel };
        myView.ShowDialog();
    }
}

Mit WPF sieht das dann etwas anders aus, da gibt's dann z.B. keine Methode "DoSomething" mehr, sondern ein Command "DoSomethingCommand", an das meine View dann bindet.

Zusätzlich kann man dann noch alles hinter Interfaces abstrahieren:

markieren

C#-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

public interface IMyViewModel
{
    string MyText { get; set; }
    void DoSomething();
}
public interface IView
{
    void Show();
    void ShowDialog();
}
public interface IMyView : IView
{
    IMyViewModel ViewModel { get; set; }
}

public class CoolClass
{
    public void ShowMyViewDialog()
    {
        var myView = ViewFactory.CreateView<IMyView>();
        var myViewModel = new MyViewModel();
        myView.ViewModel = myViewModel;
        myView.ShowDialog();
    }
}

Natürlich musst Du die Interfaces dann auch implementieren, das hab ich mir jetzt gespart.
Die Variante mit den Interfaces hat den Vorteil, dass Du nur noch mit Interfaces arbeitest und nicht mehr wissen musst, wie alles dahinter aus sieht.
Jede View muss dann nur irgendwie der ViewFactory bekannt gemacht werden, wie die View dann aus sieht, ob es WinForms, WPF, ASP.NET oder die Konsole, die am Ende angezeigt wird, ist völlig egal.

PS:
In der View sollte natürlich noch eine Kontrolle eingebaut werden, dass die View immer ein ViewModel bekommt. Man kann das ViewModel z.B. auch direkt über den Konstruktur abfragen, allerdings funktioniert der Designer dann nicht mehr, außer Du legst noch einen parameterlosen Konstruktor an.

	Mitgliederliste
	Gruppen
	Das Team
	Richtlinien
	Synonyme