O PDC deste ano é todo acerca da cloud (núvem – ou nebulosa, como eu lhe chamo) e a .NET Framework 4.0.

Ninguém da Microsoft me disse que os Windows Forms tinham os dias contados (antes pelo contrário) mas, olhando para  lista de sessões do PDC deste ano, só vejo WPF.

Portanto, a questão mantem-se: Será o fim dos Windows Forms?

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

Esta versão adiciona o suporte para métodos estáticos e metódos não públicos à API AAA. Vejam as notas de lançamento.

Não me agrada muito a aproximação reflectiva ao teste de membros privados.

Com as novas adicões à API AAA, testar esta classe:

public class MyClass
{
    public string Public()
    {
        return this.Private();
    }

    private string Private()
    {
        throw new NotImplementedException();
    }
}

pode ser feito assim:

[TestMethod]
[Isolated]
public void PrivateTest()
{
    MyClass fake = Isolate.Fake.Instance<MyClass>();

    Isolate.WhenCalled(() => fake.Public()).CallOriginal();

    Isolate.NonPublic.WhenCalled(fake, "Private").WillReturn("FAKE");

    string fakePublic = fake.Public();

    Assert.AreEqual("FAKE", fakePublic);

    Isolate.Verify.WasCalledWithExactArguments(() => fake.Public());

    Isolate.Verify.NonPublic.WasCalled(fake, "Private");
}

Agradava-me mais que fosse assim:

[TestMethod]
[Isolated]
public void PrivateTest()
{
    MyClass fake = Isolate.Fake.Instance<MyClass>();

    MyClass_Accessor fakeAccessor = MyClass_Accessor.AttachShadow(fake);

    Isolate.WhenCalled(() => fakeAccessor.Private()).WillReturn("FAKE");

    Isolate.WhenCalled(() => fake.Public()).CallOriginal();

    string fakePublic = fake.Public();

    Assert.AreEqual("FAKE", fakePublic);

    Isolate.Verify.WasCalledWithExactArguments(() => fake.Public());

    Isolate.Verify.WasCalledWithExactArguments(() => fakeAccessor.Private());
}

Parece a mesma coisa mas não há nomes de métodos no código de teste.

Eles conseguiram fazê-lo para os Natural Mocks. Certamente que o conseguirão fazer para AAA.

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

Há algum tempo perguntaram-me se seria possível forjar parâmetros de saída usando o Typemock Isolator.

Na verdade é muito fácil de o fazer usand qualquer uma das APIs disponíveis.

Dada esta classe:

public class MyClass
{
    public bool MyMethod(string input, out int output1, out double output2)
    {
        throw new NotImplementedException();
    }
}

Usando a nova API AAA, é tão limpo omo:

[TestMethod]
[Isolated]
public void TestMethodIsolated()
{
    MyClass target = Isolate.Fake.Instance<MyClass>();

    string input = "test value";
    int expectedOutput1 = 1;
    double expectedOutput2 = 2;

    Isolate.WhenCalled(() => target.MyMethod(input, out expectedOutput1, out expectedOutput2)).WillReturn(true);

    int output1;
    double output2;
    bool result = target.MyMethod(input, out output1, out output2);

    Assert.IsTrue(result);
    Assert.AreEqual<int>(expectedOutput1, output1);
    Assert.AreEqual<double>(expectedOutput2, output2);
}

Usando Natural Mocks, é tão fácil como:

[TestMethod]
[VerifyMocks]
public void TestMethodNatural()
{
    MyClass target = RecorderManager.CreateMockedObject<MyClass>();

    string input = "test value";
    int expectedOutput1 = 1;
    double expectedOutput2 = 2;

    using (RecordExpectations recorder = RecorderManager.StartRecording())
    {
        recorder.ExpectAndReturn(target.MyMethod(input, out expectedOutput1, out expectedOutput2), true);
    }

    int output1;
    double output2;
    bool result = target.MyMethod(input, out output1, out output2);

    Assert.IsTrue(result);
    Assert.AreEqual<int>(expectedOutput1, output1);
    Assert.AreEqual<double>(expectedOutput2, output2);
}

Também é possível usando Reflective Mocks:

