Wiele okien – dodawanie i wymiana danych

Po co wiele okien?

Do tej pory Twoje aplikacje miały jedno okno – MainWindow. W prawdziwych programach często potrzeba więcej okien: okno logowania, okno „O programie”, formularz dodawania nowego rekordu, okno ustawień, okno ze szczegółami wybranego elementu.

Typowe zastosowania dodatkowych okien:

Dodawanie nowego okna do projektu

W Visual Studio kliknij prawym przyciskiem na nazwę projektu w Eksploratorze rozwiązań → Dodaj → Nowy element… → wybierz szablon „Okno (WPF)” → nadaj nazwę, np. OknoSzczegoly.xaml → Dodaj.

Visual Studio utworzy dla Ciebie parę plików – dokładnie tak samo jak przy MainWindow:

<Window x:Class="MojaAplikacja.OknoSzczegoly"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="OknoSzczegoly"
        Height="300"
        Width="400">
    <Grid>

    </Grid>
</Window>

Otwieranie okna – Show()

Żeby otworzyć nowe okno z poziomu MainWindow, tworzysz jego obiekt (tak jak każdy inny obiekt w C#) i wywołujesz metodę Show().

<Button Content="Pokaż szczegóły"
        Click="btnPokazSzczegoly_Click" />

private void btnPokazSzczegoly_Click(object sender, RoutedEventArgs e)
{
    // 1. Tworzymy obiekt nowego okna (tak jak każdy inny obiekt)
    OknoSzczegoly okno = new OknoSzczegoly();

    // 2. Pokazujemy je na ekranie
    okno.Show();
}

Okno modalne – ShowDialog()

Czasem chcesz, żeby użytkownik musiał obsłużyć nowe okno, zanim wróci do reszty aplikacji – np. formularz logowania, okno z pytaniem „czy na pewno usunąć?”. Do tego służy ShowDialog().

private void btnDodajUcznia_Click(object sender, RoutedEventArgs e)
{
    OknoDodawania okno = new OknoDodawania();
    okno.ShowDialog();

    // Ten kod wykona się DOPIERO po zamknięciu okna "okno"!
    MessageBox.Show("Okno dodawania zostało zamknięte");
}

Show() vs ShowDialog() – porównanie

Przekazywanie danych DO nowego okna

Często nowe okno potrzebuje jakichś danych z okna głównego – np. okno szczegółów ucznia potrzebuje wiedzieć, którego ucznia pokazać. Są dwa sposoby.

Sposób 1 – przez konstruktor

Najczystszy sposób – dodajesz do klasy okna własny konstruktor, który przyjmuje dane jako parametry.

public partial class OknoSzczegoly : Window
{
    // Domyślny konstruktor – WYMAGANY, zostaje bez zmian
    public OknoSzczegoly()
    {
        InitializeComponent();
    }

    // Własny, dodatkowy konstruktor – przyjmuje dane
    public OknoSzczegoly(string imie, int wiek)
    {
        InitializeComponent();

        // Od razu wypełniamy kontrolki przekazanymi danymi
        lblImie.Text = $"Imię: {imie}";
        lblWiek.Text = $"Wiek: {wiek} lat";
    }
}

private void btnPokazSzczegoly_Click(object sender, RoutedEventArgs e)
{
    // Wywołujemy NASZ konstruktor, podając dane
    OknoSzczegoly okno = new OknoSzczegoly("Anna Kowalska", 17);
    okno.Show();
}

Sposób 2 – przez właściwość publiczną

Alternatywa: zamiast konstruktora, dodajesz publiczną właściwość i ustawiasz ją po utworzeniu okna, ale przed jego pokazaniem.

public partial class OknoSzczegoly : Window
{
    // Publiczna właściwość – dostępna z zewnątrz klasy
    public string ImieUcznia { get; set; }
    public int    WiekUcznia { get; set; }

    public OknoSzczegoly()
    {
        InitializeComponent();
    }

    // Zdarzenie Loaded – wykonuje się TUŻ PRZED wyświetleniem okna,
       gdy właściwości są już ustawione
    private void Window_Loaded(object sender, RoutedEventArgs e)
    {
        lblImie.Text = $"Imię: {ImieUcznia}";
        lblWiek.Text = $"Wiek: {WiekUcznia} lat";
    }
}

private void btnPokazSzczegoly_Click(object sender, RoutedEventArgs e)
{
    OknoSzczegoly okno = new OknoSzczegoly();

    // Ustawiamy właściwości ZANIM pokażemy okno
    okno.ImieUcznia = "Anna Kowalska";
    okno.WiekUcznia = 17;

    okno.Show();
}

Przekazywanie danych Z POWROTEM do okna głównego

To odwrotna sytuacja: użytkownik wypełnia formularz w nowym oknie (np. „Dodaj ucznia”), klika „Zapisz”, i okno główne musi odebrać te dane. Tutaj właśnie przydaje się ShowDialog() z sekcji 4.

Sposób 1 – właściwość publiczna (najprostszy)

<Window x:Class="MojaAplikacja.OknoDodawania" ... Title="Dodaj ucznia" Width="300" Height="200">
    <StackPanel Margin="15">
        <TextBlock Text="Imię i nazwisko:" />
        <TextBox x:Name="txtImie" Margin="0,4,0,12" />

        <Button Content="Zapisz"
                Click="btnZapisz_Click" />
    </StackPanel>
</Window>

public partial class OknoDodawania : Window
{
    // Tu "wystawiamy" wynik na zewnątrz
    public string WpisaneImie { get; private set; }

    public OknoDodawania()
    {
        InitializeComponent();
    }

    private void btnZapisz_Click(object sender, RoutedEventArgs e)
    {
        if (string.IsNullOrWhiteSpace(txtImie.Text))
        {
            MessageBox.Show("Podaj imię!");
            return;
        }

        WpisaneImie = txtImie.Text;   // zapisujemy wynik do właściwości
        Close();                     // zamykamy to okno
    }
}

private void btnDodajUcznia_Click(object sender, RoutedEventArgs e)
{
    OknoDodawania okno = new OknoDodawania();

    // ShowDialog() CZEKA aż okno się zamknie – dopiero potem lecimy dalej
    okno.ShowDialog();

    // Tutaj okno jest już zamknięte, możemy bezpiecznie odczytać dane
    if (!string.IsNullOrEmpty(okno.WpisaneImie))
    {
        lstUczniowie.Items.Add(okno.WpisaneImie);
    }
}

Sposób 2 – DialogResult (informacja OK/Anuluj)

DialogResult to specjalna właściwość wbudowana w każde okno – mówi „czy użytkownik zatwierdził, czy anulował”. Świetnie współpracuje z właściwościami publicznymi z poprzedniego przykładu.

public partial class OknoDodawania : Window
{
    public string WpisaneImie { get; private set; }

    public OknoDodawania()
    {
        InitializeComponent();
    }

    private void btnZapisz_Click(object sender, RoutedEventArgs e)
    {
        if (string.IsNullOrWhiteSpace(txtImie.Text))
        {
            MessageBox.Show("Podaj imię!");
            return;
        }

        WpisaneImie = txtImie.Text;
        DialogResult = true;   // ← oznacza "zatwierdzono" i AUTOMATYCZNIE zamyka okno!
    }

    private void btnAnuluj_Click(object sender, RoutedEventArgs e)
    {
        DialogResult = false;   // ← oznacza "anulowano" i zamyka okno
    }
}

private void btnDodajUcznia_Click(object sender, RoutedEventArgs e)
{
    OknoDodawania okno = new OknoDodawania();

    // ShowDialog() zwraca bool? – to co ustawiliśmy w DialogResult
    bool? wynik = okno.ShowDialog();

    if (wynik == true)   // użytkownik kliknął "Zapisz", nie "Anuluj"
    {
        lstUczniowie.Items.Add(okno.WpisaneImie);
    }
    // jeśli wynik == false lub null – użytkownik anulował, nic nie robimy
}

Zamykanie okna z kodu

Każde okno (również MainWindow) ma metodę Close(), którą wywołujesz, żeby je zamknąć programowo – np. po kliknięciu przycisku „Anuluj” albo „Zamknij”.

private void btnZamknij_Click(object sender, RoutedEventArgs e)
{
    Close();   // zamyka OKNO, w którym jest ta metoda
}

// Jeśli mamy referencję do otwartego okna, możemy je zamknąć z innego miejsca
OknoSzczegoly okno = new OknoSzczegoly();
okno.Show();

// ... później, gdzie indziej w kodzie:
okno.Close();

Zdarzenia Closing i Closed

Czasem chcesz coś zrobić tuż przed zamknięciem okna (np. zapytać „czy na pewno?”) albo tuż po jego zamknięciu. Do tego służą dwa zdarzenia.

<!-- XAML: <Window ... Closing="Window_Closing"> -->

private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
    MessageBoxResult wynik = MessageBox.Show(
        "Czy na pewno chcesz zamknąć okno? Niezapisane zmiany zostaną utracone.",
        "Potwierdzenie",
        MessageBoxButton.YesNo,
        MessageBoxImage.Warning);

    if (wynik == MessageBoxResult.No)
    {
        e.Cancel = true;   // anulujemy zamknięcie okna!
    }
}

