Quais abordagens estão disponíveis para dados de tempo de design fictícios no WPF?

Estou trabalhando sem mistura de expressão e usando apenas o editor XAML no vs2010. Deixando isso de lado, vejo cada vez mais a necessidade de vinculação de dados em tempo de design. Para casos simples, a FallbackValuepropriedade funciona muito bem (Textboxes e TextBlocks, etc). Mas, especialmente ao lidar com ItemsControle semelhantes, é necessário que os dados de amostra fiquem visíveis no designer para que você possa ajustar e ajustar os controles e modelos de dados sem ter que executar o executável.

Eu sei que isso ObjectDataProviderpermite a vinculação a um tipo e, portanto, pode fornecer dados de tempo de design para visualização, mas há alguns malabarismos para permitir que os dados de tempo de execução reais sejam vinculados sem desperdiçar recursos ao carregar o tempo de design, dados simulados e as ligações de tempo de execução.

Na verdade, o que desejo é a capacidade de ter, digamos, "John", "Paul", "George" e "Ringo" no designer XAML como itens estilizáveis ​​no meu ItemsControl, mas dados reais aparecerem quando o aplicativo corre.

Eu também sei que o Blend permite alguns atributos sofisticados que definem dados de vinculação de tempo de design que são efetivamente ignorados pelo WPF em condições de tempo de execução.

Então, minhas perguntas são:

1. Como posso aproveitar as associações de tempo de design de coleções e dados não triviais no designer XAML do Visual Studio e, em seguida, trocar para associações de tempo de execução sem problemas?

2. Como outras pessoas resolveram esse problema de dados em tempo de design vs. tempo de execução? No meu caso, não posso usar facilmente os mesmos dados para ambos (como seria possível com, digamos, uma consulta de banco de dados).

3. Existem alternativas para a combinação de expressões que eu poderia usar para o design XAML integrado de dados? (Eu sei que existem algumas alternativas, mas eu quero especificamente algo que eu possa usar e ver dados de amostra vinculados, etc?)

Usando VS2010, você pode usar atributos de tempo de design (funciona para SL e WPF). Eu geralmente tenho uma fonte de dados simulada de qualquer maneira, então é só uma questão de:

• Adicionando a declaração de namespace

  xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

• Adicionando o contexto de dados fictícios aos recursos de janela / controle

  <UserControl.Resources>
    <ViewModels:MockXViewModel x:Key="DesignViewModel"/>
  </UserControl.Resources>

• Definição do contexto de dados em tempo de design

  <Grid d:DataContext="{Binding Source={StaticResource DesignViewModel}}" ...

Funciona bem o suficiente.

Como um amálgama da resposta aceita de Goran e do excelente comentário de René.

• Adicione a declaração de namespace. xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

• Referencie seu contexto de dados de tempo de design do código.
  <Grid d:DataContext="{d:DesignInstance Type=ViewModels:MockXViewModel, IsDesignTimeCreatable=True}" ...

Karl Shifflett descreve uma abordagem que deve funcionar igualmente bem para VS2008 e VS2010:

Visualizando dados de tempo de design no Visual Studio 2008 Cider Designer em projetos WPF e Silverlight

Laurent Bugnion tem uma abordagem semelhante que se concentra no Expression Blend. Ele pode trabalhar para VS2010, mas eu não confirmaram isso ainda.

Simular dados no modo de design no Microsoft Expression Blend

Talvez os novos recursos de tempo de design do Visual Studio 2010 e Expression Blend 4 sejam uma opção para você.

Como funciona é mostrado no aplicativo de amostra BookLibrary do WPF Application Framework (WAF) . Faça download da versão .NET4.

Eu uso essa abordagem para gerar dados de tempo de design com .NET 4.5 e Visual Studio 2013.

Eu tenho apenas um ViewModel. O modelo de visualização possui uma propriedade IsInDesignModeque informa se o modo de design está ativo ou não (consulte a classe ViewModelBase). Em seguida, você pode configurar seus dados de tempo de design (como preencher um controle de itens) no construtor de modelos de visualização.

Além disso, eu não carregaria dados reais no construtor de modelos de visualização, isso pode levar a problemas no tempo de execução, mas configurar os dados para o tempo de design não deve ser um problema.

public abstract class ViewModelBase
{
    public bool IsInDesignMode
    {
        get
        {
            return DesignerProperties.GetIsInDesignMode(new DependencyObject());
        }
    }
}

public class ExampleViewModel : ViewModelBase
{
    public ExampleViewModel()
    {
        if (IsInDesignMode == true)
        {
            LoadDesignTimeData();
        }
    }

    private void LoadDesignTimeData()
    {
        // Load design time data here
    }       
}

Usando o Visual Studio 2017, tenho tentado seguir todos os guias e questões como esta e ainda estava diante de um <ItemsControl>que simplesmente não executou o código que eu tinha dentro do construtor de um do DesignFooViewModelqual herda FooViewModel. Confirmei a parte "não executou" seguindo este guia "útil" do MSDN (spoiler: MessageBoxdepuração). Embora isso não esteja diretamente relacionado à pergunta original, espero que poupe muito tempo aos outros.

Acontece que não estava fazendo nada de errado. O problema era que meu aplicativo precisava ser construído para x64. Como o Visual Studio ainda é em 2018 um processo de 32 bits e aparentemente não pode girar um processo de host de 64 bits para a parte do designer, ele não pode usar minhas classes x64. O que é realmente ruim é que não há erros em nenhum log que eu possa imaginar.

Portanto, se você se deparar com essa pergunta porque está vendo dados falsos em seu modelo de visualização do tempo de design (por exemplo: <TextBlock Text="{Binding Name}"/>aparece Nameindependentemente de você definir a propriedade como), a causa provavelmente será sua construção x64. Se você não puder alterar sua configuração de compilação para anycpu ou x86 por causa das dependências, considere a criação de um novo projeto que seja totalmente anycpu e não tenha as dependências (ou quaisquer dependências). Então, você acaba dividindo a maior parte ou todas, exceto as partes de inicialização do código, de seu projeto "WPF App" em um projeto de "biblioteca de classes C #".

Para a base de código em que estou trabalhando, acho que isso forçará uma separação saudável de interesses ao custo de alguma duplicação de código, o que provavelmente é positivo.

Semelhante à resposta mais bem avaliada, mas melhor na minha opinião: você pode criar uma propriedade estática para retornar uma instância de dados de design e referenciá-la diretamente do XAML assim:

<d:UserControl.DataContext>
    <Binding Source="{x:Static designTimeNamespace:DesignTimeViewModels.MyViewModel}" />
</d:UserControl.DataContext>

Isso evita a necessidade de uso UserControl.Resources. Sua propriedade estática pode funcionar como uma fábrica, permitindo que você construa tipos de dados não triviais - por exemplo, se você não tiver um ctor padrão, você pode chamar uma fábrica ou contêiner aqui para injetar nas dependências apropriadas.