Exemplarische Vorgehensweise: Hosten eines zusammengesetzten Windows Forms-Steuerelements in WPF
Aktualisiert: August 2010
Windows Presentation Foundation (WPF) stellt eine umfangreiche Umgebung zum Erstellen von Anwendungen bereit. Wenn Sie allerdings bereits erheblichen Aufwand für Windows Forms-Code betrieben haben, kann es effektiver sein, zumindest einen Teil dieses Codes in Ihrer WPF-Anwendung wieder zu verwenden, anstatt ihn von Grund auf neu zu schreiben. Das häufigste Szenario ist, dass Sie über vorhandene Windows Forms-Steuerelemente verfügen. In einigen Fällen haben Sie möglicherweise noch nicht einmal Zugriff auf den Quellcode für diese Steuerelemente. WPF stellt ein einfaches Verfahren bereit, um diese Steuerelemente in einer WPF-Anwendung zu hosten. Zum Beispiel können Sie WPF für den Großteil der Programmierung verwenden, während sie die spezialisierten DataGridView-Steuerelemente hosten.
In dieser exemplarischen Vorgehensweise wird eine Anwendung vorgestellt, die ein zusammengesetztes Windows Forms-Steuerelement hostet, um die Dateneingabe in einer WPF-Anwendung auszuführen. Das zusammengesetzte Steuerelement ist in einer DLL gepackt. Diese allgemeine Prozedur kann auf komplexere Anwendungen und Steuerelemente erweitert werden. Diese exemplarische Vorgehensweise ist hinsichtlich Darstellung und Funktionalität nahezu identisch mit Exemplarische Vorgehensweise: Hosten eines zusammengesetzten WPF-Steuerelements in Windows Forms. Der Hauptunterschied liegt in einer Umkehrung des Hostingszenarios.
Die exemplarische Vorgehensweise ist in zwei Abschnitte unterteilt. Im ersten Abschnitt wird kurz die Implementierung des zusammengesetzten Windows Forms-Steuerelements beschrieben. Im zweiten Abschnitt wird detailliert erläutert, wie das zusammengesetzte Steuerelement in einer WPF-Anwendung gehostet wird, Ereignisse vom Steuerelement empfangen werden und auf einige Eigenschaften des Steuerelements zugegriffen wird.
In dieser exemplarischen Vorgehensweise werden u. a. folgende Aufgaben veranschaulicht:
Implementieren des zusammengesetzten Windows Forms-Steuerelements
Implementieren der WPF-Hostanwendung
Eine vollständige Codeauflistung der Aufgaben, die in dieser exemplarischen Vorgehensweise veranschaulicht wurden, finden Sie unter Beispiel für das Hosten eines zusammengesetzten Windows Forms-Steuerelements in Windows Presentation Foundation.
Voraussetzungen
Zum Durchführen dieser exemplarischen Vorgehensweise benötigen Sie die folgenden Komponenten:
- Visual Studio 2010.
Implementieren des zusammengesetzten Windows Forms-Steuerelements
Das in diesem Beispiel verwendete zusammengesetzte Windows Forms-Steuerelement ist ein einfaches Dateneingabeformular. Dieses Formular nimmt den Namen und die Adresse des Benutzers auf und verwendet dann ein benutzerdefiniertes Ereignis, um diese Informationen an den Host zurückzugeben. Die folgende Abbildung zeigt das gerenderte Steuerelement.
Zusammengesetztes Windows Forms-Steuerelement
.gif "Einfaches Windows Forms-Steuerelement")
Erstellen des Projekts
So starten Sie das Projekt
Starten Sie Microsoft Visual Studio, und öffnen Sie das Dialogfeld Neues Projekt.
Wählen Sie in der Kategorie "Fenster" die Vorlage Windows Forms-Steuerelementbibliothek aus.
Geben Sie für das neue Projekt den Namen MyControls ein.
Geben Sie für den Speicherort einen passend benannten Ordner der obersten Ebene an, z. B. WpfHostingWindowsFormsControl. Später legen Sie die Hostanwendung in diesem Ordner ab.
Klicken Sie auf OK, um das Projekt zu erstellen. Das Standardprojekt enthält ein einzelnes Steuerelement mit dem Namen UserControl1.
Benennen Sie im Projektmappen-Explorer UserControl1 in MyControl1 um.
Das Projekt sollte Verweise auf die folgenden System-DLLs aufweisen. Wenn diese DLLs nicht standardmäßig eingeschlossen sind, fügen Sie sie dem Projekt hinzu.
System
System.Data
System.Drawing
System.Windows.Forms
System.Xml
Hinzufügen von Steuerelementen zum Formular
So fügen Sie dem Formular Steuerelemente hinzu
- Öffnen Sie MyControl1 im Designer.
Fügen Sie fünf Label-Steuerelemente und die entsprechenden TextBox-Steuerelemente im Formular hinzu, und passen Sie ihre Größe und Anordnung wie in der vorhergehenden Abbildung an. Im Beispiel werden die TextBox-Steuerelemente folgendermaßen benannt:
txtName
txtAddress
txtCity
txtState
txtZip
Fügen Sie zwei Button-Steuerelemente mit den Bezeichnungen OK und Cancel hinzu. Im Beispiel lauten die Schaltflächennamen btnOK bzw. btnCancel.
Implementieren des unterstützenden Codes
Öffnen Sie das Formular in der Codeansicht. Das Steuerelement gibt die gesammelten Daten an seinen Host zurück, indem es das benutzerdefinierte OnButtonClick-Ereignis auslöst. Die Daten sind im Ereignisargumentobjekt enthalten. Der folgende Code zeigt die Ereignis- und Delegatdeklaration.
Fügen Sie der MyControl1-Klasse den folgenden Code hinzu.
Public Delegate Sub MyControlEventHandler(ByVal sender As Object, ByVal args As MyControlEventArgs)
Public Event OnButtonClick As MyControlEventHandler
public delegate void MyControlEventHandler(object sender, MyControlEventArgs args);
public event MyControlEventHandler OnButtonClick;
Die MyControlEventArgs-Klasse enthält die Informationen, die an den Host zurückgegeben werden sollen.
Fügen Sie dem Formular die folgende Klasse hinzu.
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
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; }
}
}
Wenn der Benutzer auf die Schaltfläche OK oder Cancel klickt, erstellen die Click-Ereignishandler ein MyControlEventArgs-Objekt, das die Daten enthält und das OnButtonClick-Ereignis auslöst. Der einzige Unterschied zwischen den zwei Handlern ist die IsOK-Eigenschaft des Ereignisarguments. Diese Eigenschaft ermöglicht es dem Host, zu bestimmen, auf welche Schaltfläche geklickt wurde. Sie ist für die Schaltfläche OK auf true und für die Schaltfläche Cancel auf false festgelegt. Der folgende Code zeigt die beiden Schaltflächenhandler.
Fügen Sie der MyControl1-Klasse den folgenden Code hinzu.
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
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);
}
Vergeben eines starken Namens für die Assembly und Erstellen der Assembly
Damit von einer WPF-Anwendung auf diese Assembly verwiesen wird, muss sie einen starken Namen haben. Um einen starken Namen zu erstellen, erstellen Sie mit "Sn.exe" eine Schlüsseldatei, und fügen Sie sie dem Projekt hinzu.
Öffnen Sie eine Visual Studio-Eingabeaufforderung. Klicken Sie dazu auf das Menü Start, und wählen Sie dann Alle Programme/Microsoft Visual Studio 2010/Visual Studio Tools/Visual Studio-Eingabeaufforderung aus. Dies startet ein Konsolenfenster mit benutzerdefinierten Umgebungsvariablen.
Verwenden Sie an der Eingabeaufforderung den cd-Befehl, um zum Projektordner zu wechseln.
Generieren Sie eine Schlüsseldatei mit dem Namen MyControls.snk, indem Sie den folgenden Befehl ausführen.
Sn.exe -k MyControls.snkUm die Schlüsseldatei dem Projekt hinzuzufügen, klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen, und klicken Sie dann auf Eigenschaften. Klicken Sie im Projekt-Designer auf die Registerkarte Signierung, aktivieren Sie das Kontrollkästchen Assembly signieren, und navigieren Sie dann zur Schlüsseldatei.
Erstellen Sie die Projektmappe. Der Build erzeugt eine DLL mit dem Namen MyControls.dll.
Implementieren der WPF-Hostanwendung
Die WPF-Hostanwendung verwendet das WindowsFormsHost-Steuerelement, um MyControl1 zu hosten. Die Anwendung behandelt das OnButtonClick-Ereignis, um die Daten vom Steuerelement zu empfangen. Sie enthält außerdem eine Auflistung von Optionsschaltflächen, mit denen Sie einige der Eigenschaften des Steuerelements in der WPF-Anwendung ändern können. Die folgende Abbildung zeigt die fertige Anwendung.
Vollständige Anwendung mit in der WPF-Anwendung eingebettetem Steuerelement
.gif "Ein in einer WPF-Seite eingebettetes Steuerelement")
Erstellen des Projekts
So starten Sie das Projekt
Öffnen Sie Visual Studio, und wählen Sie Neues Projekt aus.
Wählen Sie in der Kategorie "Fenster" die Vorlage WPF-Anwendung aus.
Geben Sie für das neue Projekt den Namen WpfHost ein.
Geben Sie für den Speicherort den Ordner der obersten Ebene an, der auch das Projekt "MyControls" enthält.
Klicken Sie auf OK, um das Projekt zu erstellen.
Außerdem müssen Sie Verweise auf die DLL hinzufügen, die MyControl1 und andere Assemblys enthält.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen, und klicken Sie dann auf Verweis hinzufügen.
Klicken Sie auf die Registerkarte Durchsuchen, und navigieren Sie zu dem Ordner, der "MyControls.dll" enthält. In dieser exemplarischen Vorgehensweise ist dies der Ordner "MyControls\bin\Debug".
Wählen Sie "MyControls.dll" aus, und klicken Sie dann auf OK.
Fügen Sie einen Verweis auf die WindowsFormsIntegration-Assembly, die WindowsFormsIntegration.dll genannt wird, hinzu.
Implementieren des grundlegenden Layouts
Die user interface (UI) der Hostanwendung wird in "MainWindow.xaml" implementiert. Diese Datei enthält Extensible Application Markup Language (XAML)-Markup, das das Layout definiert, und hostet das Windows Forms-Steuerelement. Die Anwendung ist in drei Bereiche unterteilt:
Bereich Steuerelementeigenschaften, der eine Auflistung von Optionsschaltflächen enthält, mit denen Sie verschiedene Eigenschaften des gehosteten Steuerelements ändern können.
Bereich Steuerelementdaten, der verschiedene TextBlock-Elemente enthält, die die vom gehosteten Steuerelement zurückgegebenen Daten anzeigen.
Das gehostete Steuerelement selbst.
Der folgende XAML-Code zeigt das grundlegende Layout. Das zum Hosten von MyControl1 erforderliche Markup ist in diesem Beispiel nicht enthalten, wird aber später erläutert.
Ersetzen Sie den XAML-Code in "MainWindow.xaml" durch den folgenden Code: Wenn Sie Visual Basic verwenden, ändern Sie die Klasse in x:Class="MainWindow".
<Window xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="https://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>
Das erste StackPanel-Element enthält verschieden Gruppen von RadioButton-Steuerelementen, mit denen Sie verschiedene Standardeigenschaften des gehosteten Steuerelements ändern können. Dem folgt ein WindowsFormsHost-Element, das MyControl1 hostet. Das letzte StackPanel-Element enthält verschiedene TextBlock-Elemente, die die vom gehosteten Steuerelement zurückgegebenen Daten anzeigen. Durch die Reihenfolge der Elemente und die Attributeinstellungen Dock und Height wird das gehostete Steuerelement ohne Lücken oder Verzerrungen in das Fenster eingebettet.
Hosten des Steuerelements
Der Schwerpunkt der folgenden bearbeiteten Version des vorherigen XAML-Codes liegt auf den Elementen, die zum Hosten von MyControl1 benötigt werden.
<Window xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="https://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>
Das xmlns-Namespace-Zuordnungsattribut erstellt einen Verweis auf den MyControls-Namespace, der das gehostete Steuerelement enthält. Diese Zuordnung ermöglicht es Ihnen, MyControl1 als <mcl:MyControl1> in XAML darzustellen.
Zwei Elemente im XAML-Code behandeln das Hosting:
WindowsFormsHost stellt das WindowsFormsHost-Element dar, das das Hosten eines Windows Forms-Steuerelements in einer WPF-Anwendung ermöglicht.
mcl:MyControl1, das MyControl1 darstellt, wird der untergeordneten Auflistung des WindowsFormsHost-Elements hinzugefügt. Dadurch wird dieses Windows Forms-Steuerelement als Teil des WPF-Fensters gerendert, und Sie können über die Anwendung Daten mit dem Steuerelement austauschen.
Implementieren der Code-Behind-Datei
Die CodeBehind-Datei ("MainWindow.xaml.vb" oder "MainWindow.xaml.cs") enthält den prozeduralen Code, der die im vorherigen Abschnitt erläuterten Funktionen der UI implementiert. Die Hauptaufgaben sind:
Anfügen eines Ereignishandlers an das OnButtonClick-Ereignis von MyControl1.
Ändern verschiedener Eigenschaften von MyControl1 auf Grundlage der Auflistung von Optionsschaltflächen.
Anzeigen der vom Steuerelement gesammelten Daten.
Initialisieren der Anwendung
Der Code für die Initialisierung ist in einem Ereignishandler für das Loaded-Ereignis des Fensters enthalten und fügt einen Ereignishandler an das OnButtonClick-Ereignis des Steuerelements an.
Fügen Sie in "MainWindow.xaml.vb" bzw. "MainWindow.xaml.cs" der MainWindow-Klasse den folgenden Code hinzu.
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
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;
}
Da MyControl1 im zuvor erläuterten XAML-Code zur Auflistung untergeordneter Elemente des WindowsFormsHost-Elements hinzugefügt wurde, können Sie das Child des WindowsFormsHost-Elements umwandeln, um den Verweis auf MyControl1 abzurufen. Sie können dann diesen Verweis verwenden, um einen Ereignishandler an OnButtonClick anzufügen.
WindowsFormsHost stellt nicht nur einen Verweis auf das Steuerelement selbst bereit, sondern macht eine Reihe von Eigenschaften des Steuerelements verfügbar, die Sie in der Anwendung ändern können. Im Initialisierungscode werden diese Werte privaten globalen Variablen zur späteren Verwendung in der Anwendung zugewiesen.
Damit Sie mühelos auf die Typen in der MyControls-DLL zugreifen können, fügen Sie am Anfang der Datei die folgende Imports- oder using-Anweisung hinzu.
Imports MyControls
using MyControls;
Behandeln des OnButtonClick-Ereignisses
MyControl1 löst das OnButtonClick-Ereignis aus, wenn der Benutzer auf eine der Schaltflächen des Steuerelements klickt.
Fügen Sie der MainWindow-Klasse den folgenden Code hinzu.
'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
//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 );
}
}
Die Daten in den Textfeldern werden in das MyControlEventArgs-Objekt gepackt. Wenn der Benutzer auf die Schaltfläche OK klickt, extrahiert der Ereignishandler die Daten und zeigt sie im Bereich unter MyControl1 an.
Ändern der Eigenschaften des Steuerelements
Das WindowsFormsHost-Element macht mehrere Standardeigenschaften des gehosteten Steuerelements verfügbar. Daher können Sie die Darstellung des Steuerelements entsprechend dem Stil Ihrer Anwendung ändern. Die Gruppen von Optionsschaltflächen im linken Bereich ermöglichen die Änderung mehrerer Farb- und Schrifteigenschaften. Jede Schaltflächengruppe besitzt einen Handler für das Click-Ereignis, der die vom Benutzer ausgewählten Optionsschaltflächen ermittelt und die entsprechende Eigenschaft für das Steuerelement ändert.
Fügen Sie der MainWindow-Klasse den folgenden Code hinzu.
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
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;
}
Erstellen Sie die Anwendung, und führen Sie sie aus. Fügen Sie im zusammengesetzten Windows Forms-Steuerelement Text hinzu, und klicken Sie dann auf OK. Der Text wird in den Beschriftungen angezeigt. Klicken Sie auf die verschiedenen Optionsfelder, um die Auswirkung auf das Steuerelement zu überprüfen.
Siehe auch
Aufgaben
Exemplarische Vorgehensweise: Hosten eines Windows Forms-Steuerelements in WPF
Referenz
Konzepte
Exemplarische Vorgehensweise: Hosten eines zusammengesetzten WPF-Steuerelements in Windows Forms
Weitere Ressourcen
Änderungsprotokoll
Datum |
Versionsgeschichte |
Grund |
|---|---|---|
August 2010 |
Aktualisiert für Visual Studio 2010. |
Kundenfeedback. |