private void Window_Closed(object sender, EventArgs e)
{
    // Okno jest już zamknięte - tutaj można np. zwolnić zasoby,
       zatrzymać timer, wyrejestrować się z jakiegoś zdarzenia
    _timer?.Stop();
}

Dostęp do okna głównego z okna podrzędnego

Czasem okno podrzędne chce bezpośrednio „dotknąć” kontrolki w oknie głównym – np. odświeżyć listę bez czekania na ShowDialog(). Można to zrobić na dwa sposoby.

Sposób 1 – Application.Current.MainWindow

WPF zawsze wie, które okno jest „głównym oknem” aplikacji (to ustawione w App.xaml). Możesz się do niego odwołać z dowolnego miejsca w programie.

private void btnOdswiez_Click(object sender, RoutedEventArgs e)
{
    // Rzutujemy Application.Current.MainWindow na nasz konkretny typ
    MainWindow glowne = (MainWindow)Application.Current.MainWindow;

    // Teraz mamy dostęp do jego publicznych metod i kontrolek
    glowne.OdswiezListe();
}

Sposób 2 – przekazanie referencji przez konstruktor

Alternatywnie, przy tworzeniu okna podrzędnego możesz od razu przekazać mu referencję this (czyli „samego siebie”) – okno podrzędne zapamiętuje, kto je otworzył.

private void btnOtworz_Click(object sender, RoutedEventArgs e)
{
    // "this" to referencja do aktualnego okna (MainWindow)
    OknoPodrzedne okno = new OknoPodrzedne(this);
    okno.Show();
}

public partial class OknoPodrzedne : Window
{
    private readonly MainWindow _oknoGlowne;

    public OknoPodrzedne(MainWindow oknoGlowne)
    {
        InitializeComponent();
        _oknoGlowne = oknoGlowne;
    }

    private void btnOdswiez_Click(object sender, RoutedEventArgs e)
    {
        _oknoGlowne.OdswiezListe();
    }
}

Kompletny przykład – lista uczniów z dodawaniem

Połączmy wszystko: okno główne z listą, przycisk otwierający formularz modalny, przekazanie danych z powrotem przez DialogResult.

<Window x:Class="MojaAplikacja.MainWindow" ...
        Title="Lista uczniów" Width="350" Height="400">
    <DockPanel Margin="10">

        <Button DockPanel.Dock="Top"
                Content="➕ Dodaj ucznia"
                Margin="0,0,0,10"
                Click="btnDodaj_Click" />

        <ListBox x:Name="lstUczniowie" />

    </DockPanel>
</Window>

private void btnDodaj_Click(object sender, RoutedEventArgs e)
{
    OknoDodawania okno = new OknoDodawania();
    bool? wynik = okno.ShowDialog();

    if (wynik == true)
    {
        lstUczniowie.Items.Add(okno.WpisaneImie);
    }
}

<Window x:Class="MojaAplikacja.OknoDodawania" ...
        Title="Dodaj ucznia"
        Width="300" Height="180"
        WindowStartupLocation="CenterOwner"
        ResizeMode="NoResize">
    <StackPanel Margin="15">

        <TextBlock Text="Imię i nazwisko ucznia:" />
        <TextBox x:Name="txtImie" Margin="0,4,0,16" />

        <StackPanel Orientation="Horizontal"
                    HorizontalAlignment="Right">
            <Button Content="Anuluj"
                    Width="80" Margin="0,0,8,0"
                    IsCancel="True"
                    Click="btnAnuluj_Click" />
            <Button Content="Zapisz"
                    Width="80"
                    IsDefault="True"
                    Click="btnZapisz_Click" />
        </StackPanel>

    </StackPanel>
</Window>

public partial class OknoDodawania : Window
{
    public string WpisaneImie { get; private set; }

    public OknoDodawania()
    {
        InitializeComponent();
    }

    private void btnZapisz_Click(object sender, RoutedEventArgs e)
    {
        if (string.IsNullOrWhiteSpace(txtImie.Text))
        {
            MessageBox.Show("Podaj imię i nazwisko!");
            return;
        }

        WpisaneImie = txtImie.Text;
        DialogResult = true;
    }

    private void btnAnuluj_Click(object sender, RoutedEventArgs e)
    {
        DialogResult = false;
    }
}

Częste błędy

❌ Błąd 1: Odczyt danych przed zamknięciem okna (Show zamiast ShowDialog)

OknoDodawania okno = new OknoDodawania();
okno.Show();  // NIE czeka!

// To wykona się NATYCHMIAST,
// zanim użytkownik cokolwiek wpisze!
lstUczniowie.Items.Add(okno.WpisaneImie);

OknoDodawania okno = new OknoDodawania();
bool? wynik = okno.ShowDialog();  // czeka!

if (wynik == true)
    lstUczniowie.Items.Add(okno.WpisaneImie);

❌ Błąd 2: Ustawienie właściwości po Show()/ShowDialog()

OknoSzczegoly okno = new OknoSzczegoly();
okno.Show();
okno.ImieUcznia = "Anna"; // za późno!
// Window_Loaded już się wykonał

OknoSzczegoly okno = new OknoSzczegoly();
okno.ImieUcznia = "Anna"; // najpierw dane
okno.Show(); // potem pokazujemy

❌ Błąd 3: Zapomniany domyślny konstruktor

public partial class OknoSzczegoly : Window
{
    // Tylko własny konstruktor –
    // brak konstruktora bez parametrów!
    public OknoSzczegoly(string imie)
    {
        InitializeComponent();
    }
}
// Visual Studio / XAML designer
// oczekuje domyślnego konstruktora!

public partial class OknoSzczegoly : Window
{
    public OknoSzczegoly() // domyślny – zostaw!
    {
        InitializeComponent();
    }

    public OknoSzczegoly(string imie) : this()
    {
        lblImie.Text = imie;
    }
}

❌ Błąd 4: DialogResult ustawione bez ShowDialog()

// W MainWindow:
OknoDodawania okno = new OknoDodawania();
okno.Show(); // Show(), nie ShowDialog()!

// W OknoDodawania, przy kliknięciu Zapisz:
DialogResult = true;
// Wyjątek! DialogResult działa TYLKO
// z ShowDialog()

// Jeśli chcesz używać DialogResult,
// zawsze otwieraj okno przez:
okno.ShowDialog();

Zadania do wykonania