Compartir a través de

Tutorial: Hospedaje de un control compuesto de Formularios Windows Forms en WPF

  • Artículo

Windows Presentation Foundation (WPF) proporciona un entorno enriquecido para crear aplicaciones. Sin embargo, cuando tiene una inversión sustancial en el código de Windows Forms, puede ser más eficaz reutilizar al menos parte de ese código en la aplicación WPF en lugar de volver a escribirlo desde cero. El escenario más común es cuando tiene controles de Windows Forms existentes. En algunos casos, es posible que ni siquiera tenga acceso al código fuente de estos controles. WPF proporciona un procedimiento sencillo para hospedar estos controles en una aplicación WPF. Por ejemplo, puede usar WPF para la mayoría de su programación mientras aloja los controles especializados DataGridView.

Este tutorial le guiará a través de una aplicación que hospeda un control compuesto de Windows Forms para realizar la entrada de datos en una aplicación WPF. El control compuesto se empaqueta en un archivo DLL. Este procedimiento general se puede extender a aplicaciones y controles más complejos. Este tutorial está diseñado para ser casi idéntico en apariencia y funcionalidad para Walkthrough: Hospedaje de un control compuesto de WPF en Windows Forms. La principal diferencia es que se invierte el escenario de hospedaje.

El tutorial se divide en dos secciones. En la primera sección se describe brevemente la implementación del control compuesto de Windows Forms. En la segunda sección se describe detalladamente cómo hospedar el control compuesto en una aplicación WPF, recibir eventos del control y acceder a algunas de las propiedades del control.

Las tareas que se muestran en este tutorial incluyen:

  • Implementación del control compuesto de Windows Forms.

  • Implementación de la aplicación host de WPF.

Para obtener una lista de código completa de las tareas que se muestran en este tutorial, vea Hospedaje de un control compuesto de Formularios Windows Forms en el ejemplo de WPF.

Prerrequisitos

Necesita Visual Studio para completar este tutorial.

Implementación del control compuesto de Windows Forms

El control compuesto de Windows Forms usado en este ejemplo es un formulario simple de entrada de datos. Este formulario toma el nombre y la dirección del usuario y, a continuación, usa un evento personalizado para devolver esa información al host. En la ilustración siguiente se muestra el control representado.

En la imagen siguiente se muestra un control compuesto de Windows Forms:

Captura de pantalla que muestra un control simple de Windows Forms.

Creación del proyecto

Para iniciar el proyecto:

  1. Inicie Visual Studio y abra el cuadro de diálogo Nuevo proyecto .

  2. En la categoría Ventana, seleccione la plantilla Biblioteca de controles de Windows Forms .

  3. Asigne al nuevo proyecto MyControlsel nombre .

  4. Para la ubicación, especifique una carpeta de nivel superior denominada convenientemente, como WpfHostingWindowsFormsControl. Más adelante, colocará la aplicación host en esta carpeta.

  5. Haga clic en Aceptar para crear el proyecto. El proyecto predeterminado contiene un único control denominado UserControl1.

  6. En el Explorador de soluciones, cambie el nombre UserControl1 a MyControl1.

El proyecto debe tener referencias a los siguientes archivos DLL del sistema. Si alguno de estos archivos DLL no se incluye de forma predeterminada, agréguelos al proyecto.

  • Sistema

  • System.Data

  • System.Drawing

  • System.Windows.Forms

  • System.Xml

Agregar controles al formulario

Para agregar controles al formulario:

  • Abra MyControl1 en el diseñador.

Agregue cinco controles Label con sus controles correspondientes TextBox, con el mismo tamaño y disposición que en la ilustración anterior, en el formulario. En el ejemplo, los TextBox controles se denominan:

  • txtName

  • txtAddress

  • txtCity

  • txtState

  • txtZip

Agregue dos Button controles etiquetados como Aceptar y Cancelar. En el ejemplo, los nombres de botón son btnOK y btnCancel, respectivamente.

Implementación del código auxiliar

Abra el formulario en la vista de código. El control devuelve los datos recopilados a su host generando el evento personalizado OnButtonClick . Los datos se encuentran en el objeto de argumento de evento. El código siguiente muestra la declaración de evento y delegado.

