Padrão de design da interface do usuário para Windows Forms (como MVVM para WPF)

O MVVM é mais comumente usado com o WPF porque é perfeitamente adequado para ele. Mas e o Windows Forms? Também existe um padrão de abordagem / design estabelecido e comumente usado como esse para o Windows Forms? Um que funciona explicitamente bem com o Windows Forms? Existe um livro ou um artigo que descreva isso bem? Talvez baseado em MVP ou MVC?

Eu tentei MVP e parece funcionar muito bem com o Windows Forms também. Este livro tem um exemplo de formulários do Windows com padrão MVP (aplicativo de folha de pagamento de amostra). O aplicativo não é tão complexo, mas lhe dará uma idéia de como proceder para criá-lo.

Princípios, padrões e práticas ágeis em C # ...

Você pode obter o código fonte em Source Code

EDITAR:

Existem duas variações do padrão MVP (a) visão passiva e (b) controlador de supervisão

Para cenários complexos de ligação de dados, prefiro seguir o padrão do controlador de supervisão. Na supervisão do padrão do controlador, a responsabilidade da ligação de dados é da visão. Portanto, para treeview / datagrid, isso deve estar nas respectivas visualizações, apenas a lógica agnóstica da visualização deve ser movida para o apresentador.

Recomendarei dar uma olhada na seguinte estrutura MVP MVC # - Uma estrutura MVP

Não use o nome (é uma estrutura MVP).

Vídeo simples do winforms MVP Winforms - MVP

Um exemplo de como lidar com a lista suspensa MVP - DropDownList

Exemplo simples de ligação em árvore (ligação do pobre homem). Você pode adicionar qualquer lógica específica da árvore em BindTree ().

Abaixo está o trecho de código .... não testado, digitado diretamente do pensamento ....

public interface IYourView
{
   void BindTree(Model model);
}

public class YourView : System.Windows.Forms, IYourView
{
   private Presenter presenter;

   public YourView()
   {
      presenter = new YourPresenter(this);
   }

   public override OnLoad()
   {
         presenter.OnLoad();
   }

   public void BindTree(Model model)
   {
       // Binding logic goes here....
   }
}

public class YourPresenter
{
   private IYourView view;

   public YourPresenter(IYourView view)
   { 
       this.view = view;
   }

   public void OnLoad()
   {
       // Get data from service.... or whatever soruce
       Model model = service.GetData(...);
       view.BindTree(model);
   }
}

Como já foi dito, sempre trabalhei em um padrão MVP ao usar o WinForms. Mas o padrão de design que você usará não significa que você usará corretamente. Há um monte de anti-padrão anexado ao MVP.

Se você deseja iniciar tudo de uma maneira boa, precisará usar a estrutura para criar o Smart Client. Portanto, recomendo usar esse design e práticas: Smart Client Software Factory http://www.codeplex.com/smartclient

Você tem uma discussão aqui sobre as estruturas atuais de smart clients: http://codebetter.com/blogs/glenn.block/archive/2008/05/10/prism-cab-and-winforms-futures.aspx

PS: Eu gosto deste post sobre os padrões anti-MVP: http://blog.mattwynne.net/2007/06/13/mvp-smells/

Espero que isto ajude

O Model-View-ViewModel (MVVM) padrão é um padrão de design. Por definição, um padrão de design mostra uma solução comum no mundo orientado a objetos e esta solução pode ser aplicada em várias plataformas (WPF, WinForms, Java Swing, etc.). Concordo que o MVVM é melhor usado com o WPF, porque aproveita os fortes recursos de ligação. No entanto, o Windows Forms também suporta ligação de dados.

O WAF Windows Forms Adapter mostra como aplicar o padrão MVVM em um aplicativo Windows Forms.

Eu escrevi sobre uma variação dos padrões de design do MVP / MVVM chamados MVP-VM, que é uma solução personalizada para aplicativos winforms que exigem cobertura completa de testes e usa a ligação de dados como mecanismo principal para manter a apresentação atualizada com os dados do modelo.

MVVM para .NET Winforms

O MVVM (Model View View Model) apresenta uma abordagem semelhante para separar a apresentação dos dados em um ambiente que capacita a ligação de dados (WPF). Como o .NET framework 2.0 já oferece uma infraestrutura avançada de ligação de dados que também permite a ligação em tempo de design de objetos de aplicativo - a entidade 'View Model' pode se encaixar muito bem no ambiente baseado em MVP.

Fiz a mesma pergunta a dois de meus colegas técnicos: o MVVM for WindowsForms é possível? Ambos me deram a mesma resposta exata: " De jeito nenhum! WindowsForms está faltando as ligações valiosas do WPF e Silverlight (OneTime, OneWay, TwoWay, OnWayToSource) e também está faltando os TypeConverters ."

• Screen Activator Pattern for WindowsForms - você pode encontrá-lo aqui , portado de Caliburn.Micro by jagui
• Rich Bindings e TypeConverters - Truss de Kent Boogaart, fazem isso de maneira independente da interface do usuário
• Comandos - O WPF Application Framework (WAF) possui um projeto WafWinFormsAdapter que cuida de algumas coisas do MVVM, ou seja, comandos

