• “Programing Windows Phone 7″ (PDF grátis disponível) – http://www.charlespetzold.com/phone/
• Beginning Windows Phone 7 Development (Books for Professionals by Professionals)
• Professional Windows Phone 7 Application Development: Building Applications and Games Using Visual Studio, Silverlight, and XNA (Wrox Programmer to Programmer)

Training Kits

• Windows Phone 7 Training Kit for Developers – RTM

O conteúdo da prova ainda não foi divulgado, entrei em contato com a microsoft e obtive a resposta que em até 2 semanas a página estará disponível pelo endereço http://www.microsoft.com/learning/en/us/exam.aspx?ID=70-599&locale=en-us

[UPDATE] Página com conteúdo do exame já está disponível

<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. Requisitos:

• Prism v4 para Windows Phone 7

Crie um novo projeto utilizando o template Windows Phone Application, e coloque o nome de CommandWP7. Com nosso projeto criado adicione um botão à MainPage.xaml

<!--ContentPanel - place additional content here-->
        <Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
            <Button Content="Botão com Command" HorizontalAlignment="Center" VerticalAlignment="Center"/>
        </Grid>

No WP7 por enquanto não temos uma propriedade Command e CommandParameter como no silverlight e wpf, então teremos que utilizar um Behavior para nosso command funcionar. Adicione a referência ao assembly System.Windows.Interactivity ao seu projeto e coloque no seu xaml o uso deste assembly

xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"

e modificaremos o código do nosso button para

            <Button Content="Botão com Command" HorizontalAlignment="Center" VerticalAlignment="Center">
                <i:Interaction.Behaviors>

                </i:Interaction.Behaviors>
            </Button>

Agora teremos que criar o nosso ButtonCommand que será uma implementação de um beehavior que irá fazer o binding do nosso botão com o comando no ViewModel, adicione a referência ao assembly Microsoft.Practices.Prism e Microsoft.Practices.Prism.Interactivity, crie uma nova classe e dê o nome de ButtonCommand.

    public class ButtonCommand : Behavior<Button>
    {
        public static readonly DependencyProperty CommandParameterBindingProperty =
            DependencyProperty.Register("CommandParameterBinding", typeof(Binding), typeof(ButtonCommand), new PropertyMetadata(HandleBindingChanged));

        public static readonly DependencyProperty CommandBindingProperty =
            DependencyProperty.Register("CommandBinding", typeof(Binding), typeof(ButtonCommand), new PropertyMetadata(HandleBindingChanged));

        private readonly BindingListener commandBindinglistener;
        private readonly BindingListener parameterBindinglistener;
        private ButtonClickCommandBinding binding;

        public ButtonCommand()
        {
            this.commandBindinglistener = new BindingListener(this.HandleCommandBindingValueChanged);
            this.parameterBindinglistener = new BindingListener(this.HandleCommandParameterBindingValueChanged);
        }

        public Binding CommandBinding
        {
            get { return (Binding)GetValue(CommandBindingProperty); }
            set { SetValue(CommandBindingProperty, value); }
        }

        public Binding CommandParameterBinding
        {
            get { return (Binding)GetValue(CommandParameterBindingProperty); }
            set { SetValue(CommandParameterBindingProperty, value); }
        }

        protected ICommand Command { get; set; }

        protected object CommandParameter { get; set; }

        protected override void OnAttached()
        {
            this.commandBindinglistener.Element = this.AssociatedObject;
            this.parameterBindinglistener.Element = this.AssociatedObject;
            this.CreateBinding();
            base.OnAttached();
        }

        protected override void OnDetaching()
        {
            this.commandBindinglistener.Element = null;
            this.parameterBindinglistener.Element = null;
            base.OnDetaching();
        }

        protected void OnBindingChanged(DependencyPropertyChangedEventArgs e)
        {
            if (e.Property == CommandBindingProperty)
            {
                this.commandBindinglistener.Binding = (Binding)e.NewValue;
            }

            if (e.Property == CommandParameterBindingProperty)
            {
                this.parameterBindinglistener.Binding = (Binding)e.NewValue;
            }

            this.CreateBinding();
        }

        private static void HandleBindingChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            ((ButtonCommand)sender).OnBindingChanged(e);
        }

        private void HandleCommandBindingValueChanged(object sender, BindingChangedEventArgs e)
        {
            this.CreateBinding();
        }

        private void HandleCommandParameterBindingValueChanged(object sender, BindingChangedEventArgs e)
        {
            this.CreateBinding();
        }

        private void CreateBinding()
        {
            if (this.commandBindinglistener.Value != null)
            {
                if (this.binding != null)
                {
                    this.binding.Detach();
                }

                this.binding = new ButtonClickCommandBinding(
                    this.AssociatedObject,
                    (ICommand)this.commandBindinglistener.Value,
                    () => this.parameterBindinglistener.Value);
            }
        }

        public class ButtonClickCommandBinding
        {
            private readonly ICommand command;
            private readonly Button button;
            private readonly Func<object> parameterGetter;

            public ButtonClickCommandBinding(Button button, ICommand command, Func<object> parameterGetter)
            {
                this.command = command;
                this.button = button;
                this.parameterGetter = parameterGetter;

                this.command.CanExecuteChanged += this.CommandCanExecuteChanged;
                this.button.Click += this.IconButtonClicked;
                this.button.IsEnabled = this.command.CanExecute(this.parameterGetter());
            }

            public void Detach()
            {
                this.button.Click -= this.IconButtonClicked;
                this.command.CanExecuteChanged -= this.CommandCanExecuteChanged;
            }

            private void IconButtonClicked(object s, EventArgs e)
            {
                this.command.Execute(this.parameterGetter());
            }

            private void CommandCanExecuteChanged(object s, EventArgs ea)
            {
                this.button.IsEnabled = this.command.CanExecute(this.parameterGetter());
            }
        }
    }

