Demonstra Passo a passo: Criando um conversor de tipo para o WPF designer

Essa explicação passo a passo mostra como criar um conversor de tipos de um tipo personalizado.O Windows Presentation Foundation (WPF) Designer for Visual Studio usa o conversor de tipos para serializar seu tipo personalizado para e a partir da linguagem XAML.

Nesta explicação passo a passo, você executa as seguintes tarefas:

• Criar o projeto.

• Criar o tipo personalizado.

• Criar o conversor de tipos.

• Criar um controle que usa o tipo personalizado.

• Exibir o tipo personalizado na janela de Properties.

Quando você terminar, você poderá ser criar tipo conversores para seus tipos personalizados.

Observação:
As caixas de diálogo e comandos de menu demonstradas podem ser diferentes daqueles descritas na Ajuda, dependendo das configurações ativas ou configurações de edição.Para alterar as configurações, escolher Importar e exportar configurações on the Ferramentas menu.Para obter mais informações, consulte Configurações do Visual Studio.

Pré-requisitos

Para completar este passo a passo, são necessários os seguintes componentes:

• Visual Studio 2008.

Criando o projeto

A primeira etapa é criar um projeto para a aplicação.

Para criar o projeto

• Criar um novo projeto de aplicativo WPF em Visual Basic ou Visual C# chamado TypeConverterExample .Para obter mais informações, consulte Como: Criar um novo projeto de aplicativo do WPF.

  Window1.xaml é aberto no WPF Designer.

Criando o Tipo Personalizado

Nesse procedimento, você cria um tipo personalizado simples chamado Complex, que representa um número complexo.Um número complexo tem uma parte real e uma parte imaginária, e elas são expostas como propriedades double.

Para criar um tipo personalizado

1. Adicione uma nova classe denominada Complex.vb ou Complex.cs para o projeto TypeConverterExample.Para obter mais informações, consulte Como: Itens de Adicionar Novo Projeto.

   O arquivo de código para a classe Complex abre no Editor de Códigos.

2. Substitua a definição da classe Complex pelo código a seguir.

   <TypeConverter(GetType(ComplexTypeConverter))> _
   Public Class Complex
       Private realValue As Double
       Private imaginaryValue As Double
   
       Public Sub New()
   
       End Sub
   
       Public Sub New(ByVal real As Double, ByVal imaginary As Double)
           Me.realValue = real
           Me.imaginaryValue = imaginary
   
       End Sub
   
       Public Property Real() As Double
           Get
               Return realValue
           End Get
   
           Set(ByVal value As Double)
               realValue = value
           End Set
       End Property
   
       Public Property Imaginary() As Double
           Get
               Return imaginaryValue
           End Get
   
           Set(ByVal value As Double)
               imaginaryValue = value
           End Set
       End Property
   
       Public Overrides Function ToString() As String
           Return String.Format( _
               CultureInfo.CurrentCulture, _
               "{0}{2}{1}", _
               Me.realValue, _
               Me.imaginaryValue, _
               CultureInfo.CurrentCulture.NumberFormat.NumberGroupSeparator)
       End Function
   
       Public Shared Function Parse(ByVal complexNumber As String) As Complex
           If String.IsNullOrEmpty(complexNumber) Then
               Return New Complex()
           End If
   
           'The parts array holds the real and imaginary parts of the object.
           Dim separator() As Char = {","}
           Dim parts() As String = complexNumber.Split(separator)
   
           If (parts.Length <> 2) Then
               Throw New FormatException( _
                   String.Format( _
                       "Cannot parse '{0}' into a Complex object because " & _
                       "it is not in the '<real>, <imaginary>' format.", _
                   complexNumber))
           End If
   
           Return New Complex( _
               Double.Parse(parts(0).Trim()), _
               Double.Parse(parts(1).Trim()))
   
       End Function
   
   End Class
   

   [TypeConverter( typeof( ComplexTypeConverter ) )]
   public class Complex
   {
       private double realValue;
       private double imaginaryValue;
   
       public Complex()
       {
       }
   
       public Complex(double real, double imaginary)
       {
           this.realValue = real;
           this.imaginaryValue = imaginary;
       }
   
       public double Real
       {
           get
           {
               return realValue;
           }
   
           set
           {
               realValue = value;
           }
       }
   
       public double Imaginary
       {
           get 
           {
               return imaginaryValue; 
           }
   
           set 
           {
               imaginaryValue = value; 
           }
       }
   
       public override string ToString()
       {
           return String.Format(
               CultureInfo.CurrentCulture, 
               "{0}{2}{1}", 
               this.realValue, 
               this.imaginaryValue,
               CultureInfo.CurrentCulture.NumberFormat.NumberGroupSeparator);
       }
   
       public static Complex Parse(string complexNumber)
       {
           if (String.IsNullOrEmpty(complexNumber))
           {
               return new Complex();
           }
   
           // The parts array holds the real and 
           // imaginary parts of the object.
           string[] parts = complexNumber.Split(',');       
   
           if (2 != parts.Length)
           {
               throw new FormatException(
                   String.Format(
                   "Cannot parse '{0}' into a Complex object because " +
                   "it is not in the \"<real>, <imaginary>\" format.",
                   complexNumber));
           }
   
           return new Complex(double.Parse(parts[0].Trim()), double.Parse(parts[1].Trim()));
   
       }
   }
   

