Genomgång: Att vara värd för en sammanställd Windows Forms-kontroll i WPF

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 effektivare att återanvända åtminstone en del av koden i wpf-programmet i stället för att skriva om den från grunden. Det vanligaste scenariot är när du har befintliga Windows Forms-kontroller. I vissa fall kanske du inte ens har åtkomst till källkoden för dessa kontroller. WPF är en enkel procedur för att hantera sådana kontroller i ett WPF-program. Du kan till exempel använda WPF för de flesta av dina programmeringar när du är värd för dina specialiserade DataGridView kontroller.

Den här genomgången vägleder dig genom ett program som är värd för en sammansatt Windows Forms-kontroll för att utföra datainmatning i ett WPF-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 Genomgång: Värd för en WPF Sammansatt Kontroll i Windows Forms. 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 kontrollen Windows Forms. I det andra avsnittet beskrivs i detalj hur du är värd för den sammansatta kontrollen i ett WPF-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:

• Implementera sammansatta Windows Forms-kontroller.

• Implementera WPF-värdprogrammet.

En fullständig kodlista över de uppgifter som illustreras i den här genomgången finns i Hantera en sammansatt Windows Forms-kontroll i WPF-exempel.

Förutsättningar

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

Implementera sammansatt kontroll för Windows Forms

Den sammansatta Windows Forms-kontrollen som används i det här exemplet är ett enkelt formulär för datainmatning. Det här formuläret tar användarens namn och adress och använder sedan en anpassad händelse för att returnera informationen till servern. Följande bild visar den renderade kontrollen.

Följande bild visar en sammansatt Windows Forms-kontroll:

Skapa projektet

Så här startar du projektet:

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

2. I kategorin Fönster väljer du mallen Kontrollbibliotek för Windows Forms .

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

• Systemet

• System.Data

• System.Drawing

• System.Windows.Forms

• System.Xml

Lägga till kontroller i formuläret

Så här lägger du till kontroller i formuläret:

• Öppna MyControl1 i designern.

Lägg till fem Label kontroller och deras motsvarande TextBox kontroller, med samma storlek och arrangemang som i bilden ovan, på formuläret. I exemplet TextBox heter kontrollerna:

• txtName

• txtAddress

• txtCity

• txtState

• txtZip

Lägg till två Button kontroller med etiketten OK och Avbryt. I exemplet är knappnamnen btnOK och btnCancel respektive.

Implementera den stödjande koden

Öppna formuläret i kodvyn. Kontrollen returnerar insamlade data till värden genom att utlösa det anpassade OnButtonClick-evenemanget. Data finns i händelseargumentobjektet. Följande kod visar händelsen och ombudsdeklarationen.

Lägg till följande kod i MyControl1 klassen.

public delegate void MyControlEventHandler(object sender, MyControlEventArgs args);
public event MyControlEventHandler OnButtonClick;

Public Delegate Sub MyControlEventHandler(ByVal sender As Object, ByVal args As MyControlEventArgs)
Public Event OnButtonClick As MyControlEventHandler

Klassen MyControlEventArgs innehåller den information som ska returneras till värddatorn.

Lägg till följande klass i formuläret.

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

Public Class MyControlEventArgs
    Inherits EventArgs
    Private _Name As String
    Private _StreetAddress As String
    Private _City As String
    Private _State As String
    Private _Zip As String
    Private _IsOK As Boolean
    
    
    Public Sub New(ByVal result As Boolean, ByVal name As String, ByVal address As String, ByVal city As String, ByVal state As String, ByVal zip As String) 
        _IsOK = result
        _Name = name
        _StreetAddress = address
        _City = city
        _State = state
        _Zip = zip
    
    End Sub
    
    
    Public Property MyName() As String 
        Get
            Return _Name
        End Get
        Set
            _Name = value
        End Set
    End Property
    
    Public Property MyStreetAddress() As String 
        Get
            Return _StreetAddress
        End Get
        Set
            _StreetAddress = value
        End Set
    End Property
    
    Public Property MyCity() As String 
        Get
            Return _City
        End Get
        Set
            _City = value
        End Set
    End Property
    
    Public Property MyState() As String 
        Get
            Return _State
        End Get
        Set
            _State = value
        End Set
    End Property
    
    Public Property MyZip() As String 
        Get
            Return _Zip
        End Get
        Set
            _Zip = value
        End Set
    End Property
    
    Public Property IsOK() As Boolean 
        Get
            Return _IsOK
        End Get
        Set
            _IsOK = value
        End Set
    End Property