Faça o build do projeto e volte ao nosso botão. Teremos que adicionar o namespace do projeto em nosso xaml

xmlns:local="clr-namespace:CommandWp7"

e então adicionar o nosso behavior de command ao nosso botão fazendo o binding para o comando no viewmodel.

            <Button Content="Botão com Command" HorizontalAlignment="Center" VerticalAlignment="Center">
                <i:Interaction.Behaviors>
                    <local:ButtonCommand CommandBinding="{Binding ViewCommand}"/>
                </i:Interaction.Behaviors>
            </Button>

Para criar o ViewModel, crie uma nova classe  e coloque o nome de MainPageViewModel

public class MainPageViewModel
    {

        public DelegateCommand ViewCommand { get; set; }

        public MainPageViewModel()
        {
            this.ViewCommand = new DelegateCommand(ViewCommandInvoke);
        }

        public void ViewCommandInvoke()
        {
            MessageBox.Show("Comando executado com sucesso");
        }

    }

e por último no MainPage.xaml.cs setamos o DataContext da view para o viewModel

    public partial class MainPage : PhoneApplicationPage
    {
        // Constructor
        public MainPage()
        {
            InitializeComponent();
            this.DataContext = new MainPageViewModel();
        }
    }

agora é só executar. O codigo fonte pode ser baixado aqui.

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.

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!

Antes de começar faça o download do CTP 4.

• Abra o Visual Studio 2010
• File –> New –> New Project
• Selecione “Windows” no menu à esquerda e depois “Console Application”
• Digite PocoEF4 como nome do projeto

Com a nossa solução criada, criaremos mais dois projetos para o domínio e a persistência.

1. Com o botão direito do mouse clique em Add –> New Project
2. Selecione “Class Library”
3. Digite Dominio no nome do projeto.
4. Repita os passos 1 e 2 e coloque o nome do projeto como Persistencia

Após adicionar os projetos sua solução deve parecer como na imagem abaixo:

Vamos então criar o nosso domínio com as classes POCO. No projeto domínio crie duas classes com os nomes Blog e Post conforme o código abaixo

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; }
}

Para começar a utilizar o CTP 4 adicione a referência ao assembly Microsoft.Data.Entity.Ctp na tab .Net e adicione também o assembly System.Data.Entity.

Criado o domínio, temos que criar agora o contexto de dados. Crie uma classe no projeto Persistencia com o nome BlogContext conforme o código abaixo

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; }
}

Por último configure a conexão com o banco de dados, segue um exemplo abaixo

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

Acessando os dados

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();
        }
    }
}

Agora já podemos rodar o programa e verificar que um novo blog foi adicionado.

No próximo post irei explicar mais detalhadamente sobre o DbContext e o ModelDiscovery. Até a próxima

No final de junho 3 estudantes (Patrick Boos, Michael Gfeller e Silvan Gehrig) apresentaram seu projeto de bacharelado esta incível ferramenta utilizando o TFS, Scrum e Microsoft Surface. Foram utilizadas as tecnologias:

• C# e WPF
• Microsoft Surface SDK 1.0
• Team Foundation Server 2010
• Scrum

Veja o vídeo abaixo: