Dela via

Genomgång: Hosta en sammansatt WPF-kontroll i Windows-formulär

  • Artikel

Windows Presentation Foundation (WPF) ger en omfattande miljö för att skapa program. Men när du har en betydande investering i Windows Forms-kod kan det vara mer effektivt att utöka ditt befintliga Windows Forms-program med WPF i stället för att skriva om det från grunden. Ett vanligt scenario är när du vill bädda in en eller flera kontroller som implementerats med WPF i ditt Windows Forms-program. Mer information om hur du anpassar WPF-kontroller finns i Control Customization.

Den här genomgången vägleder dig genom ett program som är värd för en WPF-sammansatt kontroll för att utföra datainmatning i ett Windows Forms-program. Den sammansatta kontrollen paketeras i en DLL. Den här allmänna proceduren kan utökas till mer komplexa program och kontroller. Den här genomgången är utformad för att vara nästan identisk i utseende och funktionalitet med Walkthrough: Hosting a Windows Forms Composite Control in WPF. Den primära skillnaden är att värdscenariot är omvänt.

Genomgången är uppdelad i två avsnitt. I det första avsnittet beskrivs kortfattat implementeringen av den sammansatta WPF-kontrollen. I det andra avsnittet beskrivs i detalj hur du är värd för den sammansatta kontrollen i ett Windows Forms-program, tar emot händelser från kontrollen och får åtkomst till några av kontrollens egenskaper.

Uppgifter som illustreras i den här genomgången är:

  • Att implementera den sammansatta WPF-kontrollen.

  • Implementera Windows Forms-värdprogrammet.

En fullständig kodlista över de uppgifter som illustreras i den här genomgången finns i Hosting a WPF Composite Control in Windows Forms Sample.

Förutsättningar

Du behöver Visual Studio för att slutföra den här genomgången.

Att implementera WPF:s sammansatta kontroll

Den sammansatta WPF-kontrollen som används i det här exemplet är ett enkelt formulär för datainmatning som tar användarens namn och adress. När användaren klickar på en av de två knapparna för att ange att uppgiften är klar, genererar kontrollen en anpassad händelse för att skicka tillbaka informationen till värden. Följande bild visar den renderade kontrollen.

Följande bild visar en SAMMANSATT WPF-kontroll:

Skärmbild som visar en enkel WPF-kontroll.

Skapa projektet

Så här startar du projektet:

  1. Starta Visual Studio och öppna dialogrutan Nytt projekt.

  2. I Visual C# och kategorin Windows väljer du mallen WPF User Control Library.

  3. Ge det nya projektet namnet MyControls.

  4. För platsen anger du en bekvämt namngiven mapp på den översta nivån, till exempel WindowsFormsHostingWpfControl. Senare placerar du värdprogrammet i den här mappen.

  5. Klicka på OK för att skapa projektet. Standardprojektet innehåller en enda kontroll med namnet UserControl1.

  6. I Solution Explorer byter du namn på UserControl1 till MyControl1.

Projektet bör ha referenser till följande system-DLL:er. Om någon av dessa DLL:er inte ingår som standard lägger du till dem i projektet.

  • PresentationCore

  • PresentationFramework

  • System

  • WindowsBase

Skapa användargränssnittet

Användargränssnittet (UI) för den sammansatta kontrollen implementeras med XAML (Extensible Application Markup Language). Det sammansatta kontrollgränssnittet består av fem TextBox element. Varje TextBox element har ett associerat TextBlock element som fungerar som en etikett. Det finns två Button element längst ned, OK och Avbryt. När användaren klickar på vilken som helst av knapparna skapar kontrollen en anpassad händelse för att returnera informationen till värden.

Grundläggande layout

De olika gränssnittselementen finns i ett Grid element. Du kan använda Grid för att ordna innehållet i den sammansatta kontrollen på ungefär samma sätt som du använder ett Table element i HTML. WPF har också ett Table element, men Grid är enklare och passar bättre för enkla layoutuppgifter.

Följande XAML visar den grundläggande layouten. Denna XAML definierar kontrollens övergripande struktur genom att ange antalet kolumner och rader i Grid-elementet.

I MyControl1.xaml ersätter du den befintliga XAML med följande 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>

Lägga till TextBlock- och TextBox-element i rutnätet

Du placerar ett gränssnittselement i rutnätet genom att ange elementets RowProperty- och ColumnProperty attribut till lämpligt rad- och kolumnnummer. Kom ihåg att rad- och kolumnnumrering är nollbaserade. Du kan ha ett element som sträcker sig över flera kolumner genom att ange dess ColumnSpanProperty attribut. Mer information om Grid element finns i Skapa ett rutnätselement.

Följande XAML visar den sammansatta kontrollens TextBox- och TextBlock-element med attributen RowProperty och ColumnProperty, som är inställda på att placera elementen korrekt i rutnätet.

Lägg till följande XAML i elementet Grid i MyControl1.xaml.

  <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"/>

Formatera användargränssnittselementen

Många av elementen i formuläret för datainmatning har ett liknande utseende, vilket innebär att de har identiska inställningar för flera av sina egenskaper. I stället för att ange varje elements attribut separat använder den tidigare XAML Style element för att definiera standardegenskapsinställningar för elementklasser. Den här metoden minskar kontrollens komplexitet och gör att du kan ändra utseendet på flera element via ett enda formatattribut.

De Style elementen finns i Grid-elementets egenskap Resources så att de kan användas av alla element i kontrollen. Om en stil har ett namn, använder du det på ett element genom att lägga till ett Style-element satt till stilens namn. Format som inte namnges blir till standardstilen för elementet. Mer information om WPF-format finns i Styling och Templating.

Följande XAML visar de Style elementen för den sammansatta kontrollen. Information om hur formatmallarna tillämpas på element finns i föregående XAML. Det sista TextBlock-elementet har till exempel inlineText formatmall och det sista TextBox-elementet använder standardformatet.

I MyControl1.xaml lägger du till följande XAML strax efter Grid startelement.

<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>

Lägga till ok- och avbryt-knapparna

De sista elementen på den sammansatta kontrollen är element OK och element AvbrytButton, vilka upptar de två första kolumnerna i den sista raden av Grid. Dessa element använder en vanlig händelsehanterare, ButtonClickedoch standardformatet Button som definierades i föregående XAML.

I MyControl1.xaml lägger du till följande XAML efter det sista TextBox-elementet. XAML-delen av den sammansatta kontrollen är nu klar.

<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>

Implementering av Code-Behind-filen

Koden bakom filen, MyControl1.xaml.cs, implementerar tre viktiga uppgifter:

  1. Hanterar händelsen som inträffar när användaren klickar på någon av knapparna.

  2. Hämtar data från de TextBox elementen och paketar dem i ett anpassat händelseargumentobjekt.

  3. Genererar den anpassade OnButtonClick händelsen, vilket meddelar värden att användaren är klar och skickar tillbaka data till värden.

Kontrollen visar också ett antal färg- och teckensnittsegenskaper som gör att du kan ändra utseendet. Till skillnad från klassen WindowsFormsHost, som används för att husera en Windows Forms-kontroll, visar klassen ElementHost endast kontrollens Background-egenskap. För att behålla likheten mellan det här kodexemplet och exemplet som beskrivs i Genomgång: Värd för en sammansatt Windows Forms-kontroll i WPF, exponerar kontrollen de kvarvarande egenskaperna direkt.

Den grundläggande strukturen för Code-Behind-filen

Filen bakom koden består av ett enda namnområde, MyControls, som innehåller två klasser, MyControl1 och MyControlEventArgs.

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

Den första klassen, MyControl1, är en partiell klass som innehåller koden som implementerar funktionerna i användargränssnittet som definieras i MyControl1.xaml. När MyControl1.xaml parsas konverteras XAML till samma partiella klass och de två partiella klasserna sammanfogas för att bilda den kompilerade kontrollen. Därför måste klassnamnet i filen code-behind matcha klassnamnet som tilldelats MyControl1.xaml, och det måste ärva från rotelementet i kontrollen. Den andra klassen, MyControlEventArgs, är en klass för händelseargument som används för att skicka tillbaka data till värden.

Öppna MyControl1.xaml.cs. Ändra den befintliga klassdeklarationen så att den har följande namn och ärver från Grid.

public partial class MyControl1 : Grid

Initialisera styrningen

Följande kod implementerar flera grundläggande uppgifter:

  • Deklarerar en privat händelse, OnButtonClick, och dess associerade delegering, MyControlEventHandler.

  • Skapar flera privata globala variabler som lagrar användarens data. Dessa data exponeras via motsvarande egenskaper.

  • Implementerar en hanterare, Init, för kontrollens Loaded händelse. Den här hanteraren initierar de globala variablerna genom att tilldela dem de värden som definierats i MyControl1.xaml. För att göra detta använder den Name som tilldelats ett typiskt TextBlock-element, nameLabel, för att komma åt elementets egenskapsinställningar.

Ta bort den befintliga konstruktorn och lägg till följande kod i klassen 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;
}

Hantera knapparnas klickhändelser

Användaren anger att datainmatningsaktiviteten har slutförts genom att antingen klicka på knappen OK eller knappen Avbryt. Båda knapparna använder samma Click händelsehanterare, ButtonClicked. Båda knapparna har ett namn, btnOK eller btnCancel, som gör det möjligt för hanteraren att avgöra vilken knapp som klickades genom att undersöka värdet för argumentet sender. Hanteraren gör följande:

  • Skapar ett MyControlEventArgs objekt som innehåller data från de TextBox elementen.

  • Om användaren klickade på knappen Avbryt, ska du ange MyControlEventArgs-egenskapen hos objektet IsOK till false.

  • Utlöser OnButtonClick-händelsen för att indikera för värddatorn att användaren är klar, och returnerar de insamlade uppgifterna.

Lägg till följande kod i klassen MyControl1 efter metoden 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);
}

Skapa egenskaper

Resten av klassen exponerar helt enkelt egenskaper som motsvarar de globala variabler som beskrevs tidigare. När en egenskap ändras ändrar set-åtkomstorn kontrollens utseende genom att ändra motsvarande elementegenskaper och uppdatera de underliggande globala variablerna.

Lägg till följande kod i klassen 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;
    }
}

Skicka tillbaka data till värddatorn

Den sista komponenten i filen är klassen MyControlEventArgs, som används för att skicka insamlade data tillbaka till hostdatorn.

Lägg till följande kod i ditt MyControls namnområde. Implementeringen är enkel och diskuteras inte ytterligare.

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; }
    }
}

Skapa lösningen. Bygget skapar en DLL med namnet MyControls.dll.

Implementera Värdprogrammet för Windows Forms

Värdprogrammet för Windows Forms använder ett ElementHost-objekt som värd för den sammansatta WPF-kontrollen. Programmet hanterar den OnButtonClick händelsen för att ta emot data från den sammansatta kontrollen. Programmet har också en uppsättning alternativknappar som du kan använda för att ändra kontrollens utseende. Följande bild visar programmet.

Följande bild visar en SAMMANSATT WPF-kontroll som finns i ett Windows Forms-program

Skärmbild som visar ett Windows-formulär som är värd för en Avalon-kontroll.

Skapa projektet

Så här startar du projektet:

  1. Starta Visual Studio och öppna dialogrutan Nytt projekt.

  2. I Visual C# och kategorin Windows väljer du mallen Windows Forms Application.

  3. Ge det nya projektet namnet WFHost.

  4. För platsen anger du samma mapp på den översta nivån som innehåller MyControls-projektet.

  5. Klicka på OK för att skapa projektet.

Du måste också lägga till referenser till DLL som innehåller MyControl1 och andra sammansättningar.

  1. Högerklicka på projektnamnet i Solution Explorer och välj Lägg till referens.

  2. Klicka på fliken Bläddra och gå till mappen som innehåller MyControls.dll. För den här genomgången är den här mappen MyControls\bin\Debug.

  3. Välj MyControls.dlloch klicka sedan på OK.

  4. Lägg till referenser till följande sammansättningar.

    • PresentationCore

    • PresentationFramework

    • System.Xaml

    • WindowsBase

    • WindowsFormsIntegration

Implementera användargränssnittet för programmet

Användargränssnittet för Windows-formulärprogrammet innehåller flera kontroller för att interagera med den sammansatta WPF-kontrollen.

  1. Öppna Formulär1 i Windows-formulärdesignern.

  2. Förstora formuläret så att det passar kontrollerna.

  3. I det övre högra hörnet av formuläret, lägg till ett System.Windows.Forms.Panel-kontrollelement för att hålla den sammansatta WPF-kontrollen.

  4. Lägg till följande System.Windows.Forms.GroupBox kontroller i formuläret.

    Namn Text
    groupBox1 Bakgrundsfärg
    groupBox2 Förgrundsfärg
    groupBox3 Teckenstorlek
    groupBox4 Teckensnittsfamilj
    groupBox5 Typsnittsstil
    groupBox6 Typsnittsvikt
    groupBox7 Data från kontroll

  5. Lägg till följande System.Windows.Forms.RadioButton kontroller i System.Windows.Forms.GroupBox-kontrollerna.

    Gruppruta Namn Text
    groupBox1 radioBackgroundOriginal Original
    groupBox1 radio-bakgrund ljusgrön Ljusgrön
    groupBox1 radioBakgrundLjuslaxrosa LightSalmon
    groupBox2 radioForegroundOriginal Ursprunglig
    groupBox2 radioFörgrundRöd Röd
    groupBox2 radioForegroundYellow Gul
    groupBox3 radioStorlekOriginal Original
    GruppBox3 radioSizeTen 10
    groupBox3 radioSizeTwelve 12
    groupBox4 radioFamilyOriginal Original
    groupBox4 radioFamilyTimes Times New Roman
    groupBox4 radioFamilyWingDings Wingdings
    groupBox5 radioStyleOriginal Normal
    groupBox5 radioStyleItalic Kursiv
    groupBox6 radioWeightOriginal Original
    groupBox6 radioWeightBold Djärv

  6. Lägg till följande System.Windows.Forms.Label kontroller till den sista System.Windows.Forms.GroupBox. Dessa kontroller visar de data som returneras av den sammansatta WPF-kontrollen.

    Gruppruta Namn Text
    groupBox7 lblName Namn:
    groupBox7 lblAdress Gatuadress:
    groupBox7 lblCity Stad:
    groupBox7 lblStat Tillstånd:
    groupBox7 lblZip Postnummer:

Initiera formuläret

Du implementerar vanligtvis värdkoden i formulärets Load händelsehanterare. Följande kod visar Load händelsehanterare, en hanterare för den sammansatta WPF-kontrollens Loaded händelse och deklarationer för flera globala variabler som används senare.

Dubbelklicka på formuläret i Windows Forms Designer för att skapa en Load händelsehanterare. Lägg till följande using-instruktioner överst i Form1.cs.

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

Ersätt innehållet i den befintliga Form1-klassen med följande kod.

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;
}

Metoden Form1_Load i föregående kod visar den allmänna proceduren för att vara värd för en WPF-kontroll:

  1. Skapa ett nytt ElementHost objekt.

  2. Ange kontrollens egenskap Dock till DockStyle.Fill.

  3. Lägg till kontrollen ElementHost i Panel-kontrollens Controls-samling.

  4. Skapa en instans av WPF-kontrollen.

  5. Placera den sammansatta kontrollen på formuläret genom att tilldela kontrollen till ElementHost-kontrollens Child-egenskapen.

De återstående två raderna i Form1_Load-metoden kopplar hanterare till två kontrollhändelser:

  • OnButtonClick är en anpassad händelse som utlöses av den sammansatta kontrollen när användaren klickar på knappen OK eller Avbryt. Du hanterar händelsen för att hämta användarens svar och för att samla in data som användaren har angett.

  • Loaded är en standardhändelse som utlöses av en WPF-kontroll när den är fullständigt laddad. Händelsen används här eftersom exemplet måste initiera flera globala variabler med hjälp av egenskaper från kontrollen. Vid tidpunkten för formulärets Load händelse läses kontrollen inte in helt och dessa värden är fortfarande inställda på null. Du måste vänta tills kontrollens Loaded händelse inträffar innan du kan komma åt dessa egenskaper.

Händelsehanteraren Loaded visas i föregående kod. OnButtonClick-hanteraren beskrivs i nästa avsnitt.

Hantera OnButtonClick

Händelsen OnButtonClick inträffar när användaren klickar på knappen OK eller Avbryt.

Händelsehanteraren kontrollerar händelseargumentets IsOK fält för att avgöra vilken knapp som klickades. lbl data variablerna motsvarar de Label kontroller som diskuterades tidigare. Om användaren klickar på OK-knappen tilldelas data från kontrollens TextBox kontrollinställningar till motsvarande Label kontroll. Om användaren klickar på Avbrytsätts Text värdena till standardsträngarna.

Lägg till följande kod för knappklickshändelsehanterare i klassen 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: ";
    }
}

Skapa och kör programmet. Lägg till text i den sammansatta WPF-kontrollen och klicka sedan på OK. Texten visas i etiketterna. I det här läget har ingen kod lagts till ännu för att hantera alternativknapparna.

Ändra kontrollens utseende

Med RadioButton kontroller i formuläret kan användaren ändra wpf-kontrollens förgrunds- och bakgrundsfärger samt flera teckensnittsegenskaper. Bakgrundsfärgen exponeras av ElementHost-objektet. De återstående egenskaperna exponeras som anpassade egenskaper för kontrollen.

Dubbelklicka på varje RadioButton-kontroll i formuläret för att skapa CheckedChanged-händelsehanterare. Ersätt CheckedChanged händelsehanterare med följande kod.

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;
}

Skapa och kör programmet. Klicka på de olika radioknapparna för att se effekten på WPF-sammansatta kontrollen.

Se även