Hallo,

wie ist es möglich in einem Window1 ein weiteres Window2 zu öffnen und dann darin vom Window1 aus z.B. UserControls zu manipulieren?

 

Im Window1:

 


Window neuesFenster = new Window();


neuesFenster.Show();


//Bis hier hin funktioniert alles ...


neuesFenster.nameEinesLabels = "blabla"; //Funktioniert nicht -.-

Im Window2 befindet sich nur ein Label mit dem Namen "nameEinesLabels"

Wie kann ich den Text im Label vom Window1 aus ändern?

 

Gruß,

ReiniXXL

Ich könnte mir hier mehrere Ansätze vorstellen...

Wenn du dieses Label nur einmal setzen möchtest könntest du im Konstruktor des Fenster diesen Wert übergeben,
und dann entsprechend in deiner Klasse setzen.

Oder du könntest ein Property für dieses Label in deiner Window Klasse setzen und dann im setter den Wert entsprechend setzen.

//Vorschlag 1:
Window neuesFenster = new Window("Ich bin der Labeltext");
neuesFenster.Show();

//Vorschlag 2:

//Window Klasse
public string lblText
{
get{ return nameEinesLabels.Text}
set{ this.nameEinesLabels.Text = value}
}

//Andere Klasse:
Window neuesFenster = new Window();
neuesFenster.Show();
neuesFenster.lblText = "Ich bin der Labeltext";

Hoffe ich konnte helfen
Weiti

Hallo ReiniXXL,

ich versuche Dir mal die Grundlagen etwas näher zu bringen. Falls Du irgendwo nicht mitkommst, dann frage nochmal genau nach ab wo Du die Thamtik nicht mehr verstehst, denn ganz so trivial wie man meinen könnte ist es nämlich nicht; ich fang einfach mal an:

1. Zugriff auf Controls eines Fensterobjektes:

Die Zugriffe auf die Controls eines Fensters sind durch das Schlüsselwort "protected" von außen gesperrt. Deshalb kannst Du nicht von Fenster1 auf Fenster2-Controls zugreifen. Das hat auch seinen guten Grund: Die Zugriffe müssen synchronisiert werden. Deshalb kannst Du folgendes tun...

2. Zugriffsmöglichkeit anbieten:

Du kannst dem Fenster2 einen Zugriff einbauen. Das machst Du am Besten über eine öffentliche Methode. Das Ganze sieht dann in etwa so aus:

public partial class MyFenster2 : System.Windows.Forms.Form
{
        // Hier wird eine öffentliche Methode definiert
        public void SetMyLabelText(string textToSet)
        {
            // hier kann der Labeltext gesetzt werden
        }
}

Aber: wie oben bereits erwähnt, muss der Zugriff auf die Fenstercontrols synchronisiert werden.
Hintergrundwissen:
Das Fenster in Windows darf nur aus einem eigenen Thread heraus verändert werden. Ein Zugriff von außen direkt auf die Controls ist aufgrund vom Windows Betriebssystem leider her gar nicht in diesem Thread. Deshalb muss hier etwas "getrickst" werden...

3. Den Zugriff synchronisieren:

Man kann den Zugriff synchronisieren, indem man untersucht, ob der Zugriff aktuell aus dem betreffenden Thread erfolgt, der für das Fenster gedacht ist. Hier bietet das Fenster die Möglichkeit mittels InvokeRequired die Überprüfung durchzuführen. Der Trick besteht darin, die Aufrufe so lange sich wiederholen zu lassen, bis der Zugriff in dem zuständigen Thread erfolgt. Für jeden Zugriff, wo das nicht passt wird die öffentliche Methode immer wieder durch sich selbst aufgerufen:

public partial class MyFenster2 : System.Windows.Forms.Form

{

public partial class MyFenster2 : System.Windows.Forms.Form
{
        // Das wird benötigt, damit die Methode sich selbst aufrufen kann
        public delegate void OneParameterDelegate<T>(T parameter);


        // Hier wird eine öffentliche Methode definiert
        public void SetMyLabelText(string textToSet)
        {
            // hier kann der Labeltext gesetzt werden
            if (InvokeRequired)
            {
                // hier wird sich selbst aufgerufen, weil nicht im richtigen Thread
                this.BeginInvoke(new OneParameterDelegate<string>(SetMyLabelText), textToSet);
            }
            else
            {
                myLabel.Text = textToSet;
            }
        }

}

Das sieht wirklich mächtig kompliziert aus, aber wenn man es erst einmal verstanden hat, dann ist es relativ einfach. Noch einmal kurz erklärt: Die Zeile

public delegate void OneParameterDelegate<T>(T parameter);

definiert einen so genannten Delegaten. Ein Delegat ist einfach nur eine Definition, wie ein Rückruf auszusehen hat. in diesem Fall hat der Delegat den Namen "OneParameterDelegate", er definiert einen Rückruf, der keinen Rückgabewert hat (weil void), und er nimmt einen generischen Parameter vom Typ "T" an. Das "T" hält einem die Möglichkeit jeden Typen erst beim Erzeugen festzulegen.
Deshalb ist der Ablauf folgender:

if (InvokeRequired)

hier wird überprüft, ob ein synchronisierter Zugriff gerade erfolgt, falls nicht, dann erfolgt ein Selbstaufruf:

this.BeginInvoke(new OneParameterDelegate<string>(SetMyLabelText), textToSet);

Selbstaufruf ist hier mit einem Rückruf gleichzusetzen, und das "BeginInvoke" sorgt dafür, dass der Rückruf im nächsten Thread erfolgt. Außerdem wird der Rückruf hier mit einem Parameter und dem Typ "T"=string erzeugt, das muss so sein, weil die Methode "SetMyLabelText" auch einen string "textToSet" vorgibt.
Sollte es sich um einen synchroniserten Zugriff handeln (dann sind wir im richtigen Thread, dann kann der Text des Labels gesetzt werden:

myLabel.Text = textToSet;

4. DerZugriff von außen
Mit der Definition von oben hast Du alle Voraussetzungen, um von außen einen Zugriff auf das Label zu ermöglichen (hier im Beispiel nur der Text des Labels, alle anderen Eigenschaften funktionieren genauso). Somit musst Du in Deinem 1. Fenster nur noch folgendes aufrufen:

Window neuesFenster = new Window();
neuesFenster.Show();

neuesFenster.SetMyLabelText("blabla");

So, ich hoffe das Beispiel bringt Dich weiter?

Viele Grüße
Timo

Wow du hast dir echt viel Mühe gemacht, Timo. Das muß auch mal gelobt werden. Tolle Arbeit.

Vielen Dank! Ihr habt mir sehr weiter geholfen