Udostępnij za pomocą

Przewodnik: hostowanie kontrolki złożonej WPF w formularzach systemu Windows

Program Windows Presentation Foundation (WPF) udostępnia bogate środowisko do tworzenia aplikacji. Jednak jeśli masz znaczną inwestycję w kod Windows Forms, bardziej skuteczne może być rozszerzenie istniejącej aplikacji Windows Forms za pomocą WPF, a nie ponownego zapisania go od podstaw. Typowy scenariusz polega na tym, że chcesz osadzić co najmniej jedną kontrolkę zaimplementowaną za pomocą platformy WPF w aplikacji Windows Forms. Aby uzyskać więcej informacji na temat dostosowywania kontrolek WPF, zobacz Dostosowywanie kontrolek.

Ten przewodnik przeprowadzi Cię przez aplikację, która hostuje kontrolkę złożoną WPF w celu wykonania wpisu danych w aplikacji Windows Forms. Kontrolka złożona jest zawarta w DLL. Ta ogólna procedura może zostać rozszerzona na bardziej złożone aplikacje i mechanizmy kontroli. Ten przewodnik został zaprojektowany tak, aby był niemal identyczny pod względem wyglądu i funkcjonalności do Przewodnik: hostowanie kontrolki złożonej Formularzy systemu Windows w WPF. Podstawową różnicą jest to, że scenariusz hostingu jest odwrócony.

Przewodnik jest podzielony na dwie sekcje. Pierwsza sekcja krótko opisuje implementację złożonej kontrolki WPF. W drugiej sekcji omówiono szczegółowo sposób hostowania złożonej kontrolki w aplikacji Windows Forms, odbierania zdarzeń z kontrolki i uzyskiwania dostępu do niektórych właściwości kontrolki.

Zadania przedstawione w tym przewodniku obejmują:

  • Implementowanie kontrolki złożonej WPF.

  • Implementowanie aplikacji hostującej Windows Forms.

Aby uzyskać pełną listę kodu zadań przedstawionych w tym przewodniku, zobacz Hostowanie kontrolki złożonej WPF w przykładzie Windows Forms Sample.

Wymagania wstępne

Aby ukończyć ten przewodnik, potrzebny jest program Visual Studio.

Implementowanie kontrolki złożonej WPF

Kontrolka złożona WPF używana w tym przykładzie to prosty formularz wprowadzania danych, który przyjmuje nazwę i adres użytkownika. Po kliknięciu jednego z dwóch przycisków przez użytkownika, aby wskazać, że zadanie zostało zakończone, kontrolka zgłasza zdarzenie niestandardowe i przekazuje te informacje hostowi. Na poniższej ilustracji przedstawiono renderowaną kontrolkę.

Na poniższej ilustracji przedstawiono kontrolkę złożoną WPF:

Zrzut ekranu przedstawiający prostą kontrolkę WPF.

Tworzenie projektu

Aby rozpocząć projekt:

  1. Uruchom program Visual Studio i otwórz okno dialogowe Nowy projekt.

  2. W Visual C# i kategorii Windows wybierz szablon biblioteki kontroli użytkownika WPF.

  3. Nadaj nazwę nowemu projektowi MyControls.

  4. W przypadku lokalizacji określ wygodnie nazwany folder najwyższego poziomu, taki jak WindowsFormsHostingWpfControl. Później aplikacja hosta zostanie umieszczona w tym folderze.

  5. Kliknij przycisk OK, aby utworzyć projekt. Projekt domyślny zawiera jedną kontrolkę o nazwie UserControl1.

  6. W Eksploratorze rozwiązań zmień nazwę UserControl1 na MyControl1.

Projekt powinien zawierać odwołania do następujących bibliotek DLL systemu. Jeśli którakolwiek z tych bibliotek DLL nie jest domyślnie dołączona, dodaj je do projektu.

  • Rdzeń prezentacji

  • Element PresentationFramework

  • System

  • WindowsBase

Tworzenie interfejsu użytkownika

Interfejs użytkownika dla kontrolki złożonej jest implementowany za pomocą języka XAML (Extensible Application Markup Language). Interfejs użytkownika kontrolki złożonej składa się z pięciu TextBox elementów. Każdy element TextBox ma skojarzony element TextBlock, który służy jako etykieta. W dolnej części znajdują się dwa elementy Button, OK i Anuluj. Gdy użytkownik kliknie dowolny przycisk, kontrolka zgłasza zdarzenie niestandardowe, aby zwrócić informacje do hosta.

Układ podstawowy

Różne elementy interfejsu użytkownika są zawarte w elemecie Grid. Za pomocą Grid można rozmieścić zawartość kontrolki złożonej w podobny sposób, jak używa się elementu Table w HTML. WPF ma również element Table, ale Grid jest bardziej lekki i lepiej nadaje się do prostych zadań układu.

Poniższy kod XAML przedstawia podstawowy układ. Ten kod XAML definiuje ogólną strukturę kontrolki, określając liczbę kolumn i wierszy w elemecie Grid.

W pliku MyControl1.xaml zastąp istniejący kod XAML następującym kodem XAML.

<Grid xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      x:Class="MyControls.MyControl1"
      Background="#DCDCDC"
      Width="375"
      Height="250"
      Name="rootElement"
      Loaded="Init">

  <Grid.ColumnDefinitions>
    <ColumnDefinition Width="Auto" />
    <ColumnDefinition Width="Auto" />
    <ColumnDefinition Width="Auto"/>
    <ColumnDefinition Width="Auto"/>
  </Grid.ColumnDefinitions>

  <Grid.RowDefinitions>
    <RowDefinition Height="Auto" />
    <RowDefinition Height="Auto" />
    <RowDefinition Height="Auto" />
    <RowDefinition Height="Auto" />
    <RowDefinition Height="Auto" />
    <RowDefinition Height="Auto" />
  </Grid.RowDefinitions>

</Grid>

Dodawanie elementów TextBlock i TextBox do siatki

Element interfejsu użytkownika można umieścić w siatce, ustawiając atrybuty RowProperty i ColumnProperty elementu na odpowiedni numer wiersza i kolumny. Pamiętaj, że numerowanie wierszy i kolumn jest oparte na zera. Element może obejmować wiele kolumn, ustawiając jego atrybut ColumnSpanProperty. Aby uzyskać więcej informacji na temat elementów Grid, zobacz Tworzenie Elementu Siatki.

Poniższy kod XAML przedstawia TextBox i TextBlock elementów kontrolki złożonej z ich atrybutami RowProperty i ColumnProperty, które są ustawione tak, aby poprawnie umieścić elementy w siatce.

W pliku MyControl1.xaml dodaj następujący kod XAML w elemecie Grid.

  <TextBlock Grid.Column="0"
        Grid.Row="0" 
        Grid.ColumnSpan="4"
        Margin="10,5,10,0"
        HorizontalAlignment="Center"
        Style="{StaticResource titleText}">Simple WPF Control</TextBlock>

  <TextBlock Grid.Column="0"
        Grid.Row="1"
        Style="{StaticResource inlineText}"
        Name="nameLabel">Name</TextBlock>
  <TextBox Grid.Column="1"
        Grid.Row="1"
        Grid.ColumnSpan="3"
        Name="txtName"/>

  <TextBlock Grid.Column="0"
        Grid.Row="2"
        Style="{StaticResource inlineText}"
        Name="addressLabel">Street Address</TextBlock>
  <TextBox Grid.Column="1"
        Grid.Row="2"
        Grid.ColumnSpan="3"
        Name="txtAddress"/>

  <TextBlock Grid.Column="0"
        Grid.Row="3"
        Style="{StaticResource inlineText}"
        Name="cityLabel">City</TextBlock>
  <TextBox Grid.Column="1"
        Grid.Row="3"
        Width="100"
        Name="txtCity"/>

  <TextBlock Grid.Column="2"
        Grid.Row="3"
        Style="{StaticResource inlineText}"
        Name="stateLabel">State</TextBlock>
  <TextBox Grid.Column="3"
        Grid.Row="3"
        Width="50"
        Name="txtState"/>

  <TextBlock Grid.Column="0"
        Grid.Row="4"
        Style="{StaticResource inlineText}"
        Name="zipLabel">Zip</TextBlock>
  <TextBox Grid.Column="1"
        Grid.Row="4"
        Width="100"
        Name="txtZip"/>