[TestMethod]
[VerifyMocks]
public void TestMethodReflective()
{
    MockObject<MyClass> targetMock = MockManager.MockObject<MyClass>();

    string input = "test value";
    int expectedOutput1 = 1;
    double expectedOutput2 = 2;

    targetMock.ExpectAndReturn(
        "MyMethod",
        new DynamicReturnValue(delegate(object[] parameters, object context)
            {
                parameters[1] = expectedOutput1;
                parameters[2] = expectedOutput2;
                return true;
            }));

    int output1;
    double output2;
    bool result = targetMock.Object.MyMethod(input, out output1, out output2);

    Assert.IsTrue(result);
    Assert.AreEqual<int>(expectedOutput1, output1);
    Assert.AreEqual<double>(expectedOutput2, output2);
}

Só é preciso escolher a API de que se gosta mais.

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

O SAPO Codebits 2008 está aí. Inscrevam-se.

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

Mais uma vez estarei numa banca ATE no Tech·Ed EMEA 2008 Developers.

tal como já tinha dito acerca do PDC, o que gosto mais destes eventos é a convivência com as pessoas da Microsoft e com os outros participantes. Portanto, se se quiserem encontrar comigo, terei muito gosto em encontrar-me convosco.

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

O Luís acabou de dar a notícia acerca do nosso livro sobre LINQ com C#.

Foi com enorme honra que aceitei o convite do Luís para escrever este livro para a FCA, para quem ele já tinha publicado alguns livros [^] [^] [^].

Este será um livro de introdução em Português dirigido a quem quiser aprender LINQ com C#.

Tem sido um projecto divertido com grandes discuções (possíveis apenas porque meio oceano nos separa :) ).

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

Não é a primeira vez que tento mas, por uma razão ou outra, esta é a primeira vez que vou ao PDC (Microsoft’s Professional Developers Conference).

De acordo com o sítio do evento, “O PDC é projectado para arquitectos de software e programadores avançados. Se estão interessados no futuro da plataforma Microsoft, se são responsáveis pela estratégia tecnológica a vossa organização ou se são profissionais altamente qualificados que gostam de mergulhar o coração da plataforma, então o PDC é para vós!”. Se se revêm nesta descrição, não percam tempo e registem-se. O desconto Early Bird foi extendido até 8 de Setembro.

O que gosto mais destes eventos é a convivência com as pessoas da Microsoft e com os outros participantes. Portanto, se se quiserem encontrar comigo, terei muito gosto em encontrar-me convosco.

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

Se proucuram conteúdos técnicos em Português sobre tecnologias Microsoft, visitem o Pakua FeedCenter.

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

O Clone Detective é uma ferramenta que integra com o Visual Studio e usa o ConQAT (Continuous Quality Assessment Toolkit) para analizar projectos C# e procurar código fonte duplicado.

Vejam os vídeos e vejam se esta é a ferramenta que procuravam.

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

A Microsoft Press criou  um URL exclusivo para um desconto na subscrição da E-Reference Library para os MVPs passarem à comunidade, sem quaisquer limitações ou restrições.

