Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Windows Presentation Foundation (WPF) bietet eine umfangreiche Umgebung zum Erstellen von Anwendungen. Wenn Sie jedoch eine erhebliche Investition in Windows Forms-Code haben, kann es effektiver sein, mindestens einen Teil dieses Codes in Ihrer WPF-Anwendung wiederzuverwenden, anstatt ihn von Grund auf neu zu schreiben. Das häufigste Szenario ist, wenn Sie über vorhandene Windows Forms-Steuerelemente verfügen. In einigen Fällen haben Sie möglicherweise keinen Zugriff auf den Quellcode für diese Steuerelemente. WPF bietet ein einfaches Verfahren zum Hosten solcher Steuerelemente in einer WPF-Anwendung. Sie können WPF beispielsweise für den größten Teil Ihrer Programmierung verwenden, während Ihre spezialisierten DataGridView-Steuerelemente gehostet werden.
Diese exemplarische Vorgehensweise führt Sie durch eine Anwendung, die ein zusammengesetztes Windows Forms-Steuerelement zur Dateneingabe in einer WPF-Anwendung hostet. Das zusammengesetzte Steuerelement ist in eine DLL verpackt. Dieses allgemeine Verfahren kann auf komplexere Anwendungen und Steuerelemente erweitert werden. Diese exemplarische Vorgehensweise wurde so gestaltet, dass sie in Darstellung und Funktionalität nahezu identisch mit Exemplarische Vorgehensweise: Hosten eines zusammengesetzten WPF-Steuerelements in Windows Forms ist. Der Hauptunterschied besteht darin, dass das Hostingszenario umgekehrt wird.
Diese exemplarische Vorgehensweise ist in zwei Abschnitte unterteilt. Im ersten Abschnitt wird die Implementierung des zusammengesetzten Windows Forms-Steuerelements kurz beschrieben. Im zweiten Abschnitt wird ausführlich erläutert, wie das zusammengesetzte Steuerelement in einer WPF-Anwendung gehostet wird, wie Ereignisse vom Steuerelement empfangen werden und wie auf einige Eigenschaften des Steuerelements zugegriffen werden kann.
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 in dieser exemplarischen Vorgehensweise finden Sie unter Beispiel zum Hosten eines zusammengesetzten Windows Forms-Steuerelements in WPF.
Voraussetzungen
Sie benötigen Visual Studio, um diese Anleitung abzuschließen.
Implementieren des zusammengesetzten Windows Forms-Steuerelements
Das in diesem Beispiel verwendete zusammengesetzte Windows Forms-Steuerelement ist ein einfaches Dateneingabeformular. Dieses Formular verwendet den Namen und die Adresse des Benutzers und verwendet dann ein benutzerdefiniertes Ereignis, um diese Informationen an den Host zurückzugeben. Die folgende Abbildung zeigt das gerenderte Steuerelement.
Die folgende Abbildung zeigt ein zusammengesetztes Windows Forms-Steuerelement:
Projekt erstellen
So starten Sie das Projekt:
Starten Sie Visual Studio, und öffnen Sie das Dialogfeld Neues Projekt.
Wählen Sie in der Kategorie „Windows” die Vorlage Windows Forms-Steuerelementbibliothek aus.
Benennen Sie das neue Projekt
MyControls.Geben Sie für den Speicherort einen bequem benannten Ordner auf oberster Ebene an, z. B.
WpfHostingWindowsFormsControl. Später platzieren Sie die Hostanwendung in diesem Ordner.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
UserControl1inMyControl1um.
Ihr Projekt sollte Verweise auf die folgenden System-DLLs haben. Wenn eine dieser DLLs standardmäßig nicht enthalten ist, 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
MyControl1im Designer.
Fügen Sie auf dem Formular fünf Label-Steuerelemente und deren entsprechende TextBox-Steuerelemente hinzu, und zwar mit der gleichen Größe und Anordnung wie in der vorstehenden Abbildung. Im Beispiel sind die TextBox-Steuerelemente benannt:
txtNametxtAddresstxtCitytxtStatetxtZip
Fügen Sie zwei Button-Steuerelemente mit der Bezeichnung OK und Abbrechen hinzu. Im Beispiel lauten die Namen der Schaltflächen btnOK und btnCancel.
Implementieren des unterstützenden Codes
Öffnen Sie das Formular in der Codeansicht. Das Steuerelement gibt die gesammelten Daten durch Auslösen des benutzerdefinierten OnButtonClick-Ereignisses an seinen Host weiter. Die Daten sind im Ereignisargumentobjekt enthalten. Der folgende Code zeigt die Deklaration von Ereignis und Delegat.
Fügen Sie der klasse MyControl1 den folgenden Code hinzu.
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
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 : 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
Wenn der Benutzer auf die Schaltfläche OK oder die Schaltfläche Abbrechen klickt, erstellen die Click Ereignishandler ein MyControlEventArgs Objekt, das die Daten enthält und das OnButtonClick Ereignis auslöst. Der einzige Unterschied zwischen den beiden Handlern ist die Eigenschaft IsOK des Ereignisarguments. Mit dieser Eigenschaft kann der Host bestimmen, auf welche Schaltfläche geklickt wurde. Ihr Wert wird bei der Schaltfläche true auf und bei der Schaltfläche false auf festgelegt. Der folgende Code zeigt die beiden Schaltflächenhandler.
Fügen Sie der klasse MyControl1 den folgenden Code hinzu.
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
Vergeben eines starken Namens für die Assembly und Erstellen der Assembly
Damit auf diese Assembly von einer WPF-Anwendung verwiesen wird, muss sie einen starken Namen haben. Um einen starken Namen zu erstellen, erstellen Sie eine Schlüsseldatei mit Sn.exe, und fügen Sie sie Ihrem 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-Eingabeaufforderungaus. Dadurch wird ein Konsolenfenster mit angepassten Umgebungsvariablen gestartet.
Verwenden Sie an der Eingabeaufforderung den Befehl
cd, um zum Projektordner zu wechseln.Generieren Sie eine Schlüsseldatei namens "MyControls.snk", indem Sie den folgenden Befehl ausführen.
Sn.exe -k MyControls.snkUm diese Schlüsseldatei in Ihr Projekt einzubeziehen, klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen. Klicken Sie dann auf Eigenschaften. Klicken Sie im Projekt-Designer auf die Registerkarte Signierung, aktivieren Sie das Kontrollkästchen Assembly signieren, und navigieren Sie zu Ihrer Schlüsseldatei.
Erstellen Sie die Lösung. Der Build erzeugt eine DLL mit dem Namen MyControls.dll.
Implementieren der WPF-Hostanwendung
Die WPF-Hostanwendung verwendet das Steuerelement WindowsFormsHost zum Hosten von MyControl1. Die Anwendung verarbeitet das OnButtonClick-Ereignis, um die Daten aus dem Steuerelement zu empfangen. Außerdem verfügt es über eine Sammlung von Optionsschaltflächen, mit denen Sie einige eigenschaften des Steuerelements aus der WPF-Anwendung ändern können. Die folgende Abbildung zeigt die fertige Anwendung.
Die folgende Abbildung zeigt die vollständige Anwendung, einschließlich des in der WPF-Anwendung eingebetteten Steuerelements:
Projekt erstellen
So starten Sie das Projekt:
Öffnen Sie Visual Studio, und wählen Sie Neues Projektaus.
Wählen Sie in der Kategorie „Windows” die Vorlage WPF-Anwendung aus.
Benennen Sie das neue Projekt
WpfHost.Geben Sie für den Speicherort denselben Ordner auf oberster Ebene an, der das MyControls-Projekt enthält.
Klicken Sie auf OK, um das Projekt zu erstellen.
Sie müssen auch Verweise auf die DLL, die MyControl1 enthält, und auf andere Assemblys hinzufügen.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen, und wählen Sie Verweis hinzufügen aus.
Klicken Sie auf die Registerkarte Durchsuchen, und navigieren Sie zu dem Ordner mit „MyControls.dll“. In dieser exemplarischen Vorgehensweise ist dies der Ordner „MyControls\bin\Debug“.
Wählen Sie MyControls.dllaus, und klicken Sie dann auf OK.
Fügen Sie einen Verweis auf die WindowsFormsIntegration-Assembly hinzu, die den Namen WindowsFormsIntegration.dllträgt.
Implementieren des grundlegenden Layouts
Die Benutzeroberfläche der Hostanwendung wird in "MainWindow.xaml" implementiert. Diese Datei enthält XAML-Markup (Extensible Application Markup Language), das das Layout definiert und das Windows Forms-Steuerelement hostet. Die Anwendung ist in drei Regionen unterteilt:
Den Bereich Steuerelementeigenschaften, der eine Auflistung von Optionsschaltflächen enthält, mit denen Sie verschiedene Eigenschaften des gehosteten Steuerelements ändern können.
Den Bereich Daten aus Steuerelement, der mehrere TextBlock-Elemente enthält, die die vom gehosteten Steuerelement zurückgegebenen Daten anzeigen.
Das gehostete Steuerelement selbst.
Das grundlegende Layout wird im folgenden XAML-Code angezeigt. Das zum Hosten von MyControl1 benötigte Markup wurde in diesem Beispiel weggelassen, wird aber später erläutert.
Ersetzen Sie den XAML-Code in der Datei MainWindow.xaml durch den folgenden Code. Wenn Sie Visual Basic verwenden, ändern Sie die Klasse in 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>
Das erste StackPanel-Element enthält mehrere Gruppen von RadioButton-Steuerelementen, mit denen Sie verschiedene Standardeigenschaften des gehosteten Steuerelements ändern können. Darauf folgt ein WindowsFormsHost-Element, das MyControl1 hostet. Das letzte StackPanel-Element enthält mehrere TextBlock Elemente, die die vom gehosteten Steuerelement zurückgegebenen Daten anzeigen. Die Reihenfolge der Elemente sowie die Einstellungen der Attribute Dock und Height betten das gehostete Steuerelement ohne Lücken oder Verzerrung in das Fenster ein.
Hosten des Steuerelements
Die folgende bearbeitete Version des vorigen XAML-Codes konzentriert sich auf die Elemente, die zum Hosten von MyControl1 benötigt werden.
<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>
Das xmlns-Namespacezuordnungsattribut erstellt einen Verweis auf den MyControls-Namespace, der das gehostete Steuerelement enthält. Mit dieser Zuordnung können Sie MyControl1 in XAML als <mcl:MyControl1>darstellen.
Zwei Elemente im XAML-Code behandeln das Hosting:
WindowsFormsHoststellt das WindowsFormsHost-Element dar, mit dem Sie ein Windows Forms-Steuerelement in einer WPF-Anwendung hosten können.mcl:MyControl1, dasMyControl1darstellt, wird der untergeordneten Auflistung des Elements WindowsFormsHost hinzugefügt. Daher wird dieses Windows Forms-Steuerelement als Teil des WPF-Fensters gerendert, und Sie können mit dem Steuerelement aus der Anwendung kommunizieren.
Implementieren der CodeBehind-Datei
Die Code-Behind-Datei, MainWindow.xaml.vb oder MainWindow.xaml.cs, enthält den prozeduralen Code, der die Funktionalität der Benutzeroberfläche implementiert, die im vorherigen Abschnitt besprochen wurde. Die wichtigsten Aufgaben sind:
Einen Ereignishandler an das
MyControl1-Ereignis vonOnButtonClickbinden.Verschiedene Eigenschaften von
MyControl1basierend auf den Werten aller Optionsfelder anzupassen.Anzeigen der vom Steuerelement erfassten Daten.
Initialisieren der Anwendung
Der Initialisierungscode 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 oder MainWindow.xaml.cs den folgenden Code in die Klasse MainWindow hinzu.
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
Weil der weiter oben erläuterte XAML-Code das Steuerelement MyControl1 zur Auflistung von untergeordneten Elementen des Elements WindowsFormsHost hinzugefügt hat, können Sie den Wert WindowsFormsHost des Elements Child umwandeln, um den Verweis auf MyControl1 zu erhalten. Diesen Verweis können Sie dann verwenden, um einen Ereignishandler an OnButtonClick anzufügen.
Neben der Angabe eines Verweises auf das Steuerelement selbst macht WindowsFormsHost eine Reihe der Eigenschaften des Steuerelements verfügbar, die Sie aus der Anwendung bearbeiten können. Der Initialisierungscode weist diese Werte privaten globalen Variablen für die spätere Verwendung in der Anwendung zu.
Damit Sie ganz einfach auf die Typen in der MyControls DLL zugreifen können, fügen Sie die folgende Imports- oder using-Anweisung am Anfang der Datei 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 klasse MainWindow den folgenden Code hinzu.
//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
Die Daten in den Textfeldern werden in das MyControlEventArgs-Objekt verpackt. Wenn der Benutzer auf die Schaltfläche OK klickt, extrahiert der Ereignishandler die Daten und zeigt sie im Bereich unten MyControl1an.
Ändern der Eigenschaften des Steuerelements
Das WindowsFormsHost-Element macht mehrere standardeigenschaften des gehosteten Steuerelements verfügbar. Daher können Sie das Erscheinungsbild des Steuerelements so ändern, dass es dem Stil Ihrer Anwendung näher entspricht. Mit den Optionsfeldern im linken Bereich kann der Benutzer mehrere Farb- und Schriftarteigenschaften ändern. Jeder Satz von Schaltflächen verfügt über einen Handler für das Click-Ereignis, das die Auswahl der Optionsschaltflächen des Benutzers erkennt und die entsprechende Eigenschaft des Steuerelements ändert.
Fügen Sie der klasse MainWindow den folgenden Code hinzu.
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
Erstellen Sie die Anwendung, und führen Sie sie aus. Fügen Sie dem zusammengesetzten Windows Forms-Steuerelement etwas Text hinzu, und klicken Sie auf OK. Der Text wird in den Beschriftungen angezeigt. Klicken Sie auf die verschiedenen Optionsfelder, um die Auswirkung auf das Steuerelement zu sehen.
Siehe auch
Zusammenarbeit auf GitHub
Die Quelle für diesen Inhalt finden Sie auf GitHub, wo Sie auch Issues und Pull Requests erstellen und überprüfen können. Weitere Informationen finden Sie in unserem Leitfaden für Mitwirkende.
.NET Desktop feedback