Criando o Conversor de Tipo

Agora você define o conversor de tipos para a classe Complex.A classe ComplexTypeConverter converte um objeto Complex para sua representação em sequência de caracteres e vice-versa.Ele também fornece uma lista de valores padrão, que podem ser exibidos no designer da janela Properties.

Para criar o conversor de tipos

1. Após a definição da classe Complex, insira o código a seguir para a classe ComplexTypeConverter.

   Public Class ComplexTypeConverter
       Inherits TypeConverter
   
       Private Shared defaultValues As List(Of Complex) = New List(Of Complex)()
   
       Shared Sub New()
           defaultValues.Add(New Complex(0, 0))
           defaultValues.Add(New Complex(1, 1))
           defaultValues.Add(New Complex(-1, 1))
           defaultValues.Add(New Complex(-1, -1))
           defaultValues.Add(New Complex(1, -1))
       End Sub
   
       ' Override CanConvertFrom to return true for String-to-Complex conversions.
       Public Overrides Function CanConvertFrom( _
           ByVal context As ITypeDescriptorContext, _
           ByVal sourceType As Type) As Boolean
   
           If sourceType Is GetType(String) Then
               Return True
           End If
   
           Return MyBase.CanConvertFrom(context, sourceType)
   
       End Function
   
       ' Override CanConvertTo to return true for Complex-to-String conversions.
       Public Overrides Function CanConvertTo( _
           ByVal context As System.ComponentModel.ITypeDescriptorContext, _
           ByVal destinationType As System.Type) As Boolean
   
           If destinationType Is GetType(String) Then
               Return True
           End If
   
           Return MyBase.CanConvertTo(context, destinationType)
   
       End Function
   
       ' Override ConvertFrom to convert from a string to an instance of Complex.
       Public Overrides Function ConvertFrom( _
           ByVal context As ITypeDescriptorContext, _
           ByVal culture As System.Globalization.CultureInfo, _
           ByVal value As Object) As Object
   
           If TypeOf value Is String Then
               Try
                   Return Complex.Parse(CType(value, String))
               Catch ex As Exception
                   Throw New Exception( _
                       String.Format( _
                           "Cannot convert '{0}' ({1}) because {2}", _
                           value, _
                           value.GetType(), _
                           ex.Message), ex)
   
               End Try
           End If
   
           Return MyBase.ConvertFrom(context, culture, value)
   
       End Function
   
       ' Override ConvertTo to convert from an instance of Complex to string.
       Public Overrides Function ConvertTo( _
           ByVal context As ITypeDescriptorContext, _
           ByVal culture As System.Globalization.CultureInfo, _
           ByVal value As Object, _
           ByVal destinationType As Type) As Object
   
           If destinationType Is Nothing Then
               Throw New ArgumentNullException("destinationType")
           End If
   
           Dim c As Complex = CType(value, Complex)
   
           If (c IsNot Nothing) Then
               If Me.CanConvertTo(context, destinationType) Then
                   Return c.ToString()
               End If
           End If
   
           Return MyBase.ConvertTo(context, culture, value, destinationType)
   
       End Function
   
   
       Public Overrides Function GetStandardValuesSupported( _
           ByVal context As System.ComponentModel.ITypeDescriptorContext) As Boolean
   
           Return True
   
       End Function
   
   
       Public Overrides Function GetStandardValues( _
           ByVal context As System.ComponentModel.ITypeDescriptorContext) _
               As TypeConverter.StandardValuesCollection
   
           Dim svc As New StandardValuesCollection(defaultValues)
           Return svc
   
       End Function
   End Class
   

   public class ComplexTypeConverter : TypeConverter
   {
       private static List<Complex> defaultValues = new List<Complex>();
   
       static ComplexTypeConverter()
       {
           defaultValues.Add(new Complex(0, 0));
           defaultValues.Add(new Complex( 1, 1));
           defaultValues.Add(new Complex(-1, 1));
           defaultValues.Add(new Complex(-1,-1));
           defaultValues.Add(new Complex( 1,-1));
       }
   
       // Override CanConvertFrom to return true for String-to-Complex conversions.
       public override bool CanConvertFrom(
           ITypeDescriptorContext context, 
           Type sourceType)
       {
           if (sourceType == typeof(string))
           {
               return true;
           }
   
           return base.CanConvertFrom(context, sourceType);
       }
   
       // Override CanConvertTo to return true for Complex-to-String conversions.
       public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
       {
           if (destinationType == typeof(string))
           {
               return true;
           }
   
           return base.CanConvertTo(context, destinationType);
       }
   
       // Override ConvertFrom to convert from a string to an instance of Complex.
       public override object ConvertFrom(
           ITypeDescriptorContext context, 
           System.Globalization.CultureInfo culture, 
           object value)
       {
           string text = value as string;
   
           if (text != null)
           {
               try
               {
                   return Complex.Parse(text);
               }
               catch (Exception e)
               {
                   throw new Exception(
                       String.Format("Cannot convert '{0}' ({1}) because {2}", 
                                       value, 
                                       value.GetType(), 
                                       e.Message), e);
               }
           }
   
           return base.ConvertFrom(context, culture, value);
       }
   
       // Override ConvertTo to convert from an instance of Complex to string.
       public override object ConvertTo(
           ITypeDescriptorContext context, 
           System.Globalization.CultureInfo culture, 
           object value, 
           Type destinationType)
       {
           if (destinationType == null)
           {
               throw new ArgumentNullException("destinationType");
           }
   
           //Convert Complex to a string in a standard format.
           Complex c = value as Complex;
   
           if (c != null && this.CanConvertTo(context, destinationType))
           {
               return c.ToString();
           }
   
           return base.ConvertTo(context, culture, value, destinationType);
       }
   
       public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
       {
           return true;
       }
   
       public override TypeConverter.StandardValuesCollection GetStandardValues(
           ITypeDescriptorContext context)
       {   
           StandardValuesCollection svc = new StandardValuesCollection(defaultValues);       
           return svc;
       }
   }
   