Agregue el siguiente código a la clase MyControl1 .

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

La MyControlEventArgs clase contiene la información que se va a devolver al host.

Agregue la siguiente clase al formulario.

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

Cuando el usuario hace clic en el botón Aceptar o Cancelar , los Click controladores de eventos crean un MyControlEventArgs objeto que contiene los datos y generan el OnButtonClick evento. La única diferencia entre los dos controladores es la propiedad de IsOK del argumento del evento. Esta propiedad permite al host determinar en qué botón se hizo clic. Se establece en true para el botón Aceptar y false para el botón Cancelar . En el código siguiente se muestran los dos controladores de botón.

Agregue el siguiente código a la clase MyControl1 .

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

Asignar un nombre seguro al ensamblado y crear el ensamblado

Para que una aplicación WPF haga referencia a este ensamblado, debe tener un nombre seguro. Para crear un nombre seguro, cree un archivo de clave con Sn.exe y agréguelo al proyecto.

  1. Abra una consola de comandos de Visual Studio. Para ello, haga clic en el menú Inicio y, a continuación, seleccione Todos los programas/Microsoft Visual Studio 2010/Visual Studio Tools/Símbolo del sistema de Visual Studio. Esto inicia una ventana de consola con variables de entorno personalizadas.

  2. En el símbolo del sistema, use el comando cd para ir a tu carpeta del proyecto.

  3. Genere un archivo de clave denominado MyControls.snk ejecutando el siguiente comando.

    Sn.exe -k MyControls.snk

  4. Para incluir el archivo de clave en el proyecto, haga clic con el botón derecho en el nombre del proyecto en el Explorador de soluciones y, a continuación, haga clic en Propiedades. En el Diseñador de proyectos, haga clic en la pestaña Firma , active la casilla Firmar el ensamblado y, a continuación, vaya al archivo de clave.

  5. Compile la solución. La compilación generará un archivo DLL denominado MyControls.dll.

Implementación de la aplicación host de WPF

La aplicación host de WPF usa el WindowsFormsHost control para hospedar MyControl1. La aplicación controla el OnButtonClick evento para recibir los datos del control. También tiene una colección de botones de opción que permiten cambiar algunas de las propiedades del control de la aplicación WPF. En la ilustración siguiente se muestra la aplicación finalizada.

En la imagen siguiente se muestra la aplicación completa, incluido el control incrustado en la aplicación WPF:

Captura de pantalla que muestra un control incrustado en una página de WPF.

Creación del proyecto

Para iniciar el proyecto:

  1. Abra Visual Studio y seleccione Nuevo proyecto.

  2. En la categoría Ventana, seleccione la plantilla Aplicación WPF .

  3. Asigne al nuevo proyecto WpfHostel nombre .

  4. Para la ubicación, especifique la misma carpeta de nivel superior que contiene el proyecto MyControls.

  5. Haga clic en Aceptar para crear el proyecto.

También debe agregar referencias a la biblioteca DLL que contiene MyControl1 y a otros ensamblados.

  1. Haga clic con el botón derecho en el nombre del proyecto en el Explorador de soluciones y seleccione Agregar referencia.

  2. Haga clic en la pestaña Examinar y vaya a la carpeta que contiene MyControls.dll. Para este tutorial, esta carpeta es MyControls\bin\Debug.

  3. Seleccione MyControls.dlly haga clic en Aceptar.

  4. Agregue una referencia al ensamblado WindowsFormsIntegration, que se denomina WindowsFormsIntegration.dll.

Implementación del diseño básico

La interfaz de usuario (UI) de la aplicación host se implementa en MainWindow.xaml. Este archivo contiene marcado extensible del lenguaje de marcado de aplicaciones (XAML) que define el diseño y hospeda el control de Windows Forms. La aplicación se divide en tres regiones:

  • El panel Propiedades de control , que contiene una colección de botones de opción que puede usar para modificar varias propiedades del control hospedado.

  • El panel Datos del control , que contiene varios TextBlock elementos que muestran los datos devueltos desde el control hospedado.

  • El propio control hospedado.