End Class

När användaren klickar på knappen OK eller Click skapar händelsehanterarna ett MyControlEventArgs objekt som innehåller data och genererar OnButtonClick händelsen. Den enda skillnaden mellan de två hanterarna är händelseargumentets IsOK egenskap. Den här egenskapen låter värden avgöra vilken knapp som har klickats. Den är inställd true på för OK-knappen och false för knappen Avbryt . Följande kod visar de två knapphanterarna.

Lägg till följande kod i MyControl1 klassen.

private void btnOK_Click(object sender, System.EventArgs e)
{

    MyControlEventArgs retvals = new MyControlEventArgs(true,
                                                         txtName.Text,
                                                         txtAddress.Text,
                                                         txtCity.Text,
                                                         txtState.Text,
                                                         txtZip.Text);
    OnButtonClick(this, retvals);
}

private void btnCancel_Click(object sender, System.EventArgs e)
{
    MyControlEventArgs retvals = new MyControlEventArgs(false,
                                                         txtName.Text,
                                                         txtAddress.Text,
                                                         txtCity.Text,
                                                         txtState.Text,
                                                         txtZip.Text);
    OnButtonClick(this, retvals);
}

Private Sub btnOK_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles btnOK.Click

    Dim retvals As New MyControlEventArgs(True, txtName.Text, txtAddress.Text, txtCity.Text, txtState.Text, txtZip.Text)
    RaiseEvent OnButtonClick(Me, retvals)

End Sub

Private Sub btnCancel_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles btnCancel.Click
    Dim retvals As New MyControlEventArgs(False, txtName.Text, txtAddress.Text, txtCity.Text, txtState.Text, txtZip.Text)
    RaiseEvent OnButtonClick(Me, retvals)

End Sub

Ge en starkt namn åt samlingen och bygg samlingen

För att den här sammansättningen ska refereras av ett WPF-program måste den ha ett starkt namn. Skapa ett starkt namn genom att skapa en nyckelfil med Sn.exe och lägga till den i projektet.

1. Öppna en Visual Studio-kommandotolk. Det gör du genom att klicka på Start-menyn och sedan välja Alla program/Microsoft Visual Studio 2010/Visual Studio Tools/Visual Studio-kommandotolken. Detta startar ett konsolfönster med anpassade miljövariabler.

2. I kommandotolken använder du cd kommandot för att gå till projektmappen.

3. Generera en nyckelfil med namnet MyControls.snk genom att köra följande kommando.

   Sn.exe -k MyControls.snk
   

4. Om du vill inkludera nyckelfilen i projektet högerklickar du på projektnamnet i Solution Explorer och klickar sedan på Egenskaper. I Projektdesignern klickar du på fliken Signering , markerar kryssrutan Signera sammansättningen och bläddrar sedan till nyckelfilen.

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

Implementera WPF-värdprogrammet

WPF-värdprogrammet använder WindowsFormsHost-kontrollen för att vara värd för MyControl1. Programmet hanterar OnButtonClick händelsen för att ta emot data från kontrollen. Den har också en samling alternativknappar som gör att du kan ändra vissa av kontrollens egenskaper från WPF-programmet. Följande bild visar det färdiga programmet.

Följande bild visar hela programmet, inklusive kontrollen som är inbäddad i WPF-programmet:

Skapa projektet

Så här startar du projektet:

1. Öppna Visual Studio och välj Nytt projekt.

2. I kategorin Fönster väljer du mallen WPF-applikation.

3. Ge det nya projektet namnet WpfHost.

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 en referens till sammansättningen WindowsFormsIntegration, som heter WindowsFormsIntegration.dll.

Implementera den grundläggande layouten

Användargränssnittet (UI) för värdprogrammet implementeras i MainWindow.xaml. Den här filen innehåller XAML-markering (Extensible Application Markup Language) som definierar layouten och är värd för Windows Forms-kontrollen. Programmet är indelat i tre regioner:

• Panelen Kontrollegenskaper , som innehåller en samling alternativknappar som du kan använda för att ändra olika egenskaper för den värdbaserade kontrollen.

• Panelen Data från kontroll , som innehåller flera TextBlock element som visar data som returneras från den värdbaserade kontrollen.

• Den värdbaserade kontrollen.

Den grundläggande layouten visas i följande XAML. Den markering som krävs för att vara värd för MyControl1 utelämnas i det här exemplet, men kommer att diskuteras senare.

Ersätt XAML i MainWindow.xaml med följande. Om du använder Visual Basic ändrar du klassen till x:Class="MainWindow".

<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      x:Class="WpfHost.MainWindow"
      xmlns:mcl="clr-namespace:MyControls;assembly=MyControls"
      Loaded="Init">
  <DockPanel>
    <DockPanel.Resources>
      <Style x:Key="inlineText" TargetType="{x:Type Inline}">
        <Setter Property="FontWeight" Value="Normal"/>
      </Style>
      <Style x:Key="titleText" TargetType="{x:Type TextBlock}">
        <Setter Property="DockPanel.Dock" Value="Top"/>
        <Setter Property="FontWeight" Value="Bold"/>
        <Setter Property="Margin" Value="10,5,10,0"/>
      </Style>
    </DockPanel.Resources>

    <StackPanel Orientation="Vertical"
                DockPanel.Dock="Left"
                Background="Bisque"
                Width="250">

      <TextBlock  Margin="10,10,10,10"
                  FontWeight="Bold"
                  FontSize="12">Control Properties</TextBlock>
      <TextBlock Style="{StaticResource titleText}">Background Color</TextBlock>
      <StackPanel Margin="10,10,10,10">
        <RadioButton Name="rdbtnOriginalBackColor"
                    IsChecked="True"
                    Click="BackColorChanged">Original</RadioButton>
        <RadioButton Name="rdbtnBackGreen"
                    Click="BackColorChanged">LightGreen</RadioButton>
        <RadioButton Name="rdbtnBackSalmon"
                    Click="BackColorChanged">LightSalmon</RadioButton>
      </StackPanel>

      <TextBlock Style="{StaticResource titleText}">Foreground Color</TextBlock>
      <StackPanel Margin="10,10,10,10">
        <RadioButton Name="rdbtnOriginalForeColor"
                    IsChecked="True"
                    Click="ForeColorChanged">Original</RadioButton>
        <RadioButton Name="rdbtnForeRed"
                    Click="ForeColorChanged">Red</RadioButton>
        <RadioButton Name="rdbtnForeYellow"
                    Click="ForeColorChanged">Yellow</RadioButton>
      </StackPanel>

      <TextBlock Style="{StaticResource titleText}">Font Family</TextBlock>
      <StackPanel Margin="10,10,10,10">
        <RadioButton Name="rdbtnOriginalFamily"
                     IsChecked="True"
                    Click="FontChanged">Original</RadioButton>
        <RadioButton Name="rdbtnTimes"
                    Click="FontChanged">Times New Roman</RadioButton>
        <RadioButton Name="rdbtnWingdings"
                    Click="FontChanged">Wingdings</RadioButton>
      </StackPanel>

      <TextBlock Style="{StaticResource titleText}">Font Size</TextBlock>
      <StackPanel Margin="10,10,10,10">
        <RadioButton Name="rdbtnOriginalSize"
                    IsChecked="True"
                    Click="FontSizeChanged">Original</RadioButton>
        <RadioButton Name="rdbtnTen"
                    Click="FontSizeChanged">10</RadioButton>
        <RadioButton Name="rdbtnTwelve"
                    Click="FontSizeChanged">12</RadioButton>
      </StackPanel>

      <TextBlock Style="{StaticResource titleText}">Font Style</TextBlock>
      <StackPanel Margin="10,10,10,10">
        <RadioButton Name="rdbtnNormalStyle"
                     IsChecked="True"
                     Click="StyleChanged">Original</RadioButton>
        <RadioButton Name="rdbtnItalic"
                     Click="StyleChanged">Italic</RadioButton>
      </StackPanel>

      <TextBlock Style="{StaticResource titleText}">Font Weight</TextBlock>
      <StackPanel Margin="10,10,10,10">
        <RadioButton Name="rdbtnOriginalWeight"
                     IsChecked="True"
                   Click="WeightChanged">
          Original
        </RadioButton>
        <RadioButton Name="rdbtnBold"
                   Click="WeightChanged">Bold</RadioButton>
      </StackPanel>
    </StackPanel>

    <WindowsFormsHost Name="wfh"
                     DockPanel.Dock="Top"
                     Height="300">
      <mcl:MyControl1 Name="mc"/>
    </WindowsFormsHost>
    
    <StackPanel Orientation="Vertical"
                Height="Auto"
                Background="LightBlue">
      <TextBlock Margin="10,10,10,10"
            FontWeight="Bold"
            FontSize="12">Data From Control</TextBlock>
      <TextBlock Style="{StaticResource titleText}">
        Name: <Span Name="txtName" Style="{StaticResource inlineText}"/>
      </TextBlock>
      <TextBlock Style="{StaticResource titleText}">
        Street Address: <Span Name="txtAddress" Style="{StaticResource inlineText}"/>
      </TextBlock>
      <TextBlock Style="{StaticResource titleText}">
        City: <Span Name="txtCity" Style="{StaticResource inlineText}"/>
      </TextBlock>
      <TextBlock Style="{StaticResource titleText}">
        State: <Span Name="txtState" Style="{StaticResource inlineText}"/>
      </TextBlock>
      <TextBlock Style="{StaticResource titleText}">
        Zip: <Span Name="txtZip" Style="{StaticResource inlineText}"/>
      </TextBlock>
    </StackPanel>
  </DockPanel>
