Existe-t-il des projets WPF courants?

Question

Dans le cadre de ma tentative d'adaptation à WPF/XAML, je me suis intéressé à l'application d'interfaces fluides au codage de l'interface utilisateur.

Je suis au courant de Fluent Silverlight (http://code.google.com/p/fluent-silverlight/), mais je ne peux pas trouver quelque chose d'équivalent pour WPF.

En guise de note personnelle, je trouve qu'il est très difficile d'acheter tout en combinant XAML et C#/MVVM. Il me semble que certains aspects de la programmation de l'interface utilisateur (par exemple la liaison de données) sont mieux exprimés dans le code que dans le code XAML déclaratif.

Une interface WPF fluide semble être la seule chose pour atteindre ces objectifs.

Answer 1

API Courant pour la construction de commandes dans WPF http://code.google.com/p/present/

Answer 2

Lors d'un récent podcast de Herding Code: http://herdingcode.com/?p=212 l'un des invités explique qu'il a tenté une interface fluide pour créer des interfaces utilisateur WPF. Il est possible que l'un d'entre eux puisse faire ce qu'il a fait. Incidemment, ce même podcast et celui qui le précède (http://herdingcode.com/?p=208) parlent de vos préoccupations concernant le code d'abord par rapport à la vue d'abord et pourquoi il est avantageux de se concentrer sur xaml. Les arguments sont principalement pour rendre les interfaces utilisateur "Blendable" (pouvoir les concevoir dans Microsoft Expression Blend) par un concepteur en plus de la testabilité de votre code. Une approche basée sur le code réduit en quelque sorte cette capacité si vous n'êtes pas très prudent.

Vous n'êtes pas seul dans vos appréhensions. Espérons que ces podcasts vous aideront à prendre une décision.

Answer 3

Comme je lance dans des parties de WPF que je préfère programmer dans un style fluide, j'ajouter le soutien des méthodes d'extension à un ensemble d'utilité personnelle. Par exemple, voici un programme qui montre les propriétés TaskbarItemInfoProgressValue et ProgressState. Cette version est écrite d'une manière standard non-fluide.

using System.Windows; 
using System.Windows.Controls; 
using System.Windows.Shell; 

namespace TaskbarItemProgress 
{ 
    public partial class MainWindow : Window 
    { 
     public MainWindow() 
     { 
      InitializeComponent(); 

      TaskbarItemInfo = new TaskbarItemInfo(); 

      TaskbarItemInfo.ProgressValue = 0.5; 

      var stackPanel = new StackPanel(); 

      Content = stackPanel; 

      var normalButton = new Button() { Content = "Normal" }; 
      normalButton.Click += (s, e) => 
       TaskbarItemInfo.ProgressState = TaskbarItemProgressState.Normal; 
      stackPanel.Children.Add(normalButton); 

      var pausedButton = new Button() { Content = "Paused" }; 
      pausedButton.Click += (s, e) => 
       TaskbarItemInfo.ProgressState = TaskbarItemProgressState.Paused; 
      stackPanel.Children.Add(pausedButton); 

      var errorButton = new Button() { Content = "Error" }; 
      errorButton.Click += (s, e) => 
       TaskbarItemInfo.ProgressState = TaskbarItemProgressState.Error; 
      stackPanel.Children.Add(errorButton); 

      var indeterminateButton = new Button() { Content = "Indeterminate" }; 
      indeterminateButton.Click += (s, e) => 
       TaskbarItemInfo.ProgressState = TaskbarItemProgressState.Indeterminate; 
      stackPanel.Children.Add(indeterminateButton); 

      var noneButton = new Button() { Content = "None" }; 
      noneButton.Click += (s, e) => 
       TaskbarItemInfo.ProgressState = TaskbarItemProgressState.None; 
      stackPanel.Children.Add(noneButton); 

      var increaseButton = new Button() { Content = "Increase" }; 
      increaseButton.Click += (s, e) => TaskbarItemInfo.ProgressValue += 0.10; 
      stackPanel.Children.Add(increaseButton); 

      var decreaseButton = new Button() { Content = "Decrease" }; 
      decreaseButton.Click += (s, e) => TaskbarItemInfo.ProgressValue -= 0.10; 
      stackPanel.Children.Add(decreaseButton); 
     } 
    } 
} 

est ici la version couramment:

using System.Windows; 
using System.Windows.Controls; 
using System.Windows.Shell; 
using FluentWpf; 

namespace TaskbarItemProgress 
{ 
    public partial class MainWindow : Window 
    { 
     public MainWindow() 
     { 
      InitializeComponent(); 

      TaskbarItemInfo = new TaskbarItemInfo(); 

      TaskbarItemInfo.ProgressValue = 0.5; 

      Content = new StackPanel() 
       .AddChildren(
        new Button() { Content = "Normal" } 
         .AddClick((s, e) => TaskbarItemInfo.ProgressState = TaskbarItemProgressState.Normal), 
        new Button() { Content = "Paused" } 
         .AddClick((s, e) => TaskbarItemInfo.ProgressState = TaskbarItemProgressState.Paused), 
        new Button() { Content = "Error" } 
         .AddClick((s, e) => TaskbarItemInfo.ProgressState = TaskbarItemProgressState.Error), 
        new Button() { Content = "Indeterminate" } 
         .AddClick((s, e) => TaskbarItemInfo.ProgressState = TaskbarItemProgressState.Indeterminate), 
        new Button() { Content = "None" } 
         .AddClick((s, e) => TaskbarItemInfo.ProgressState = TaskbarItemProgressState.None), 
        new Button() { Content = "Increase" } .AddClick((s, e) => TaskbarItemInfo.ProgressValue += 0.10), 
        new Button() { Content = "Decrease" } .AddClick((s, e) => TaskbarItemInfo.ProgressValue -= 0.10)); 
     } 
    } 
} 

La version couramment emploie deux méthodes d'extension, AddChildren (au lieu de Children.Add) et AddClick (au lieu de Click += ...).

Le programme ressemble à ceci:

Je garde mon personnel FluentWpflibrary on github.