El diseño básico se muestra en el código XAML siguiente. El marcado necesario para hospedar MyControl1 se omite en este ejemplo, pero se analizará más adelante.

Reemplace el XAML en MainWindow.xaml por lo siguiente. Si usa Visual Basic, cambie la clase a 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>

El primer StackPanel elemento contiene varios conjuntos de RadioButton controles que permiten modificar varias propiedades predeterminadas del control hospedado. Esto va seguido de un WindowsFormsHost elemento , que hospeda MyControl1. El elemento final StackPanel contiene varios TextBlock elementos que muestran los datos devueltos por el control hospedado. La ordenación de los elementos y la configuración de los atributos Dock y Height integran el control hospedado en la ventana sin huecos ni distorsión.

Hospedar el control

La siguiente versión editada del XAML anterior se centra en los elementos necesarios para hospedar 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>

El xmlns atributo de asignación de espacio de nombres crea una referencia al MyControls espacio de nombres que contiene el control hospedado. Esta asignación permite representar MyControl1 en XAML como <mcl:MyControl1>.

Dos elementos del XAML controlan el hospedaje:

  • WindowsFormsHost representa el WindowsFormsHost elemento que permite hospedar un control de Windows Forms en una aplicación WPF.

  • mcl:MyControl1, que representa MyControl1, se agrega a la WindowsFormsHost colección secundaria del elemento. Como resultado, este control de Windows Forms se representa como parte de la ventana de WPF y puede comunicarse con el control desde la aplicación.

Implementación del archivo Code-Behind

El archivo de código subyacente, MainWindow.xaml.vb o MainWindow.xaml.cs, contiene el código de procedimientos que implementa la funcionalidad de la interfaz de usuario que se describe en la sección anterior. Las tareas principales son:

  • Adjuntar un controlador de eventos al MyControl1evento.OnButtonClick

  • Modificar varias propiedades de MyControl1, en función de cómo se establece la colección de botones de opción.

  • Mostrar los datos recopilados por el control.

Inicialización de la aplicación

El código de inicialización está contenido en un controlador de eventos para el evento Loaded de la ventana y adjunta un controlador de eventos al evento OnButtonClick del control.

En MainWindow.xaml.vb o MainWindow.xaml.cs, agregue el código siguiente a la MainWindow clase .

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

Dado que el XAML descrito anteriormente añadió MyControl1 a la colección de elementos secundarios del elemento WindowsFormsHost, puedes convertir el Child del elemento WindowsFormsHost para obtener la referencia a MyControl1. A continuación, puede usar esa referencia para adjuntar un controlador de eventos a OnButtonClick.

Además de proporcionar una referencia al propio control, WindowsFormsHost expone una serie de propiedades del control, que puede manipular desde la aplicación. El código de inicialización asigna esos valores a variables globales privadas para su uso posterior en la aplicación.

Para que pueda acceder fácilmente a los tipos en la DLL MyControls, agregue la siguiente declaración Imports o using en la parte superior del archivo.

Imports MyControls

using MyControls;

Manejo del evento OnButtonClick

MyControl1 genera el OnButtonClick evento cuando el usuario hace clic en cualquiera de los botones del control.

Agregue el siguiente código a la clase MainWindow .

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

Los datos de los cuadros de texto se empaquetan en el MyControlEventArgs objeto . Si el usuario hace clic en el botón Aceptar , el controlador de eventos extrae los datos y los muestra en el panel debajo MyControl1de .

Modificar las propiedades del control

El WindowsFormsHost elemento expone varias de las propiedades predeterminadas del control hospedado. Como resultado, puede cambiar la apariencia del control para que coincida con el estilo de la aplicación más estrechamente. Los conjuntos de botones de opción del panel izquierdo permiten al usuario modificar varias propiedades de color y fuente. Cada conjunto de botones tiene un controlador para el Click evento, que detecta las selecciones de botones de opción del usuario y cambia la propiedad correspondiente en el control.

Agregue el siguiente código a la clase MainWindow .

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

Compile y ejecute la aplicación. Agregue texto en el control compuesto de Windows Forms y, a continuación, haga clic en Aceptar. El texto aparece en las etiquetas. Haga clic en los distintos botones de radio para ver el efecto en el control.

Consulte también