Demonstra Passo a passo: Alterar o comportamento de uma propriedade em time de design

Artigo
08/25/2010

Quando você usa extensibilidade para personalizar o Windows Presentation Foundation (WPF) Designer for Visual Studio, você geralmente irá criar controles personalizados.Algumas vezes, é necessário uma propriedade do controle para se comportar de maneira diferente no tempo de design que ao tempo de execução, enquanto ainda permite que o usuário definir o valor da propriedade normalmente.Por exemplo, você quiser que o usuário poderá definir a propriedade visível de um controle false,mas o controle ainda deve estar visível no tempo de design.

Você criará um personalizado Button e alterar o comportamento de Background essa explicação passo a passo e as propriedades Content.Para fazer isso, você cria um DesignModeValueProvider e anexá-la ao seu controle personalizado.O DesignModeValueProvider captura Propriedade alterações que o usuário faz, inserir sua própria lógica no método TranslatePropertyValue, e o DesignModeValueProvider passa os novos valores para o designer.

Observação importante:
Quando você usa essa técnica, o comportamento de uma propriedade no designer não coincide com o valor da propriedade no modo XAML.XAML exibe o valor que o usuário inseriu em tempo de design.O valor no modo XAML representa o comportamento que a propriedade irá apresentar em tempo de execução.

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

Criar um projeto de biblioteca de controle personalizado WPF .
Crie um DesignModeValueProvider personalizado.
Crie um controle de botão personalizado.
Anexe a DesignModeValueProvider a controle personalizado.
Crie um aplicativo de teste.
Teste a controle personalizado.

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

Criar um projeto de biblioteca de controle personalizado WPF .

Para criar o projeto

Criar um novo projeto Biblioteca de controle personalizado WPF em Visual Basic ou Visual C# chamado SkewButtonLibrary .

O código de CustomControl1 abre no Editor de Códigos.
Adicione uma referência ao seguinte conjunto de módulos (assembly) .
- Microsoft.Windows.Design.Extensibility
Em Gerenciador de Soluções ,altere o nome do arquivo de código para CustomButton.cs ou CustomButton.vb.

Se um caixa de mensagem aparecer que pergunta se você deseja executar uma renomeação para todas as referências no projeto atual, clique em Sim .
Em Gerenciador de Soluções expanda a pasta Themes e abra o arquivo Generic.XAML.

Generic.xaml é aberto no WPF Designer.
No modo de exibição XAML, substitua todas as ocorrências de "CustomControl1" com "CustomButton" no arquivo Generic.XAML.
On the Compilação menu, clicar Criar solução.

Criando um DesignModeValueProvider personalizado

Nesse procedimento você criar uma classe DesignModeValueProvider Personalizada.No método TranslatePropertyValue, você alterar a propriedade Content de Button para que ele seja exibido maiúsculo no designer.Você também alterar a Background propriedade de Button para que ele seja exibido com a cor padrão do sistema no designer.Essas alterações afetam somente o criador.No tempo de execução, o Content e as Background propriedades aparecem com os valores definidos pelo usuário.

Observação:
Nesse procedimento, você criar um DesignModeValueProvider que lida com duas propriedades diferentes.Você também pode criar vários objetos DesignModeValueProvider para manipular as propriedades diferentes.

Para criar um DesignModeValueProvider personalizado

Adicionar uma nova classe denominada CustomButtonDesignModeValueProvider.cs ou CustomButtonDesignModeValueProvider.vb para o projeto CustomButton.

A classe abre na editor de códigos.

Adicione os seguintes namespaces à parte superior do arquivo.Substitua os existentes se houver algum.

Imports System
Imports System.Windows                  'SystemColors
Imports System.Windows.Media            'SolidColorBrush
Imports System.Windows.Controls         'Button
Imports Microsoft.Windows.Design.Model  'DesignModeValueProvider

using System;
using System.Windows;                   //SystemColors
using System.Windows.Media;             //SolidColorBrush
using System.Windows.Controls;          //Button
using Microsoft.Windows.Design.Model;   //DesignModeValueProvider

Edite a CustomButtonDesignModeValueProvider classe para herdar de DesignModeValueProvider.

Public Class CustomButtonDesignModeValueProvider
    Inherits DesignModeValueProvider

End Class

class CustomButtonDesignModeValueProvider : DesignModeValueProvider
{
}

Adicione um método à classe.No Construtor de você identificar as propriedades que você deseja capturar.

Public Sub New()

    Properties.Add(Button.ContentProperty)
    Properties.Add(Button.BackgroundProperty)
End Sub