Stylowanie elementów interfejsu użytkownika

Wiele elementów w formularzu wprowadzania danych ma podobny wygląd, co oznacza, że mają identyczne ustawienia dla kilku ich właściwości. Zamiast oddzielnie ustawiać atrybuty każdego elementu, poprzedni kod XAML używa Style elementów do definiowania standardowych ustawień właściwości dla klas elementów. Takie podejście zmniejsza złożoność kontrolki i umożliwia zmianę wyglądu wielu elementów za pomocą pojedynczego atrybutu stylu.

Elementy Style są zawarte we właściwości Grid elementu Resources, dzięki czemu mogą być używane przez wszystkie elementy w kontrolce. Jeśli styl ma nazwę, należy zastosować go do elementu, dodając element Style ustawiony na nazwę stylu. Style, które nie są nazwane, stają się domyślnym stylem elementu. Aby uzyskać więcej informacji na temat stylów WPF, zobacz Style and Templating.

Poniższy kod XAML przedstawia elementy Style dla kontrolki złożonej. Aby zobaczyć, jak style są stosowane do elementów, zobacz poprzedni kod XAML. Na przykład ostatni element TextBlock ma styl inlineText, a ostatni element TextBox używa stylu domyślnego.

W pliku MyControl1.xaml dodaj następujący kod XAML tuż po elemecie start Grid.

<Grid.Resources>
  <Style x:Key="inlineText" TargetType="{x:Type TextBlock}">
    <Setter Property="Margin" Value="10,5,10,0"/>
    <Setter Property="FontWeight" Value="Normal"/>
    <Setter Property="FontSize" Value="12"/>
  </Style>
  <Style x:Key="titleText" TargetType="{x:Type TextBlock}">
    <Setter Property="DockPanel.Dock" Value="Top"/>
    <Setter Property="FontWeight" Value="Bold"/>
    <Setter Property="FontSize" Value="14"/>
    <Setter Property="Margin" Value="10,5,10,0"/>
  </Style>
  <Style TargetType="{x:Type Button}">
    <Setter Property="Margin" Value="10,5,10,0"/>
    <Setter Property="Width" Value="60"/>
  </Style>
  <Style TargetType="{x:Type TextBox}">
    <Setter Property="Margin" Value="10,5,10,0"/>
  </Style>
</Grid.Resources>

Dodawanie przycisków OK i Anuluj

Ostatnie elementy na kontrolce złożonej to OK i AnulujButton, które zajmują dwie pierwsze kolumny ostatniego wiersza Grid. Te elementy używają typowej procedury obsługi zdarzeń, ButtonClickedi domyślnego stylu Button zdefiniowanego w poprzednim języku XAML.

W pliku MyControl1.xaml dodaj następujący kod XAML po ostatnim elemencie TextBox. Część XAML kontrolki złożonej została ukończona.

<Button Grid.Row="5"
        Grid.Column="0"
        Name="btnOK"
        Click="ButtonClicked">OK</Button>
<Button Grid.Row="5"
        Grid.Column="1"
        Name="btnCancel"
        Click="ButtonClicked">Cancel</Button>

Implementowanie pliku Code-Behind

Plik związany z kodem, MyControl1.xaml.cs, implementuje trzy podstawowe zadania:

  1. Obsługuje zdarzenie, które występuje, gdy użytkownik kliknie jeden z przycisków.

  2. Pobiera dane z elementów TextBox i pakuje je w niestandardowym obiekcie argumentu zdarzenia.

  3. Zgłasza zdarzenie niestandardowe OnButtonClick, które powiadamia hosta o zakończeniu pracy użytkownika i przekazuje dane z powrotem do hosta.

Kontrolka uwidacznia również wiele właściwości koloru i czcionki, które umożliwiają zmianę wyglądu. W przeciwieństwie do klasy WindowsFormsHost, która jest używana do hostowania kontrolki Windows Forms, klasa ElementHost uwidacznia tylko właściwość Background kontrolki. Aby zachować podobieństwo między tym przykładem kodu a przykładem omówionym w Walkthrough: Hosting a Windows Forms Composite Control in WPF, kontrolka udostępnia pozostałe właściwości wprost.

Podstawowa struktura pliku Code-Behind

Plik code-behind składa się z jednej przestrzeni nazwowej, MyControls, która będzie zawierać dwie klasy, MyControl1 i MyControlEventArgs.

namespace MyControls
{
  public partial class MyControl1 : Grid
  {
    //...
  }
  public class MyControlEventArgs : EventArgs
  {
    //...
  }
}

Pierwsza klasa, MyControl1, jest klasą częściową zawierającą kod, który implementuje funkcjonalność interfejsu użytkownika zdefiniowanego w pliku MyControl1.xaml. Po przeanalizowaniu pliku MyControl1.xaml kod XAML jest konwertowany na tę samą klasę częściową, a dwie klasy częściowe są scalane w celu utworzenia skompilowanej kontrolki. Z tego powodu nazwa klasy w pliku za kodem musi być zgodna z nazwą klasy przypisaną do pliku MyControl1.xaml i musi dziedziczyć z elementu głównego kontrolki. Druga klasa, MyControlEventArgs, to klasa argumentów zdarzeń używana do wysyłania danych z powrotem do hosta.

Otwórz MyControl1.xaml.cs. Zmień istniejącą deklarację klasy, aby miała następującą nazwę i dziedziczyła z Grid.

public partial class MyControl1 : Grid

Inicjowanie kontrolki

Poniższy kod implementuje kilka podstawowych zadań:

  • Deklaruje zdarzenie prywatne, OnButtonClicki skojarzony z nim delegat, MyControlEventHandler.

  • Tworzy kilka prywatnych zmiennych globalnych, które przechowują dane użytkownika. Te dane są udostępniane za pośrednictwem odpowiednich właściwości.

  • Implementuje program obsługi Initdla zdarzenia Loaded kontrolki. Ta procedura obsługi inicjuje zmienne globalne, przypisując im wartości zdefiniowane w pliku MyControl1.xaml. W tym celu używa Name przypisanego do typowego elementu TextBlock, nameLabel, aby uzyskać dostęp do ustawień właściwości tego elementu.

Usuń istniejący konstruktor i dodaj następujący kod do klasy MyControl1.

public delegate void MyControlEventHandler(object sender, MyControlEventArgs args);
public event MyControlEventHandler OnButtonClick;
private FontWeight _fontWeight;
private double _fontSize;
private FontFamily _fontFamily;
private FontStyle _fontStyle;
private SolidColorBrush _foreground;
private SolidColorBrush _background;

private void Init(object sender, EventArgs e)
{
    //They all have the same style, so use nameLabel to set initial values.
    _fontWeight = nameLabel.FontWeight;
    _fontSize = nameLabel.FontSize;
    _fontFamily = nameLabel.FontFamily;
    _fontStyle = nameLabel.FontStyle;
    _foreground = (SolidColorBrush)nameLabel.Foreground;
    _background = (SolidColorBrush)rootElement.Background;
}

Obsługa zdarzeń kliknięcia przycisków

Użytkownik wskazuje, że zadanie wprowadzania danych zostało zakończone, klikając przycisk OK lub przycisk Anuluj. Oba przyciski używają tego samego programu obsługi zdarzeń Click, ButtonClicked. Oba przyciski mają nazwę, btnOK lub btnCancel, które umożliwiają programowi obsługi określenie, który przycisk został kliknięty, sprawdzając wartość argumentu sender. Obsługa wykonuje następujące czynności:

  • Tworzy obiekt MyControlEventArgs zawierający dane z elementów TextBox.

  • Jeśli użytkownik kliknął przycisk Anuluj, ustawia właściwość MyControlEventArgs obiektu IsOK na false.

  • Zgłasza zdarzenie OnButtonClick, aby wskazać hostowi, że użytkownik jest gotowy, i przekazuje zebrane dane z powrotem.

Dodaj następujący kod do klasy MyControl1 po metodzie Init.

