AndrePassos.net

Sorry, this entry is only available in Português.

O padrão MVVM (Model-View-ViewModel) é uma especialização do padrão Presenter porém utilizando capacidades específicas de Silverlight e WPF como data binding, command e behaviors. O MVVM é semelhante a muitos outros padrões que separam a camada de apresentação da camada de lógica, sendo assim toda a lógica de negócio pode ser programada para qualquer tipo de interface XAML.

Utilizando MVVM o código da sua view irá ficar totalmente limpo e muito mais fácil de dar manutenção. Sem utilizar MVVM o simples clique de um botão é definido da seguinte forma:

<Button Click="Button_Click" />

private void Button_Click(object sender, RoutedEventArgs e)        {

        }

Mas qual o problema desta abordagem? Bom dou um bom exemplo: Você está desenvolvendo um sitema que tem um cliente Desktop WPF e um cliente móvel em WP7. Se os códigos estiverem todos nas views, terá que recodificar tudo em cada cliente. Com a utilização dos viewModels, você irá codificar esta ação uma única vez tanto para WPF quando para WP7. Deixando a teoria de lado, vamos por a mão na massa.

Read more…

Um problema que me deparo constantemente é a necessidade de abrir um ChildWindow qualquer e continuar a execução do código a partir do retorno deste. Claro que é possível fazer isto utilizando Actions e eventos, mas não seria muito melhor que trabalhasse de forma semelhante ao MessageBox do WinForms?

Antes de começar é necessário instalar o Visual Studio Async CTP pois ele nos da a possibilidade de trabalhar de forma Assíncrona/Síncrona.

Primeiro criaremos um novo projeto com o template Silverlight Application. Dentro do projeto crie um novo item utilizando o template ChildWindow, e de-lhe o nome de ChildWindowSync.

Criaremos então um método estático que será responsável por mostrar a nossa window conforme o código abaixo:

        public static Task<bool> ShowSync()        {            var tcs = new TaskCompletionSource<bool>();            var window = new ChildWindowSync();            window.Closed += (sender, e) => {                tcs.TrySetResult(window.DialogResult.Value);            };            window.Show();            return tcs.Task;        }

Veja que é bastante simples, criamos um objeto TaskCompletionSource que será a task retornada quando nossa window for fechada, após este passo a janela é criada e adicionamos um eventHandler ao evento de closed. Dentro deste handler setamos o dialogResult que foi definido pelos métodos de button click do Ok e Cancel;

Neste momento seu código deve estar parecido com o abaixo:

    public partial class ChildWindowSync : ChildWindow    {        public ChildWindowSync()        {            InitializeComponent();        }

        private void OKButton_Click(object sender, RoutedEventArgs e)        {            this.DialogResult = true;        }

        private void CancelButton_Click(object sender, RoutedEventArgs e)        {            this.DialogResult = false;        }

        public static Task<bool> ShowSync()        {            var tcs = new TaskCompletionSource<bool>();            var window = new ChildWindowSync();            window.Closed += (sender, e) => {                tcs.TrySetResult(window.DialogResult.Value);            };            window.Show();            return tcs.Task;        }    }

Agora criaremos um botão na MainPage.xaml que irá chamar nossa ChildWindowSync.

<UserControl x:Class="SilverlightApplication2.MainPage"    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"    mc:Ignorable="d"    d:DesignHeight="300" d:DesignWidth="400">

    <Grid x:Name="LayoutRoot" Background="White">        <Button x:Name="testebtn" Content="Open window" Click="testebtn_Click"                VerticalAlignment="Center" HorizontalAlignment="Center"/>    </Grid></UserControl>

O async ctp exige que seja utilizado a palavra reservada "async" nos métodos que utilizam chamadas assíncronas em seu corpo. No caso a assinatura do método testbtn_Click fica da seguinte forma:

private async void testebtn_Click(object sender, RoutedEventArgs e)

então colocamos o corpo do nosso método para esperar ate que a childWindow seja fechada e retornar se o DialogResult foi True ou False

private async void testebtn_Click(object sender, RoutedEventArgs e)        {            bool teste = await ChildWindowSync.ShowSync();            if (teste)            {                MessageBox.Show("Você Clicou em Ok!");            }            else            {                MessageBox.Show("Você clicou em Cancel!");            }        }

Rode a aplicação e veja o resultado. Você verá que ao clicar no nosso botão de teste a child window é exibida e o resultado é exibido somente depois da janela ter um resultado: true se for clicado em Ok e False se for clicado em Cancel ou fechar a janela pelo X.

O código fonte deste exemplo pode ser baixado aqui.

2011 começa com boas notícias! Após muito tempo sem postar nada, venho compartilhar minha alegria ao ser aprovado com a pontuação de 900/1000 na minha primeira certificação microsoft.

A prova achei um pouco mais difícil que a prova beta, mas nada muito complicado, qualquer pessoa que utilize silverlight no dia a dia consegue ser aprovado.

Sobre as questões vi muita coisa sobre layout e perguntas específicas de controles básicos como TextBox, ComboBox e Grid, eventos e eventos roteados, muito pouco sobre Binding e Command além de 2 questões sobre ClientAccessPolice e mais umas duas sobre WCF.

No geral a prova ficou bem dividida e abordando todos os assuntos divulgados no site do exame.

Quem estiver interessado em estudar para esta prova, é uma leitura quase que obrigatória o livro “Pro Silverlight 4” da Apress.

Próxima prova… 70-516!

“Beta” of this blog, I did a post showing how to use the POCO (Plain Old CLR Object) and the new features available in CTP Feature 4 for ADO.Net Entity Framework. But I decided to rewrite the post to better explain each feature and go deeper with each post.

Before you start to download the April CTP.

* Open the Visual Studio 2010
* File -> New -> New Project
* Select “Windows” in the left menu and then “Console Application”
* Enter the project name as PocoEF4

With our solution set, we create two more projects for the domain and persistence.

1. With the right mouse button click Add -> New Project
2. Select “Class Library”
3. Domain Enter the name of the project.
4. Repeat steps 1 and 2 and put the project name as Persistence

After adding the projects your solution should look like the image below:

Let us create our domain classes POCO. In the project area to create two classes of names as the blog and post code below

public class Blog
{
    public virtual Guid ID { get; set; }
    public virtual string BlogName { get; set; }
    private IList<post> _Posts = new List<post>(); 

    public virtual IList<post> Posts
    {
        get { return _Posts; }
        set { _Posts = value; }
    }
}

public class Post
{
    public virtual Guid ID { get; set; }
    public virtual Blog Blog { get; set; }
    public virtual string PostTitle { get; set; }
}

To start using the CTP 4 add reference to assembly Microsoft.Data.Entity.Ctp the tab. Net and also add the assembly System.Data.Entity.

Created the field, we must now create the data context. Create a Persistence class in the project named as the code below BlogContext

using System.Data.Entity;

public class BlogContext : DbContext
{
    public BlogContext() : base(ConfigurationManager.ConnectionStrings["BlogConnection"].ConnectionString)
    {
    }
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post>
 Posts { get; set; }
}

Finally configure the connection to the database, an example follows below

<configuration>
  <connectionStrings>
    <add name="BlogConnection" connectionString ="Data Source=.\;Initial Catalog=Blog;Integrated Security=SSPI;" providerName ="System.Data.SqlClient.SqlConnection"/>
  </connectionStrings>
</configuration>

Accessing Data

class Program
{
    static void Main(string[] args)
    {
        using (var context = new BlogContext())
        {
            var blog = new Blog { ID = Guid.NewGuid(), BlogName = "AndrePassos.net" };
            context.Blogs.Add(blog);
            int rows = context.SaveChanges();

            Console.WriteLine("{0} entidades atualizadas no banco de dados", rows);
            Console.ReadKey();
        }
    }
}

Now we can run the program and verify that a new blog was added.

In the next post’ll explain in more detail about the DbContext, and ModelDiscovery. Until next time

This week visiting some blogs on the Internet I came across this amazing video showing the strength of SCRUM on the Microsoft platform. Recently launched the Visual Studio 1.0 Scrum is a template for use in Team Foundation Server 2010 that applies all the directives of SCRUM vision of your project.

In June, three students (Patrick Boos, Michael Gfeller and Silvan Gehrig) presented the Bachelor Project of this amazing tool using TFS, Scrum and Microsoft Surface. They were developed using:

* C # and WPF
* Microsoft Surface SDK 1.0
* Team Foundation Server 2010
* Scrum

See the video below: