È possibile ottenere binding fortemente tipizzati in WPF/XAML?

Question

Utilizzando lo MVVM -pattern si imposta DataContext su un ViewModel specifico. Ora c'è un modo per dire al XAML il tipo di DataContext in modo che possa convalidare i miei binding?

Cercare qualcosa come il tipo di dati digitati in ASP.NET MVC.

Answer 1

No, la specifica corrente non ha una digitazione forte in Xaml. Credo che con .Net 4.0, Xaml dovrebbe vedere la capacità dei generici. Con quello, penserei che dovrebbe essere molto più facile avere una digitazione forte in Xaml.

Answer 2

È possibile scrivere ogni singola associazione in un modo fortemente tipizzato:

<TextBox Text="{Binding Path=(vm:Site.Contact).(vm:Contact.Name)}" /> 

Tuttavia questo non sarebbe convalidare il fatto che TextBox DataContext è di tipo ViewModel.Site (e penso che questo non è possibile, ma Potrei sbagliarmi).

Answer 3

Prova questo:

<Window> 
    <Window.Resources> 
     <DataTemplate x:Key="TypedTemplate" DataType="{x:Type myViewModel}"> 
      ... 
     </DataTemplate> 
    </Window.Resources> 

    <ContentPresenter Content="{Binding}" Template="{StaticResource TypedTemplate}" /> 
</Window> 

non ho ancora testato questo codice ma dovrebbe dare l'idea. Il presentatore di contenuti mostrerà il DataContext corrente che utilizzerà il DataTemplate. Questo non è fortemente scritto nel compilatore, ma genererà un errore di runtime immediatamente in fase di caricamento (in InitializeComponent della finestra). Dovresti essere in grado di cogliere facilmente questo nei tuoi test se qualcosa si rompe.

Answer 4

No. FrameworkElement.DatatContext è la proprietà di dipendenza che consente l'associazione dati è di tipo object.

Come indicato da altri, è possibile specificare il tipo previsto di DataContext per un modello speciale denominato DataTemplate. Molti controlli come ItemsControl, ControlControl forniscono l'accesso a DataTemplates per consentire all'utente di impostare le aspettative di rappresentazione visiva del tipo di DataContext.

Bryan ha ragione, non ha testato il suo codice.

La corretta applicazione di un DataTemplate digitato assomiglia a questo:

<Window> 
    <Window.Resources> 
     <DataTemplate x:Key="TypedTemplate" DataType="{x:Type myViewModel}"> 
     ... 
     </DataTemplate> 
    </Window.Resources> 
    <ContentControl Content="{Binding}" ContentTemplate="{StaticResource TypedTemplate}" /> 
</Window> 

ContentPresenter eredita direttamente da FrameworkElement e non dispone di una proprietà Template. Inoltre, la proprietà Template si riferisce comunemente a Control.Template del tipo ControlTemplate che è qualcosa di completamente diverso da un DataTemplate.

Penso che Bryan stesse pensando allo ContentControl che è uno dei due tipi di controllo root (l'altro è ItemsControl). ContentControl infatti eredita da Control. Pertanto possiamo specificare la proprietà Template su di esso se lo desideriamo.

<Window> 
    <Window.Resources> 
     <DataTemplate x:Key="TypedTemplate" DataType="{x:Type myViewModel}"> 
     ... 
     </DataTemplate> 
     <ControlTemplate x:Key="ControlSkin" TargetType="{x:Type ContentControl}"> 
     ... 
     </ControlTemplate> 
    </Window.Resources> 
    <ContentControl Content="{Binding}" ContentTemplate="{StaticResource TypedTemplate}" Template="{StaticResource ControlSkin}" /> 
</Window> 

Answer 5

Io personalmente dichiaro un PropertyPath statica per ogni proprietà nel mio ViewModel il riferimento questo usando x: statica come il percorso di associazione - esempio

public class MyViewModel 
{ 
    public static PropertyPath MyPropertyPath = new PropertyPath("MyProperty"); 
    public bool MyProperty{get; set;} 
} 

XAML: {Binding Path={x:Static local:MyViewModel.MyPropertyPath}}

In questo modo tutto i miei binding vengono convalidati su build.