Novamente, podemos ter o MVVM for WinForms? Sim, nós podemos. Temos todas as peças. Nós apenas temos que colá-los juntos.

Acredito que o MVP é um padrão adequado ao desenvolvimento do WinForms - como é parcialmente evidenciado pelo uso no CAB - estrutura da Microsoft para o WinForms.

Eu uso o MVP no WinForms para extrair o código do modo de exibição - porque não consigo testar o código do modo de exibição. E também para permitir que o código que precisa ser reutilizado (ou duplicado) fique fora da visualização, onde não pode ser compartilhado.

Posso me referir ao meu próprio projeto em que uso o padrão MVP ExceptionReporter.NET . Embora tenha certeza de que não o uso perfeitamente.

Você mencionou o MVVM trabalhando para o WPF - acho que a razão disso é devido ao forte suporte à ligação de dados. Se você não estiver usando a ligação de dados no WPF (e certamente não é obrigatório), poderá escolher o MVP. O ponto é que o MVP é uma escolha forte para qualquer aplicativo do lado do cliente. E, possivelmente, uma opção 'melhor', mesmo no WPF, se você planeja compartilhar código entre projetos que não são WPF.

Para obter mais evidências do valor do uso do MVP no WinForms, consulte a apresentação em vídeo da Boodhoo sobre o uso do MVP: http://www.bestechvideos.com/2008/06/29/dnrtv-show-14-jean-paul-boodhoo-on-model -view-apresentador E um artigo do MSDN do mesmo autor em http://msdn.microsoft.com/en-us/magazine/cc188690.aspx

O método BindTree parece um pouco defeituoso para mim. De repente, o the View conhece o modelo. Isso é uma coisa boa? Deve haver toneladas de pessoas sendo confrontadas com esse tipo de problema. Estou surpreso que não haja nenhum livro sobre isso. Como existem livros sobre tudo no mundo .NET.

Eles não se destinam a ocultar o modelo, mas a definir com precisão as interações entre as diferentes camadas dos aplicativos. Você pode alterar completamente o back-end e, desde que passe um modelo pelo Bindtree, sua interface continuará funcionando.

Agora, a classe Model pode ser uma má escolha de um nome no exemplo que Rajesh fornece. Pode ser TreeData ou RecordsData. No entanto, você define o que você precisa para usar o mecanismo de ligação do Winforms para vincular um controle específico aos dados subjacentes.

O melhor site para procurar esse tipo de material é aqui . Martin Fowler coletou uma variedade de padrões de design de interface do usuário úteis e padrões de design corporativo.

Novamente, a chave para isso é o uso de interfaces para definir com precisão como cada camada interage.

Em meu próprio aplicativo (aplicativos CAD / CAM usados ​​para executar máquinas de corte de metal), minha estrutura fica assim.

• Formulários implementando interfaces de formulário
• UIDLL com visualizações implementando interfaces de visualização que interagem com os formulários por meio da interface do formulário. As visualizações específicas se registram com UIViewDLL Views executa objetos de comando encontrados em bibliotecas de comandos que interagem com o modelo.
• Bibliotecas de comandos; listas de comandos que implementam o ICommand. O comando que interage com as visualizações o faz por meio das interfaces expostas no UIViewDLL.
• UIViewDLL; expõe as interfaces de exibição usadas pelos comandos.
• Modelo; as classes e a coleção que compõem as estruturas de dados principais do meu aplicativo. Para mim, são coisas como material, caminhos de corte, formas, lençóis, tochas, etc.
• Utilitário; uma DLL que geralmente usa classes de utilitário usadas por minha empresa que abrangem aplicativos diferentes. Por exemplo, funções matemáticas complexas.

Você pode usar Arquitetura, Padrões e Práticas Corporativas como ponto de partida, embora estejam um pouco desatualizados.

Em Orientação Geral, existe a Arquitetura de Aplicativos para .NET: Design de Aplicativos e Serviços , que é uma boa introdução às formas do .NET e aos aplicativos de camadas N em camadas.

texto alternativo http://i.msdn.microsoft.com/ms954595.f00aa01%28en-us%2CMSDN.10%29.gif

Para "padrões" mais formais, existe o Enterprise Solution Patterns usando o Microsoft .NET . _{(fonte: microsoft.com )}

Para nomear alguns,

• Model-View-Controller
• Filtro Interceptador
• Aplicativo de serviços em três camadas

A primeira boa explicação dos padrões de design de interface do usuário que li foi no blog de Jeremy Miller - Construindo seu próprio CAB . Ele descreve os padrões comuns - Visualização Passiva, MVP, etc. e aborda algumas das maneiras pelas quais você pode implementá-los em C #.

Você pode experimentar o MugenMvvmToolkit que permite usar um "MVVM puro" para o WinForms. Devido ao fato de suportar ligações em todas as plataformas, todos os recursos nativos de ligação disponíveis para a plataforma WPF estão disponíveis em todas as plataformas (incluindo WinForms).