private void ButtonClicked(object sender, RoutedEventArgs e)
{
    MyControlEventArgs retvals = new MyControlEventArgs(true,
                                                        txtName.Text,
                                                        txtAddress.Text,
                                                        txtCity.Text,
                                                        txtState.Text,
                                                        txtZip.Text);
    if (sender == btnCancel)
    {
        retvals.IsOK = false;
    }
    if (OnButtonClick != null)
        OnButtonClick(this, retvals);
}

Tworzenie właściwości

Pozostała część klasy po prostu uwidacznia właściwości, które odpowiadają wcześniej omówionych zmiennych globalnych. Gdy właściwość ulegnie zmianie, zestaw metod dostępu modyfikuje wygląd kontrolki, zmieniając odpowiednie właściwości elementu i aktualizując bazowe zmienne globalne.

Dodaj następujący kod do klasy MyControl1.

public FontWeight MyControl_FontWeight
{
    get { return _fontWeight; }
    set
    {
        _fontWeight = value;
        nameLabel.FontWeight = value;
        addressLabel.FontWeight = value;
        cityLabel.FontWeight = value;
        stateLabel.FontWeight = value;
        zipLabel.FontWeight = value;
    }
}
public double MyControl_FontSize
{
    get { return _fontSize; }
    set
    {
        _fontSize = value;
        nameLabel.FontSize = value;
        addressLabel.FontSize = value;
        cityLabel.FontSize = value;
        stateLabel.FontSize = value;
        zipLabel.FontSize = value;
    }
}
public FontStyle MyControl_FontStyle
{
    get { return _fontStyle; }
    set
    {
        _fontStyle = value;
        nameLabel.FontStyle = value;
        addressLabel.FontStyle = value;
        cityLabel.FontStyle = value;
        stateLabel.FontStyle = value;
        zipLabel.FontStyle = value;
    }
}
public FontFamily MyControl_FontFamily
{
    get { return _fontFamily; }
    set
    {
        _fontFamily = value;
        nameLabel.FontFamily = value;
        addressLabel.FontFamily = value;
        cityLabel.FontFamily = value;
        stateLabel.FontFamily = value;
        zipLabel.FontFamily = value;
    }
}

public SolidColorBrush MyControl_Background
{
    get { return _background; }
    set
    {
        _background = value;
        rootElement.Background = value;
    }
}
public SolidColorBrush MyControl_Foreground
{
    get { return _foreground; }
    set
    {
        _foreground = value;
        nameLabel.Foreground = value;
        addressLabel.Foreground = value;
        cityLabel.Foreground = value;
        stateLabel.Foreground = value;
        zipLabel.Foreground = value;
    }
}

Wysyłanie danych z powrotem do hosta

Ostatnim składnikiem w pliku jest klasa MyControlEventArgs, która służy do wysyłania zebranych danych z powrotem do hosta.

Dodaj następujący kod do przestrzeni nazw MyControls. Implementacja jest prosta i nie została omówiona dalej.

public class MyControlEventArgs : EventArgs
{
    private string _Name;
    private string _StreetAddress;
    private string _City;
    private string _State;
    private string _Zip;
    private bool _IsOK;

    public MyControlEventArgs(bool result,
                              string name,
                              string address,
                              string city,
                              string state,
                              string zip)
    {
        _IsOK = result;
        _Name = name;
        _StreetAddress = address;
        _City = city;
        _State = state;
        _Zip = zip;
    }

    public string MyName
    {
        get { return _Name; }
        set { _Name = value; }
    }
    public string MyStreetAddress
    {
        get { return _StreetAddress; }
        set { _StreetAddress = value; }
    }
    public string MyCity
    {
        get { return _City; }
        set { _City = value; }
    }
    public string MyState
    {
        get { return _State; }
        set { _State = value; }
    }
    public string MyZip
    {
        get { return _Zip; }
        set { _Zip = value; }
    }
    public bool IsOK
    {
        get { return _IsOK; }
        set { _IsOK = value; }
    }
}

Skompiluj rozwiązanie. Kompilacja utworzy bibliotekę DLL o nazwie MyControls.dll.

Implementowanie aplikacji hosta formularzy systemu Windows