</Window>

Det första StackPanel elementet innehåller flera uppsättningar RadioButton kontroller som gör att du kan ändra olika standardegenskaper för den värdbaserade kontrollen. Detta följs av ett WindowsFormsHost element som är värd för MyControl1. Det sista StackPanel elementet innehåller flera TextBlock element som visar de data som returneras av den värdbaserade kontrollen. Ordningen av elementen och Dock och Height-attributinställningarna bäddar in den hostade kontrollen i fönstret utan mellanrum eller distorsion.

Att vara värd för styrningen

Den följande redigerade versionen av den tidigare XAML fokuserar på de element som behövs för att vara värd för MyControl1.

<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
      x:Class="WpfHost.MainWindow"
      xmlns:mcl="clr-namespace:MyControls;assembly=MyControls"
      Loaded="Init">

<WindowsFormsHost Name="wfh"
                 DockPanel.Dock="Top"
                 Height="300">
  <mcl:MyControl1 Name="mc"/>
</WindowsFormsHost>

Attributet xmlns för namnområdesmappning skapar en referens till det MyControls namnområde som innehåller den värdbaserade kontrollen. Med den här mappningen kan du representera MyControl1 i XAML som <mcl:MyControl1>.

Två element i XAML hanterar värdskapet:

• WindowsFormsHost representerar elementet WindowsFormsHost som gör att du kan vara värd för en Windows Forms-kontroll i ett WPF-program.

• mcl:MyControl1, som representerar MyControl1, läggs till i elementets WindowsFormsHost underordnade samling. Därför renderas den här Windows Forms-kontrollen som en del av WPF-fönstret och du kan kommunicera med kontrollen från programmet.

Implementering av Code-Behind-filen

Filen bakom koden, MainWindow.xaml.vb eller MainWindow.xaml.cs, innehåller den procedurkod som implementerar funktionerna i användargränssnittet som beskrivs i föregående avsnitt. De primära uppgifterna är:

• Koppla en händelsehanterare till MyControl1OnButtonClick händelsen.

• Ändra olika egenskaper för MyControl1, baserat på hur samlingen med alternativknappar anges.

• Visar de data som samlas in av kontrollen.

Initiera programmet

Initieringskoden finns i en händelsehanterare för fönstrets Loaded händelse och kopplar en händelsehanterare till kontrollens OnButtonClick händelse.

Lägg till följande kod MainWindow i klassen i MainWindow.xaml.vb eller MainWindow.xaml.cs.

private Application app;
private Window myWindow;
FontWeight initFontWeight;
Double initFontSize;
FontStyle initFontStyle;
SolidColorBrush initBackBrush;
SolidColorBrush initForeBrush;
FontFamily initFontFamily;
bool UIIsReady = false;

private void Init(object sender, EventArgs e)
{
    app = System.Windows.Application.Current;
    myWindow = (Window)app.MainWindow;
    myWindow.SizeToContent = SizeToContent.WidthAndHeight;
    wfh.TabIndex = 10;
    initFontSize = wfh.FontSize;
    initFontWeight = wfh.FontWeight;
    initFontFamily = wfh.FontFamily;
    initFontStyle = wfh.FontStyle;
    initBackBrush = (SolidColorBrush)wfh.Background;
    initForeBrush = (SolidColorBrush)wfh.Foreground;
    (wfh.Child as MyControl1).OnButtonClick += new MyControl1.MyControlEventHandler(Pane1_OnButtonClick);
    UIIsReady = true;
}

Private app As Application
Private myWindow As Window
Private initFontWeight As FontWeight
Private initFontSize As [Double]
Private initFontStyle As FontStyle
Private initBackBrush As SolidColorBrush
Private initForeBrush As SolidColorBrush
Private initFontFamily As FontFamily
Private UIIsReady As Boolean = False


Private Sub Init(ByVal sender As Object, ByVal e As RoutedEventArgs)
    app = System.Windows.Application.Current
    myWindow = CType(app.MainWindow, Window)
    myWindow.SizeToContent = SizeToContent.WidthAndHeight
    wfh.TabIndex = 10
    initFontSize = wfh.FontSize
    initFontWeight = wfh.FontWeight
    initFontFamily = wfh.FontFamily
    initFontStyle = wfh.FontStyle
    initBackBrush = CType(wfh.Background, SolidColorBrush)
    initForeBrush = CType(wfh.Foreground, SolidColorBrush)

    Dim mc As MyControl1 = wfh.Child

    AddHandler mc.OnButtonClick, AddressOf Pane1_OnButtonClick
    UIIsReady = True

End Sub

Eftersom XAML som diskuterats tidigare lade till MyControl1 i WindowsFormsHost-elementets underordnade elementsamling, kan du omvandla WindowsFormsHost-elementets Child för att få referensen till MyControl1. Du kan sedan använda den referensen för att koppla en händelsehanterare till OnButtonClick.

Förutom att tillhandahålla en referens till själva WindowsFormsHost kontrollen exponeras ett antal av kontrollens egenskaper, som du kan ändra från programmet. Initieringskoden tilldelar dessa värden till privata globala variabler för senare användning i programmet.

Så att du enkelt kan komma åt typerna MyControls i DLL:en lägger du till följande Imports eller using -instruktionen överst i filen.

Imports MyControls

using MyControls;

Hantera OnButtonClick-händelsen

MyControl1 genererar händelsen OnButtonClick när användaren klickar på någon av kontrollens knappar.

Lägg till följande kod i MainWindow klassen.

//Handle button clicks on the Windows Form control
private void Pane1_OnButtonClick(object sender, MyControlEventArgs args)
{
    txtName.Inlines.Clear();
    txtAddress.Inlines.Clear();
    txtCity.Inlines.Clear();
    txtState.Inlines.Clear();
    txtZip.Inlines.Clear();

    if (args.IsOK)
    {
        txtName.Inlines.Add( " " + args.MyName );
        txtAddress.Inlines.Add( " " + args.MyStreetAddress );
        txtCity.Inlines.Add( " " + args.MyCity );
        txtState.Inlines.Add( " " + args.MyState );
        txtZip.Inlines.Add( " " + args.MyZip );
    }
}

'Handle button clicks on the Windows Form control
Private Sub Pane1_OnButtonClick(ByVal sender As Object, ByVal args As MyControlEventArgs)
    txtName.Inlines.Clear()
    txtAddress.Inlines.Clear()
    txtCity.Inlines.Clear()
    txtState.Inlines.Clear()
    txtZip.Inlines.Clear()

    If args.IsOK Then
        txtName.Inlines.Add(" " + args.MyName)
        txtAddress.Inlines.Add(" " + args.MyStreetAddress)
        txtCity.Inlines.Add(" " + args.MyCity)
        txtState.Inlines.Add(" " + args.MyState)
        txtZip.Inlines.Add(" " + args.MyZip)
    End If

End Sub

Data i textrutorna packas i MyControlEventArgs objektet. Om användaren klickar på ok-knappen extraherar händelsehanteraren data och visar dem i panelen nedan MyControl1.

Ändra kontrollens egenskaper

Elementet WindowsFormsHost exponerar flera av den värdbaserade kontrollens standardegenskaper. Därför kan du ändra utseendet på kontrollen så att den matchar programmets format närmare. Med uppsättningarna med alternativknappar i den vänstra panelen kan användaren ändra flera färg- och teckensnittsegenskaper. Varje uppsättning knappar har en hanterare för Click händelsen, som identifierar användarens alternativknappval och ändrar motsvarande egenskap på kontrollen.

Lägg till följande kod i MainWindow klassen.

private void BackColorChanged(object sender, RoutedEventArgs e)
{
    if (sender == rdbtnBackGreen)
        wfh.Background = new SolidColorBrush(Colors.LightGreen);
    else if (sender == rdbtnBackSalmon)
        wfh.Background = new SolidColorBrush(Colors.LightSalmon);
    else if (UIIsReady == true)
        wfh.Background = initBackBrush;
}

private void ForeColorChanged(object sender, RoutedEventArgs e)
{
    if (sender == rdbtnForeRed)
        wfh.Foreground = new SolidColorBrush(Colors.Red);
    else if (sender == rdbtnForeYellow)
        wfh.Foreground = new SolidColorBrush(Colors.Yellow);
    else if (UIIsReady == true)
        wfh.Foreground = initForeBrush;
}

private void FontChanged(object sender, RoutedEventArgs e)
{
    if (sender == rdbtnTimes)
        wfh.FontFamily = new FontFamily("Times New Roman");
    else if (sender == rdbtnWingdings)
        wfh.FontFamily = new FontFamily("Wingdings");
    else if (UIIsReady == true)
        wfh.FontFamily = initFontFamily;
}
private void FontSizeChanged(object sender, RoutedEventArgs e)
{
    if (sender == rdbtnTen)
        wfh.FontSize = 10;
    else if (sender == rdbtnTwelve)
        wfh.FontSize = 12;
    else if (UIIsReady == true)
        wfh.FontSize = initFontSize;
}
private void StyleChanged(object sender, RoutedEventArgs e)
{
    if (sender == rdbtnItalic)
        wfh.FontStyle = FontStyles.Italic;
    else if (UIIsReady == true)
        wfh.FontStyle = initFontStyle;
}
private void WeightChanged(object sender, RoutedEventArgs e)
{
    if (sender == rdbtnBold)
        wfh.FontWeight = FontWeights.Bold;
    else if (UIIsReady == true)
        wfh.FontWeight = initFontWeight;
}

Private Sub BackColorChanged(ByVal sender As Object, ByVal e As RoutedEventArgs)

    If sender.Equals(rdbtnBackGreen) Then
        wfh.Background = New SolidColorBrush(Colors.LightGreen)
    ElseIf sender.Equals(rdbtnBackSalmon) Then
        wfh.Background = New SolidColorBrush(Colors.LightSalmon)
    ElseIf UIIsReady = True Then
        wfh.Background = initBackBrush
    End If

End Sub

Private Sub ForeColorChanged(ByVal sender As Object, ByVal e As RoutedEventArgs)
    If sender.Equals(rdbtnForeRed) Then
        wfh.Foreground = New SolidColorBrush(Colors.Red)
    ElseIf sender.Equals(rdbtnForeYellow) Then
        wfh.Foreground = New SolidColorBrush(Colors.Yellow)
    ElseIf UIIsReady = True Then
        wfh.Foreground = initForeBrush
    End If

End Sub

Private Sub FontChanged(ByVal sender As Object, ByVal e As RoutedEventArgs)
    If sender.Equals(rdbtnTimes) Then
        wfh.FontFamily = New FontFamily("Times New Roman")
    ElseIf sender.Equals(rdbtnWingdings) Then
        wfh.FontFamily = New FontFamily("Wingdings")
    ElseIf UIIsReady = True Then
        wfh.FontFamily = initFontFamily
    End If

End Sub

Private Sub FontSizeChanged(ByVal sender As Object, ByVal e As RoutedEventArgs)
    If sender.Equals(rdbtnTen) Then
        wfh.FontSize = 10
    ElseIf sender.Equals(rdbtnTwelve) Then
        wfh.FontSize = 12
    ElseIf UIIsReady = True Then
        wfh.FontSize = initFontSize
    End If

End Sub

Private Sub StyleChanged(ByVal sender As Object, ByVal e As RoutedEventArgs)
    If sender.Equals(rdbtnItalic) Then
        wfh.FontStyle = FontStyles.Italic
    ElseIf UIIsReady = True Then
        wfh.FontStyle = initFontStyle
    End If

End Sub

Private Sub WeightChanged(ByVal sender As Object, ByVal e As RoutedEventArgs)
    If sender.Equals(rdbtnBold) Then
        wfh.FontWeight = FontWeights.Bold
    ElseIf UIIsReady = True Then
        wfh.FontWeight = initFontWeight
    End If

End Sub

Skapa och kör programmet. Lägg till text i den sammansatta kontrollen Windows Forms och klicka sedan på OK. Texten visas i etiketterna. Klicka på de olika alternativknapparna för att se effekten på kontrollen.

Se även

• ElementHost
• WindowsFormsHost
• Designa XAML i Visual Studio
• Walkthrough: Inbäddning av en Windows Forms-kontroll i WPF
• Handledning: Inbäddning av en WPF-kompositkontroll i Windows Forms