Para criar uma subscrição experimental, deve ser usado o URL Experimental (http://microsofteref2.books24x7.com/promo.asp?ref=mvptry).

Qualquer membro da comunidade que subscreva a E-Reference Libraries através do URL de Subscrição (http://microsofteref2.books24x7.com/promo.asp?ref=mvpbuy) terá direito a um desconto de 40% numa subscrição de um ano.

Esta oferta termina a 30 de Setembro de 2008.

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

A equiopa do StyleCop anunciou a saída da versão 4.3 da ferramenta StyleCop. Podem obtê-la aqui.

Esta versão contem algumas correcções de erros, novas regras e documentação.

Também nesta versão, a lista de erros e avisos vai para a janela Errors List como acontece com os compiladores. Gostava que os erros e avisos também fossem para a janela Output.

A documentação do SDK para o desenvolvimento de regras próprias e integração com outros sistemas de build é esperada para breve.

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

Convenhamos, quem não conhece o .NET Reflector não pode afirmar que desenvolve em .NET.

Hoje, a Red Gate anunciou a aquisição do Lutz Roeder’s .NET Reflector.

Na nova página do .NET Reflector, a Red Gate afirma que “continuará a manter uma versão gratuita para o benefício da comunidade”.

Podem ler a entrevista com Lutz Roeder e James Moore (director geral de ferramentas de desenvolvimento .NET da Red Gate) na simple-talk.

O James ainda não sabe como melhorar o Reflector, mas eu sei. O Reflector necessita de importantes melhoramentos ao nível da usabilidade da interface com o utilizador. Vejamos se consigo arranjar uma lista:

• Para mim, a pesquisa enquanto se digita não é uma boa ideia tal como está no Reflector.
• Ainda no tema da pesquisa, pesquisa enquanto se digita já seria uma boa ideia para a janela de código.
• Não consigo perceber porque mudar alguma opção dispara um refrescamento total da aplicação perdendo-se a janela de código.
• Definições como a formatação de código, documentação ou números deveria ser possível apenas com o simples premir de um botão numa barra de botões.

Tenho a certeza que a Red Gate é mais do que capaz de tomar bem conta do .NET Reflector.

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

A Typemock lançou uma versão alfa do seu mais recente produto: Typemock Racer.

O Typemock Racer é a ferramenta que usa análise dinâmica e estática para encontrar bloqueios em código .NET que tinha sido anuncianda pelo Roy Osherove.

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

A Typemock lançou a versão 5.0 da sua ferramenta de testes unitários: Isolator. Vejam as notas de lançamento.

Esta mais recente versão vem com a nova API: Arrange Act Assert (Preparar – Executar - Validar):

• Isolator AAA API - The Basics
• Isolator AAA: Creating Fakes

Devo dizer que gostava mais de Isolator do que Isolate.

Também novidade nesta versão é a inclusão do ficheiro de ajuda no pacote de instalação.

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

Enquanto instalava o SQL Server 2008 numa máquina virtual Virtual PC, fiquei sem espaço no disco virtual.

Pesquisei e encontrei esta ferramenta: VHD Resizer. É necessário registo para descarregar a ferramenta.

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

Microsoft .NET Framework 3.5 Service Pack 1

Microsoft Visual Studio 2008 Service Pack 1 (iso)

Visual Studio 2008 Team Foundation Server Service Pack 1

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

No passado apresentei um outro possível uso para a palavra-chave using: como dicas LINQ.

Tenhno vindo a pensar mais neste assunto e refinei a minha proposta.

var q = from person in personCollection using MyEnumerableExtensions
        group person by person.LastName into g using new MyOtherComparer()
        orderby g.Key using new MyComparer()
        select person;

A consulta acima seria traduzida para:

var q = MyEnumerableExtensions.OrderBy<string, Person>(
    MyEnumerableExtensions.GroupBy<string, Person>(
        personCollection,
        person => person.LastName,
        new MyComparer(),
    ),
    g => g.Key,
    mew MyOtherComparer()
);

O que acham disto?

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

O C# 3.0 introduziu inicializadores de object and collection. É agora possível criar objectos e colecções pré-inicializados:

var person = new Person { FirstName = "Paulo", LastName = "Morgado" };

var persons = new List<Person> {
    new Person { FirstName = "Paulo", LastName = "Morgado" },
    new Person { FirstName = "Luís", LastName = "Abreu" }
};

var personDirectory = new Dictionary<string, Person> {
    { "Lisboa", new Person { FirstName = "Paulo", LastName = "Morgado" } },
    { "Funchal", new Person { FirstName = "Luís", LastName = "Abreu" } }
};

Não era bom podermos fazer o mesmo para objectos e colecções já existentes?

Que sintaxe seria usada? Algo deste género?

var person = new Person();
person = { FirstName = "Paulo", LastName = "Morgado" };

var persons = new List<Person>();
persons += {
    new Person { FirstName = "Paulo", LastName = "Morgado" },
    new Person { FirstName = "Luís", LastName = "Abreu" }
};

var personDirectory = new Dictionary<string, Person>();
personDirectory += {
    { "Lisboa", new Person { FirstName = "Paulo", LastName = "Morgado" } },
    { "Funchal", new Person { FirstName = "Luís", LastName = "Abreu" } }
};

O que pensam disto?

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

De acordo com a página inicial das MSDN Subscriptions, devemos esperar que o Service Pack 1 do Visual Studio 2008 esteja disponível após o próximo dia 11 de Agosto de 2008.

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

Finalmente está aí o SQL Server 2008 e vem com a Entity Framework, o que quer dizer que o SP1 para o Visual Studio 2008 e a .NET Framework também deve estar a saír.

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

O ASP.NET disponibiliza três tipos de armazenamento de estado de sessao:

Porque com o SQLServer e o StateServer o estado tem de atravessar a fronteira do AppDomain, tem de ser seriado antes de ser armazenado e desseriado quando carregado. Porque o estado tem de ser carregado e armazenado em cada pedido, só está disponível desde o evento PostAcquireRequestState até ao evento ReleaseRequestState. E, devido à seriação e desseriação, todos os objectos armazenados têm de ser seriáveis e qualquer referência mantida para um item do estado não será para o mesmo item após a desseriação do estado.

Por outro lado, com o InProc, o estado nunca será seriado ou desseriado, o que quer dizer que os objectos não necessitam de ser seriáveis e qualquer referência para um item do estado será sempre uma referência para um item do estado mesmo antes do evento PostAcquireRequestState e após o evento ReleaseRequestState.

Na prática, durante o desenvolvimento é usado o InProc e em produção é usado o SQLServer. Isto leva, muitas vezes, a erros aplicacionais que apenas se manifestam em ambiente de produção, com armazenar objectos não seriáveis no estado. Foi por isso que escrevi um provedor de armazenamento de estado em memória que seria e desseria os itens armazenados. Podem obter o código fonte aqui.

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]

(Isto foi-me referido pelo Frans Bouma e explicado pelo Jon Skeet)

Imaginem este conjunto de classes:

public class A
{
    public virtual string P
    {
        get { return "A"; }
    }
}

public class B : A
{
}

public class C : B
{
    public override string P
    {
        get { return "C"; }
    }
}

E esta classe:

public static class Reporter
{
    public static void Report<T>(T target, Expression<Func<T, string>> expression)
    {
        Console.WriteLine("Expression: {0}", expression);
        Console.WriteLine("\tDeclaring Type: {0}", ((expression as LambdaExpression).Body as MemberExpression).Member.DeclaringType);
        Console.WriteLine("\tInvocation Result: {0} for {1}", expression.Compile().Invoke(target), target.GetType());
        Console.WriteLine();
    }
}

A classe acima escreve na consola a expressão Lambda, o tipo que declara a propriedade e o valor da propridedade para target e o tipo de target.

Vejamos o que acontece quando é usado o seguinte código C#:

Reporter.Report(new C(), (A a) => a.P);
Reporter.Report(new C(), (B b) => b.P);
Reporter.Report(new C(), (C c) => c.P);

Reporter.Report(new B(), (A a) => a.P);
Reporter.Report(new B(), (B b) => b.P);

Reporter.Report(new A(), (A a) => a.P);

O resultado será:

Expression: a => a.P
        Declaring Type: A
        Invocation Result: C for C

Expression: b => b.P
        Declaring Type: A
        Invocation Result: C for C

Expression: c => c.P
        Declaring Type: A
        Invocation Result: C for C

Expression: a => a.P
        Declaring Type: A
        Invocation Result: A for B

Expression: b => b.P
        Declaring Type: A
        Invocation Result: A for B

Expression: a => a.P
        Declaring Type: A
        Invocation Result: A for A

Por outro lado, se for usado o seguinte código Visual Basic:

Reporter.Report(New C(), Function(a As A) a.P)
Reporter.Report(New C(), Function(b As B) b.P)
Reporter.Report(New C(), Function(c As C) c.P)

Reporter.Report(New B(), Function(a As A) a.P)
Reporter.Report(New B(), Function(b As B) b.P)

Reporter.Report(New A(), Function(a As A) a.P)

O resultado será:

Expression: a => a.P
        Declaring Type: A
        Invocation Result: C for C

Expression: b => b.P
        Declaring Type: A
        Invocation Result: C for C

Expression: c => c.P
        Declaring Type: C
        Invocation Result: C for C

Expression: a => a.P
        Declaring Type: A
        Invocation Result: A for B

Expression: b => b.P
        Declaring Type: A
        Invocation Result: A for B

Expression: a => a.P
        Declaring Type: A
        Invocation Result: A for A

Porquê as diferenças? Por causa das diferenças nas especificações e compiladores das diferentes inguagens:

• O compilador de C# gerará uma chamada virtual ao membro virtual na classe em que é declarado como virtual.
• O compilador de Visual Basic gerará uma chamada virtual ao membro sobreposto na classe em que é implementado.

[Cross-Posted de http://www.arquitecturadesoftware.org/blogs/paulomorgado/]