Stapsgewijze handleiding: Een WPF-Samengesteld Besturingselement Hosten in Windows Forms

Windows Presentation Foundation (WPF) biedt een uitgebreide omgeving voor het maken van toepassingen. Als u echter een aanzienlijke investering in Windows Forms-code hebt, kan het effectiever zijn om uw bestaande Windows Forms-toepassing uit te breiden met WPF in plaats van deze opnieuw te schrijven. Als u een of meer besturingselementen wilt insluiten die zijn geïmplementeerd met WPF in uw Windows Forms-toepassing, is dat een veelvoorkomend scenario. Zie Aanpassing van beheeropties voor meer informatie over het aanpassen van WPF-besturingselementen.

In dit overzicht wordt u stapsgewijs begeleid bij een toepassing die als host fungeert voor een WPF-samengesteld besturingselement om gegevensinvoer uit te voeren in een Windows Forms-toepassing. Het samengestelde besturingselement is ingepakt in een DLL. Deze algemene procedure kan worden uitgebreid naar complexere toepassingen en besturingselementen. Deze stapsgewijze uitleg is ontworpen om bijna identiek te zijn qua uiterlijk en functionaliteit aan Walkthrough: Hosting a Windows Forms Composite Control in WPF. Het belangrijkste verschil is dat het hostingscenario wordt omgekeerd.

De handleiding is onderverdeeld in twee delen. In de eerste sectie wordt kort de implementatie van de WPF-samengestelde controle beschreven. In de tweede sectie wordt in detail besproken hoe u het samengestelde besturingselement in een Windows Forms-toepassing host, gebeurtenissen ontvangt van het besturingselement en toegang krijgt tot enkele eigenschappen van het besturingselement.

De taken die in deze handleiding worden geïllustreerd, zijn onder andere:

• Het WPF-composite-besturingselement implementeren.

• De Windows Forms-hosttoepassing implementeren.

Zie Hosting a WPF Composite Control in Windows Forms Sample (Hosten van een WPF Composite Control in Windows Forms Sample) voor een volledige codevermelding van de taken die in dit scenario worden geïllustreerd.

Vereiste voorwaarden

U hebt Visual Studio nodig om deze walkthrough te voltooien.

Implementatie van het WPF-samengestelde besturingselement

Het samengestelde WPF-besturingselement dat in dit voorbeeld wordt gebruikt, is een eenvoudig gegevensinvoerformulier dat de naam en het adres van de gebruiker gebruikt. Wanneer de gebruiker op een van de twee knoppen klikt om aan te geven dat de taak is voltooid, genereert het besturingselement een aangepaste gebeurtenis om die informatie naar de host te retourneren. In de volgende afbeelding ziet u het weergegeven besturingselement.

In de volgende afbeelding ziet u een WPF composite control:

Het project maken

Het project starten:

1. Start Visual Studio en open het dialoogvenster Nieuw project.

2. Selecteer in de Windows-categorie van Visual C# de sjabloon WPF User Control Library.

3. Geef het nieuwe project de naam MyControls.

4. Geef voor de locatie een gemakkelijk benoemde map op het hoogste niveau op, zoals WindowsFormsHostingWpfControl. Plaats later de hosttoepassing in deze map.

5. Klik op OK- om het project te maken. Het standaardproject bevat één besturingselement met de naam UserControl1.

6. Wijzig de naam van UserControl1 in Solution Explorer in MyControl1.

Uw project moet verwijzingen hebben naar de volgende systeem-DLL's. Als een van deze DLL's niet standaard is opgenomen, voegt u deze toe aan uw project.

• PresentationCore

• PresentationFramework

• Systeem

• WindowsBase

De gebruikersinterface maken

De gebruikersinterface (UI) voor het samengestelde besturingselement wordt geïmplementeerd met Extensible Application Markup Language (XAML). De gebruikersinterface voor samengestelde besturingselementen bestaat uit vijf TextBox elementen. Elk TextBox element heeft een gekoppeld TextBlock element dat fungeert als een label. Er zijn twee Button elementen onderaan, OK en Annuleren. Wanneer de gebruiker op een van de knoppen klikt, genereert het besturingselement een aangepaste gebeurtenis om de gegevens naar de host te retourneren.

Basisindeling

De verschillende elementen van de gebruikersinterface zijn opgenomen in een Grid element. U kunt Grid de inhoud van het samengestelde besturingselement op ongeveer dezelfde manier rangschikken als u een Table element in HTML zou gebruiken. WPF heeft ook een Table element, maar Grid is lichter en beter geschikt voor eenvoudige indelingstaken.

In de volgende XAML ziet u de basisindeling. Deze XAML definieert de algehele structuur van het besturingselement door het aantal kolommen en rijen in het Grid element op te geven.

Vervang in MyControl1.xaml de bestaande XAML door de volgende 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>

TextBlock- en Tekstvakelementen toevoegen aan het raster

U plaatst een UI-element in het raster door de RowProperty en ColumnProperty attributen van het element in te stellen op het juiste rij- en kolomnummer. Houd er rekening mee dat rij- en kolomnummering nul zijn. U kunt een element uit meerdere kolommen laten bestaan door het kenmerk ervan ColumnSpanProperty in te stellen. Zie Grid voor meer informatie over elementen.

De volgende XAML toont de samengestelde besturingselementen TextBox en TextBlock met hun RowProperty en ColumnProperty attributen, die zijn ingesteld om de elementen correct te plaatsen in het raster.

Voeg in MyControl1.xaml de volgende XAML toe binnen het Grid element.

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

De elementen van de gebruikersinterface stylen

Veel van de elementen in het gegevensinvoerformulier hebben een vergelijkbaar uiterlijk, wat betekent dat ze identieke instellingen hebben voor verschillende eigenschappen. In plaats van de kenmerken van elk element afzonderlijk in te stellen, gebruikt Style de vorige XAML elementen om standaardeigenschapsinstellingen te definiëren voor klassen van elementen. Deze benadering vermindert de complexiteit van het besturingselement en stelt u in staat om het uiterlijk van meerdere elementen te wijzigen via één stijlkenmerk.

De Style elementen bevinden zich in de eigenschap van Grid het Resources element, zodat ze kunnen worden gebruikt door alle elementen in het besturingselement. Als een stijl een naam heeft, past u deze toe op een element door een Style element toe te voegen dat is ingesteld op de naam van de stijl. Stijlen die niet de naam hebben, worden de standaardstijl voor het element. Zie Styling en Templating voor meer informatie over WPF-stijlen.

In de volgende XAML worden de Style elementen voor het samengestelde besturingselement weergegeven. Zie de vorige XAML om te zien hoe de stijlen worden toegepast op elementen. Het laatste TextBlock element heeft bijvoorbeeld de inlineText stijl en het laatste TextBox element gebruikt de standaardstijl.

Voeg in MyControl1.xaml de volgende XAML toe vlak na het Grid beginelement.

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

De knoppen OK en Annuleren toevoegen

De laatste elementen van het samengestelde controle-element zijn de knoppen OK en AnnulerenButton, die de eerste twee kolommen van de laatste rij van de Grid innemen. Deze elementen maken gebruik van een algemene gebeurtenishandler ButtonClickeden de standaardstijl Button die is gedefinieerd in de vorige XAML.

Voeg in MyControl1.xaml de volgende XAML toe na het laatste TextBox element. Het XAML-deel van het samengestelde besturingselement is nu voltooid.

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

Het Code-Behind-bestand implementeren

Het code-behind-bestand, MyControl1.xaml.cs, implementeert drie essentiële taken:

1. Hiermee wordt de gebeurtenis verwerkt die optreedt wanneer de gebruiker op een van de knoppen klikt.

2. Haalt de gegevens op uit de TextBox elementen en verpakt deze in een aangepast gebeurtenisargumentobject.

3. Hiermee wordt de aangepaste OnButtonClick gebeurtenis gegenereerd, die de host aangeeft dat de gebruiker is voltooid en de gegevens weer doorgeeft aan de host.

Het besturingselement bevat ook een aantal kleur- en lettertype-eigenschappen waarmee u het uiterlijk kunt wijzigen. In tegenstelling tot de WindowsFormsHost klasse, die wordt gebruikt voor het hosten van een Windows Forms-besturingselement, maakt de ElementHost klasse alleen de eigenschap van Background het besturingselement beschikbaar. Om de gelijkenis tussen dit codevoorbeeld en het voorbeeld dat wordt besproken in Walkthrough te behouden: Als u een windows Forms Composite-besturingselement host in WPF, worden de resterende eigenschappen rechtstreeks weergegeven.

De basisstructuur van het Code-Behind-bestand

Het code-behind-bestand bestaat uit één naamruimte, MyControlsdie twee klassen MyControl1 bevat en MyControlEventArgs.

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

De eerste klasse, MyControl1is een gedeeltelijke klasse die de code bevat waarmee de functionaliteit van de gebruikersinterface wordt geïmplementeerd die is gedefinieerd in MyControl1.xaml. Wanneer MyControl1.xaml wordt geparseerd, wordt de XAML geconverteerd naar dezelfde gedeeltelijke klasse en worden de twee gedeeltelijke klassen samengevoegd om het gecompileerde besturingselement te vormen. Daarom moet de klassenaam in het code-behind-bestand overeenkomen met de klassenaam die is toegewezen aan MyControl1.xaml en moet deze overnemen van het hoofdelement van het besturingselement. De tweede klasse, MyControlEventArgsis een gebeurtenisargumentklasse die wordt gebruikt om de gegevens terug te sturen naar de host.

Open MyControl1.xaml.cs. Wijzig de bestaande klassedeclaratie zodat deze de volgende naam heeft en erft van Grid.

public partial class MyControl1 : Grid

De besturing initialiseren

Met de volgende code worden verschillende basistaken geïmplementeerd:

• Verklaart een privégebeurtenis, OnButtonClick, en de bijbehorende gedelegeerde, MyControlEventHandler.

• Hiermee maakt u verschillende globale privévariabelen waarmee de gegevens van de gebruiker worden opgeslagen. Deze gegevens worden weergegeven via de bijbehorende eigenschappen.

• Implementeert een handler, Init, voor de Loaded gebeurtenis van het besturingselement. Met deze handler worden de globale variabelen geïnitialiseerd door ze de waarden toe te wijzen die zijn gedefinieerd in MyControl1.xaml. Hiervoor wordt de Name die is toegewezen aan een typisch TextBlock element, nameLabel, gebruikt om toegang te krijgen tot de eigenschapsinstellingen van dat element.

Verwijder de bestaande constructor en voeg de volgende code toe aan uw MyControl1 klasse.

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

De klik-gebeurtenissen van de knoppen verwerken

De gebruiker geeft aan dat de gegevensinvoertaak is voltooid door op de knop OK of op de knop Annuleren te klikken. Beide knoppen gebruiken dezelfde Click gebeurtenis-handler, ButtonClicked. Beide knoppen hebben een naam of btnOKbtnCancel, waarmee de handler kan bepalen op welke knop is geklikt door de waarde van het sender argument te onderzoeken. De handler doet het volgende:

• Hiermee maakt u een MyControlEventArgs object dat de gegevens van de TextBox elementen bevat.

• Als de gebruiker op de knop Annuleren klikt, stel je de eigenschap MyControlEventArgs van het IsOK object in op false.

• Hiermee wordt de OnButtonClick gebeurtenis gegenereerd om aan de host aan te geven dat de gebruiker klaar is en worden de verzamelde gegevens teruggegeven.

Voeg na de MyControl1 methode de volgende code toe aan uw Init klasse.

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

Eigenschappen maken

In de rest van de klasse worden eenvoudig eigenschappen weergegeven die overeenkomen met de globale variabelen die eerder zijn besproken. Wanneer een eigenschap wordt gewijzigd, wijzigt de set accessor het uiterlijk van het besturingselement door de bijbehorende elementeigenschappen te wijzigen en de onderliggende globale variabelen bij te werken.

Voeg de volgende code toe aan uw MyControl1 klasse.

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

De gegevens terugsturen naar de host

Het laatste onderdeel in het bestand is de MyControlEventArgs klasse die wordt gebruikt om de verzamelde gegevens terug te sturen naar de host.

Voeg de volgende code toe aan uw MyControls naamruimte. De implementatie is eenvoudig en wordt niet verder besproken.

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

Bouw de oplossing. De build produceert een DLL met de naam MyControls.dll.

De Windows Forms Host-toepassing implementeren

De Windows Forms-hosttoepassing gebruikt een ElementHost object om het WPF-samengestelde besturingselement te hosten. De toepassing verwerkt de OnButtonClick gebeurtenis om de gegevens van het samengestelde besturingselement te ontvangen. De toepassing heeft ook een set keuzerondelen die u kunt gebruiken om het uiterlijk van het bedieningselement te wijzigen. In de volgende afbeelding ziet u de toepassing.

In de volgende afbeelding ziet u een WPF-samengestelde besturing die wordt gehost in een Windows Forms-toepassing

Het project maken

Het project starten:

1. Start Visual Studio en open het dialoogvenster Nieuw project.

2. Selecteer in Visual C# en de Windows-categorie de template Windows Forms Application.

3. Geef het nieuwe project de naam WFHost.

4. Geef voor de locatie dezelfde map op het hoogste niveau op die het Project MyControls bevat.

5. Klik op OK- om het project te maken.

U moet ook verwijzingen toevoegen naar het DLL-bestand met MyControl1 en andere assembly's.

1. Klik met de rechtermuisknop op de projectnaam in Solution Explorer en selecteer Verwijzing toevoegen.

2. Klik op het tabblad Bladeren en blader naar de map die MyControls.dllbevat. Voor deze stapsgewijze handleiding is deze map MyControls\bin\Debug.

3. Selecteer MyControls.dllen klik vervolgens op OK-.

4. Voeg verwijzingen toe aan de volgende assemblies.

   • PresentationCore

   • PresentationFramework

   • System.Xaml

   • WindowsBase

   • WindowsFormsIntegration

De gebruikersinterface voor de toepassing implementeren

De gebruikersinterface van de Windows Form-toepassing bevat verschillende bedieningselementen om te communiceren met het WPF-samengestelde element.

1. Open Form1 in the Windows Form Designer.

2. Vergroot het formulier om ruimte te bieden aan de besturingselementen.

3. Voeg in de rechterbovenhoek van het formulier een System.Windows.Forms.Panel-besturingselement toe om het samengestelde WPF-besturingselement te herbergen.

4. Voeg de volgende System.Windows.Forms.GroupBox besturingselementen toe aan het formulier.

   Naam	Tekst
   groupBox1	Achtergrondkleur
   groupBox2	Voorgrondkleur
   groupBox3	Tekengrootte
   groupBox4	Lettertypefamilie
   groupBox5	Tekenstijl
   groupBox6	Lettergewicht
   groupBox7	Gegevens uit het besturingselement

5. Voeg de volgende System.Windows.Forms.RadioButton besturingselementen toe aan de System.Windows.Forms.GroupBox besturingselementen.

   Groepsvak	Naam	Tekst
   groupBox1	radioAchtergrondOrigineel	Originele Tekst
   groupBox1	radioAchtergrondLichtGroen	Lichtgroen
   groupBox1	radioAchtergrondLichtZalm	LightSalmon
   groupBox2	radioForegroundOriginal	Originele Tekst
   groupBox2	radioVoorgrondRood	Rood
   groupBox2	radioVoorgrondGeel	Geel
   groupBox3	originele radioformaat	Originele Tekst
   groupBox3	radioSizeTen	10
   groupBox3	radioSizeTwelve	12
   groupBox4	radioFamilieOrigineel	Originele Tekst
   groupBox4	radioFamilieTijden	Times New Roman
   groupBox4	radioFamilyWingDings	Wingdings
   groupBox5	radioStyleOriginal	Normaal
   groupBox5	radioStyleItalic	Cursief
   groupBox6	radioWeightOriginal	Originele Tekst
   groupBox6	radioWeightBold	Vetgedrukt

6. Voeg de volgende System.Windows.Forms.Label besturingselementen toe aan de laatste System.Windows.Forms.GroupBox. Met deze besturingselementen worden de gegevens weergegeven die worden geretourneerd door het samengestelde WPF-besturingselement.

   Groepsvak	Naam	Tekst
   groupBox7	lblName	Naam:
   groupBox7	lblAdres	Adres:
   groupBox7	lblStad	Stad:
   groupBox7	lblState	Staat:
   groupBox7	lblZip	Ritssluiting:

Het formulier initialiseren

Over het algemeen implementeert u de hostingcode in de gebeurtenis-handler van Load het formulier. De volgende code toont de Load gebeurtenis-handler, een handler voor de Loaded gebeurtenis van het samengestelde WPF-besturingselement, en declaraties voor verschillende globale variabelen die later worden gebruikt.

Dubbelklik in Windows Forms Designer op het formulier om een Load gebeurtenis-handler te maken. Voeg bovenaan Form1.cs de volgende using instructies toe.

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

Vervang de inhoud van de bestaande Form1 klasse door de volgende code.

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

De Form1_Load methode in de voorgaande code toont de algemene procedure voor het hosten van een WPF-besturingselement:

1. Maak een nieuw ElementHost-object.

2. Stel de eigenschap Dock van het besturingselement in op DockStyle.Fill.

3. Voeg het ElementHost besturingselement toe aan de Panel verzameling van het Controls besturingselement.

4. Maak een exemplaar van het WPF-besturingselement.

5. Host het samengestelde besturingselement op het formulier door het toe te wijzen aan de eigenschap van het ElementHost besturingselement in Child.

De resterende twee regels in de Form1_Load methode koppelen handlers aan twee besturingselementen:

• OnButtonClick is een aangepaste gebeurtenis die wordt geactiveerd door het samengestelde besturingselement wanneer de gebruiker op de knop OK of Annuleren klikt. U verwerkt de gebeurtenis om het antwoord van de gebruiker op te halen en gegevens te verzamelen die de gebruiker heeft opgegeven.

• Loaded is een standaardgebeurtenis die wordt gegenereerd door een WPF-besturingselement wanneer deze volledig wordt geladen. De gebeurtenis wordt hier gebruikt omdat het voorbeeld verschillende globale variabelen moet initialiseren met behulp van eigenschappen van het besturingselement. Op het moment van de gebeurtenis van het formulier Load wordt het besturingselement niet volledig geladen en worden deze waarden nog steeds ingesteld op null. U moet wachten tot de gebeurtenis van Loaded plaatsvindt voordat u toegang krijgt tot die eigenschappen.

De Loaded gebeurtenis-handler wordt weergegeven in de voorgaande code. De OnButtonClick handler wordt in de volgende sectie besproken.

Afhandeling van OnButtonClick

De OnButtonClick gebeurtenis treedt op wanneer de gebruiker op de knop OK of Annuleren klikt.

De gebeurtenishandler controleert het veld van IsOK het gebeurtenisargument om te bepalen op welke knop is geklikt. De lblgegevensvariabelen komen overeen met de Label besturingselementen die eerder zijn besproken. Als de gebruiker op de knop OK klikt, worden de gegevens van de besturingselementen van het besturingselement TextBox toegewezen aan het bijbehorende besturingselement Label . Als de gebruiker op Annuleren klikt, worden de Text waarden ingesteld op de standaardtekenreeksen.

Voeg de volgende code voor de knopklik-gebeurtenishandler toe aan de Form1-klasse.

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

Bouw en voer de toepassing uit. Voeg tekst toe in het WPF-samengestelde controle en klik op OK. De tekst wordt weergegeven in de labels. Op dit moment is er geen code toegevoegd om de keuzerondjes te verwerken.

Het uiterlijk van het besturingselement wijzigen

Met de RadioButton besturingselementen in het formulier kan de gebruiker de voorgrond- en achtergrondkleuren van het WPF-besturingselement en verschillende lettertype-eigenschappen wijzigen. De achtergrondkleur wordt weergegeven door het ElementHost object. De resterende eigenschappen worden weergegeven als aangepaste eigenschappen van het besturingselement.

Dubbelklik op elk RadioButton controle op het formulier om CheckedChanged gebeurtenishandlers te maken. Vervang de CheckedChanged eventhandlers door de volgende code.

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

Bouw en voer de toepassing uit. Klik op de verschillende keuzerondjes om het effect op de WPF-composite control te zien.

Zie ook

• ElementHost
• WindowsFormsHost
• XAML ontwerpen in Visual Studio
• Handleiding: Een Windows Forms Composite Control hosten in WPF
• Stapsgewijze Handleiding: Een 3D WPF Composite Control hosten in Windows Forms