2. Na parte superior do arquivo, importe o namespace System.ComponentModel, que contém a implementação do TypeConverter.

   Imports System.ComponentModel
   Imports System.Globalization
   

   using System.ComponentModel;
   using System.Globalization;
   

Criando um Controle Que Utiliza um Tipo Personalizado

Para ver seu tipo personalizado e o conversor de tipos dele em ação na camada de design, crie um UserControl com a propriedade do tipo Complex.

Para criar um controle que usa um tipo personalizado

1. Adicione um novo controle de usuário WPF denominado ComplexNumberControl.xaml ao projeto TypeConverterExample.Para obter mais informações, consulte Como: Adicionar novos itens a um projeto do WPF.

2. Veja o código para ComplexNumberControl.

3. Substitua a definição da classe ComplexNumberControl pelo código a seguir.

   Partial Public Class ComplexNumberControl
       Inherits System.Windows.Controls.UserControl
   
       Private complexNumberValue As Complex
   
       Public Sub New()
           InitializeComponent()
   
       End Sub
   
       Public Property ComplexNumber() As Complex
           Get
               Return Me.GetValue(ComplexNumberProperty)
           End Get
   
           Set(ByVal value As Complex)
               Me.SetValue(ComplexNumberProperty, value)
           End Set
       End Property
   
       Public Shared ReadOnly ComplexNumberProperty As DependencyProperty = DependencyProperty.Register( _
         "ComplexNumber", _
         GetType(Complex), _
         GetType(ComplexNumberControl), _
         New PropertyMetadata(New Complex()))
   
   End Class
   

   public partial class ComplexNumberControl : UserControl
   {
       public ComplexNumberControl()
       {
           InitializeComponent();
       }
   
       public Complex ComplexNumber
       {
           get 
           { 
               return (Complex)this.GetValue(ComplexNumberProperty); 
           }
   
           set 
           { 
               this.SetValue(ComplexNumberProperty, value); 
           }
       }
       public static readonly DependencyProperty ComplexNumberProperty = DependencyProperty.Register(
         "ComplexNumber",
         typeof(Complex),
         typeof(ComplexNumberControl),
         new PropertyMetadata(new Complex()));
   }
   

4. Crie o projeto.

Exibindo o Tipo Personalizado na Janela de Propriedades

Você pode exibir seu tipo personalizado quando ComplexNumberControl estiver hospedado em uma janela WPF.

Para exibir o tipo personalizado na Janela de Propriedades

1. Abra Window1.xaml no WPF Designer.

2. No modo de exibição XAML, substitua o elemento Window pelo o código a seguir.

   <Window x:Class="TypeConverterExample.Window1"
       xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
       xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
       xmlns:c="clr-namespace:TypeConverterExample"
       Title="Window1" Height="300" Width="300">
       <Grid>
           <c:ComplexNumberControl ComplexNumber="0,0" />
       </Grid>
   </Window>
   

   <Window x:Class="TypeConverterExample.Window1"
       xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
       xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
       xmlns:c="clr-namespace:TypeConverterExample"
       Title="Window1" Height="300" Width="300">
       <Grid>
           <c:ComplexNumberControl ComplexNumber="0,0" />
       </Grid>
   </Window>
   

3. Clique no modo de design.Se necessário, clique na Barra de Informações na parte superior para recarregar a janela.

4. No modo de exibição do XAML, clique no elemento ComplexNumberControl.

5. Na janela Properties, clique na propriedade ComplexNumber.

   Uma seta suspensa aparece próxima ao item de ComplexNumber.

6. Clique na lista suspensa para ver a lista de valores padrão.Selecione o valor -1,-1.

   No modo de exibição do XAML, a atribuição ComplexNumber altera para "-1, -1".

Consulte também

Tarefas

Como: Implementar um conversor de tipo

Referência

TypeConverter

TypeConverterAttribute

XamlReader

XamlWriter

System.Windows.Markup

Outros recursos

XAML

Extensibilidade do WPF Designer