public CustomButtonDesignModeValueProvider()
{
    Properties.Add(Button.ContentProperty);
    Properties.Add(Button.BackgroundProperty);
}

Substituir o método TranslatePropertyValue na classe.Isso é onde você especificar o novo comportamento das propriedades em tempo de design.

Public Overrides Function TranslatePropertyValue(ByVal identifier As PropertyIdentifier, ByVal value As Object) As Object

    If identifier.DependencyProperty Is Button.ContentProperty Then

        Return value.ToString().ToUpper()
    End If

    If identifier.DependencyProperty Is Button.BackgroundProperty Then

        Return New SolidColorBrush(SystemColors.ControlColor)
    End If

    Return MyBase.TranslatePropertyValue(identifier, value)
End Function

public override object TranslatePropertyValue(PropertyIdentifier identifier, object value)
{
    if (identifier.DependencyProperty == Button.ContentProperty)
    {
        return ((string)value).ToUpper();
    }

    if (identifier.DependencyProperty == Button.BackgroundProperty)
    {
        return new SolidColorBrush(SystemColors.ControlColor);
    }

    return base.TranslatePropertyValue(identifier, value);
}

On the Compilação menu, clicar Criar solução.

Crie um controle de botão personalizado.

Esse procedimento você criar a controle personalizado.Criar um controle personalizado simples que herda de Button, mas contém nenhuma funcionalidade personalizada adicional.

Crie um controle de botão personalizado.

A classe CustomButton abre na editor de códigos.

Adicione os seguintes namespaces à parte superior do arquivo.Substitua os existentes se houver algum.

Imports System.Windows.Controls             'Button
Imports Microsoft.Windows.Design.Features   'Feature

using System.Windows.Controls;              //Button
using Microsoft.Windows.Design.Features;    //Feature

Substitua o seguinte a classe existente.

Public Class CustomButton
    Inherits Button

    Shared Sub New()

    End Sub
End Class

public class CustomButton : Button
{
    static CustomButton()
    {
    }
}

On the Compilação menu, clicar Criar solução.

Anexando a DesignModeValueProvider ao controle personalizado

Nesse procedimento você anexar DesignModeValueProvider para o controle personalizado, usando o atributo FeatureAttribute.

Observação:
Você também pode anexar um DesignModeValueProvider a um controle personalizado usando o armazenamento de metadados.Para obter mais informações, consulte Armazenamento de metadados e Como: Use o Repositório de Metadados.

Anexando a DesignModeValueProvider ao controle personalizado

No editor do código, localize a declaração da classe CustomButton.O código deve se parecer com o seguinte:
```
Public Class CustomButton
    Inherits Button
```
```
public class CustomButton : Button
```

Adicionar um atributo de recursos para a declaração de classe e especifique o DesignModeValueProvider.

<Feature(GetType(CustomButtonDesignModeValueProvider))> _
Public Class CustomButton
    Inherits Button

[Feature(typeof(CustomButtonDesignModeValueProvider))]
public class CustomButton : Button

On the Compilação menu, clicar Criar solução.

Criando um aplicativo de teste

Crie um aplicativo de teste.

Adicione um projeto de aplicativos do Windows chamado WpfUserControlHost à solução.

Window1.xaml é aberto no WPF Designer.
Em Solution Explorer, clique com o botão direito do mouse o projeto Client e selecione Project Set As Startup .
No menu Project,clique em Adicionar Referência e use a guia Projects Para adicionar uma referência ao projeto CustomButton.
On the Compilação menu, clicar Criar solução.

Teste o controle personalizado

Teste a controle personalizado.

No modo de exibição XAML, substitua o XAML gerado automaticamente pelo seguinte XAML.

<Window x:Class="CustomButtonTestApplication.Window1"
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:cb="clr-namespace:CustomButton;assembly=CustomButton"
    Title="Window1" Height="300" Width="300">
    <Grid>
        <cb:CustomButton Height="75" Width="100">Button1</cb:CustomButton>
    </Grid>
</Window>

No modo Design, selecione .Se necessário, clique na Barra de Informações na parte superior do designer para recarregar o modo de exibição.
Na janela Properties,localize a propriedade Background.
Digite em vermelho e pressione ENTER.

O XAML livre é atualizado com o código Background="Red", mas não altera a cor do botão no modo de design.
Na janela Properties,localize a propriedade Background.
Digite Hello World e pressione ENTER.

O XAML livre é atualizado com o conteúdo Hello World, mas o botão exibe o texto HELLO WORLD no modo de design.
No menu Depuração, clique em Iniciar Depuração.

Inicia o aplicativo e a janela é exibida.O botão é vermelho e contém o texto Hello World no tempo de execução.
Feche a janela.