Aplikacja hosta Windows Forms używa obiektu ElementHost do hostowania kontrolki złożonej WPF. Aplikacja obsługuje zdarzenie OnButtonClick w celu odbierania danych z kontrolki złożonej. Aplikacja ma również zestaw przycisków opcji, których można użyć do modyfikowania wyglądu kontrolki. Poniższa ilustracja przedstawia aplikację.

Na poniższej ilustracji przedstawiono kontrolkę złożoną WPF hostowaną w aplikacji Windows Forms

Zrzut ekranu przedstawiający formularza Windows hostującego kontrolkę Avalon.

Tworzenie projektu

Aby rozpocząć projekt:

  1. Uruchom program Visual Studio i otwórz okno dialogowe Nowy projekt.

  2. W Visual C# w kategorii Windows wybierz szablon Aplikacja Windows Forms.

  3. Nadaj nazwę nowemu projektowi WFHost.

  4. W przypadku lokalizacji określ ten sam folder najwyższego poziomu, który zawiera projekt MyControls.

  5. Kliknij przycisk OK, aby utworzyć projekt.

Należy również dodać odwołania do biblioteki DLL zawierającej MyControl1 i inne zestawy.

  1. Kliknij prawym przyciskiem myszy nazwę projektu w Eksploratorze rozwiązań i wybierz opcję Dodaj odwołanie.

  2. Kliknij kartę Przeglądaj i przejdź do folderu, który zawiera MyControls.dll. W tym przewodniku używamy folderu MyControls\bin\Debug.

  3. Wybierz pozycję MyControls.dll, a następnie kliknij przycisk OK.

  4. Dodaj odwołania do następujących zestawów.

    • Rdzeń prezentacji

    • Element PresentationFramework

    • System.Xaml

    • WindowsBase

    • WindowsFormsIntegration

Implementowanie interfejsu użytkownika dla aplikacji

Interfejs użytkownika aplikacji Formularz systemu Windows zawiera kilka kontrolek umożliwiających interakcję z kontrolką złożoną WPF.

  1. Otwórz formularz Form1 w projektancie formularzy systemu Windows.

  2. Powiększ formularz, aby uwzględnić kontrolki.

  3. W prawym górnym rogu formularza dodaj kontrolkę System.Windows.Forms.Panel do przechowywania kontrolki złożonej WPF.

  4. Dodaj następujące kontrolki System.Windows.Forms.GroupBox do formularza.

    Nazwa Tekst
    groupBox1 Kolor tła
    groupBox2 Kolor pierwszego planu
    groupBox3 Rozmiar czcionki
    groupBox4 Rodzina czcionek
    groupBox5 Styl czcionki
    groupBox6 Grubość czcionki
    groupBox7 Dane z kontrolki

  5. Dodaj następujące kontrolki System.Windows.Forms.RadioButton do kontrolek System.Windows.Forms.GroupBox.

    Ramka grupy Nazwa Tekst
    groupBox1 oryginalne tło radia Oryginał
    groupBox1 radioTłoJasnoZielony Jasnozielony
    groupBox1 TłoRadiaJasnyŁososiowy LightSalmon
    groupBox2 oryginalneRadioNaPierwszymPlanie Oryginał
    groupBox2 radioForegroundRed Czerwony
    groupBox2 Kolor pierwszoplanowy radia: żółty Żółty
    groupBox3 OryginalnyRozmiarRadio Oryginał
    groupBox3 radioSizeTen 10
    groupBox3 radioSizeTwelve 12
    groupBox4 RadioRodzinaOryginał Oryginał
    groupBox4 radioFamilyTimes Times New Roman
    groupBox4 radioFamilyWingDings Wingdings
    groupBox5 radioStyleOriginal Standardowy
    groupBox5 radioStyleItalic Italik
    groupBox6 radioWeightOriginal Oryginał
    groupBox6 radioWeightBold Pogrubiona

  6. Dodaj następujące kontrolki System.Windows.Forms.Label do ostatniego System.Windows.Forms.GroupBox. Te kontrolki wyświetlają dane zwracane przez kontrolkę złożoną WPF.

    Ramka grupy Nazwa Tekst
    groupBox7 lblName Nazwa:
    groupBox7 lblAdres Adres ulicy:
    groupBox7 lblCity Miasto:
    groupBox7 lblState Stan:
    groupBox7 lblZip Kod pocztowy

Inicjowanie formularza

Zazwyczaj kod hostingu jest implementowany w procedurze obsługi zdarzeń Load formularza. Poniższy kod przedstawia program obsługi zdarzeń Load, procedurę obsługi zdarzenia Loaded kontrolki złożonej WPF oraz deklaracje dla kilku zmiennych globalnych, które są używane później.

W programie Windows Forms Designer kliknij dwukrotnie formularz, aby utworzyć program obsługi zdarzeń Load. Na górze pliku Form1.cs dodaj następujące instrukcje using.

using System.Windows;
using System.Windows.Forms.Integration;
using System.Windows.Media;

Zastąp zawartość istniejącej klasy Form1 następującym kodem.

private ElementHost ctrlHost;
private MyControls.MyControl1 wpfAddressCtrl;
System.Windows.FontWeight initFontWeight;
double initFontSize;
System.Windows.FontStyle initFontStyle;
System.Windows.Media.SolidColorBrush initBackBrush;
System.Windows.Media.SolidColorBrush initForeBrush;
System.Windows.Media.FontFamily initFontFamily;

public Form1()
{
    InitializeComponent();
}

private void Form1_Load(object sender, EventArgs e)
{
    ctrlHost = new ElementHost();
    ctrlHost.Dock = DockStyle.Fill;
    panel1.Controls.Add(ctrlHost);
    wpfAddressCtrl = new MyControls.MyControl1();
    wpfAddressCtrl.InitializeComponent();
    ctrlHost.Child = wpfAddressCtrl;

    wpfAddressCtrl.OnButtonClick +=
        new MyControls.MyControl1.MyControlEventHandler(
        avAddressCtrl_OnButtonClick);
    wpfAddressCtrl.Loaded += new RoutedEventHandler(
        avAddressCtrl_Loaded);
}

void avAddressCtrl_Loaded(object sender, EventArgs e)
{
    initBackBrush = (SolidColorBrush)wpfAddressCtrl.MyControl_Background;
    initForeBrush = wpfAddressCtrl.MyControl_Foreground;
    initFontFamily = wpfAddressCtrl.MyControl_FontFamily;
    initFontSize = wpfAddressCtrl.MyControl_FontSize;
    initFontWeight = wpfAddressCtrl.MyControl_FontWeight;
    initFontStyle = wpfAddressCtrl.MyControl_FontStyle;
}

Metoda Form1_Load w poprzednim kodzie przedstawia ogólną procedurę hostowania kontrolki WPF:

  1. Utwórz nowy obiekt ElementHost.

  2. Ustaw właściwość Dock kontrolki na wartość DockStyle.Fill.

  3. Dodaj kontrolkę ElementHost do kolekcji Panel kontrolki Controls.

  4. Utwórz wystąpienie kontrolki WPF.

  5. Osadź kontrolkę złożoną w formularzu, przypisując ją do właściwości ElementHost kontrolki Child.

Pozostałe dwa wiersze w metodzie Form1_Load przypisują obsługujące do dwóch zdarzeń kontrolnych.

  • OnButtonClick jest zdarzeniem niestandardowym wyzwalanym przez kontrolkę złożoną, gdy użytkownik kliknie OK lub przycisk Anuluj. Obsługujesz zdarzenie, aby uzyskać odpowiedź użytkownika i zebrać wszystkie dane określone przez użytkownika.

  • Loaded jest standardowym zdarzeniem zgłaszanym przez kontrolkę WPF, gdy jest w pełni załadowana. Zdarzenie to jest tutaj używane, ponieważ przykład musi zainicjować kilka zmiennych globalnych, korzystając z właściwości kontroli. W momencie zdarzenia Load formularza kontrolka nie została w pełni załadowana, a wartości są ciągle ustawione na null. Przed uzyskaniem dostępu do tych właściwości należy poczekać na wystąpienie zdarzenia Loaded kontrolki.

Procedura obsługi zdarzeń Loaded jest wyświetlana w poprzednim kodzie. Obsługa OnButtonClick jest omówiona w kolejnej sekcji.

Obsługa onButtonClick

Zdarzenie OnButtonClick występuje, gdy użytkownik kliknie przycisk OK lub przycisk Anuluj.

Procedura obsługi zdarzeń sprawdza pole IsOK argumentu zdarzenia, aby określić, który przycisk został kliknięty. Zmienne danych lbl odpowiadają elementom sterującym Label, które zostały omówione wcześniej. Jeśli użytkownik kliknie przycisk OK, dane z kontrolek TextBox są przypisywane do odpowiedniej kontrolki Label. Jeśli użytkownik kliknie Anuluj, wartości Text zostaną ustawione na ciągi domyślne.

Dodaj następujący kod procedury obsługi zdarzenia kliknięcia przycisku do klasy Form1.

void avAddressCtrl_OnButtonClick(
    object sender,
    MyControls.MyControl1.MyControlEventArgs args)
{
    if (args.IsOK)
    {
        lblAddress.Text = "Street Address: " + args.MyStreetAddress;
        lblCity.Text = "City: " + args.MyCity;
        lblName.Text = "Name: " + args.MyName;
        lblState.Text = "State: " + args.MyState;
        lblZip.Text = "Zip: " + args.MyZip;
    }
    else
    {
        lblAddress.Text = "Street Address: ";
        lblCity.Text = "City: ";
        lblName.Text = "Name: ";
        lblState.Text = "State: ";
        lblZip.Text = "Zip: ";
    }
}

Skompiluj i uruchom aplikację. Dodaj jakiś tekst w kontrolce złożonej WPF, a następnie kliknij przycisk OK. Tekst zostanie wyświetlony w etykietach. W tym momencie kod nie został dodany do obsługi przycisków radiowych.

Modyfikowanie wyglądu kontrolki

Kontrolki RadioButton w formularzu umożliwią użytkownikowi zmianę pierwszego planu i kolorów tła kontrolki złożonej WPF, a także kilka właściwości czcionki. Kolor tła jest uwidaczniony przez obiekt ElementHost. Pozostałe właściwości są udostępniane jako niestandardowe właściwości kontrolki.

Kliknij dwukrotnie każdą kontrolkę RadioButton w formularzu, aby utworzyć programy obsługi zdarzeń CheckedChanged. Zastąp programy obsługi zdarzeń CheckedChanged następującym kodem.

private void radioBackgroundOriginal_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_Background = initBackBrush;
}

private void radioBackgroundLightGreen_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_Background = new SolidColorBrush(Colors.LightGreen);
}

private void radioBackgroundLightSalmon_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_Background = new SolidColorBrush(Colors.LightSalmon);
}

private void radioForegroundOriginal_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_Foreground = initForeBrush;
}

private void radioForegroundRed_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_Foreground = new System.Windows.Media.SolidColorBrush(Colors.Red);
}

private void radioForegroundYellow_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_Foreground = new System.Windows.Media.SolidColorBrush(Colors.Yellow);
}

private void radioFamilyOriginal_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontFamily = initFontFamily;
}

private void radioFamilyTimes_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontFamily = new System.Windows.Media.FontFamily("Times New Roman");
}

private void radioFamilyWingDings_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontFamily = new System.Windows.Media.FontFamily("WingDings");
}

private void radioSizeOriginal_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontSize = initFontSize;
}

private void radioSizeTen_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontSize = 10;
}

private void radioSizeTwelve_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontSize = 12;
}

private void radioStyleOriginal_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontStyle = initFontStyle;
}

private void radioStyleItalic_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontStyle = System.Windows.FontStyles.Italic;
}

private void radioWeightOriginal_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontWeight = initFontWeight;
}

private void radioWeightBold_CheckedChanged(object sender, EventArgs e)
{
    wpfAddressCtrl.MyControl_FontWeight = FontWeights.Bold;
}

Skompiluj i uruchom aplikację. Kliknij różne przyciski radiowe, aby zobaczyć wpływ na kontrolkę złożoną WPF.

Zobacz także

  • Last updated on