Blog Novo

Pessoal,

Recentemente fui contratado pela Microsoft para trabalhar como Premier Field Engineer.

Criei um blog novo em http://blogs.msdn.com/dfaoliveira. Vou passar a postar somente lá, então atualizem seus feeds. 🙂

Daniel

Categorias:Sem categoria

Definição de Pronto

Qualquer time ágil sabe (ou deveria saber) a importância da Definição de Pronto.

O MVP Thomas Schissler publicou em seu blog um componente que pode ser adicionado em works items do TFS 2010 para você colocar os itens que contam em sua definição de pronto. O post pode ser acessado em: http://bit.ly/i8PWbq .

Ao final você deve ter algo similar a isso:

Categorias:ALM, TFS

Palestra TechEd North America 2011

maio 21, 2011 1 comentário

Há poucos dias aconteceu o TechEd North America 2011 em Atlanta.

Para quem não sabe o TecEd Americano é o maior do mundo. Para quem não pode comparecer (tipo eu) a boa notícia é que as sessões ficam disponíveis online para assistir. O endereço é: http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/

Aqui vou listar as sessões que eu separei para assistir (pode fazer o download e assistir offline):

–    Agile Anti-Patterns! – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DPR206

–    Building Business Applications with Microsoft Visual Studio LightSwitch – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DEV211

–    The Future of Microsoft Visual Studio Application Lifecycle Management – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/FDN03

–    Metrics That Matter: Improving Lean and Agile,Kanban and Scrum – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DPR309

–    Microsoft Office 365: The Future of Productivity – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/OSP212

–    Team Foundation Server for Everyone – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DEV202

–    Introducing the Windows Azure Platform – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/COS202

–    Twenty Windows Tools You Never Knew Existed – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/WCL205

–    Emergent Architecture – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DPR308

–    Branching and Merging for Parallel Development – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DEV306

–    Code First Development in Microsoft ADO.NET Entity Framework 4.1 – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DEV312

–    ALM for C++ in Microsoft Visual Studio 2010 – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DEV316

–    Web Deployment Made Easy: Seriously – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DEV342

–    Microsoft Visual Studio 2010 Extensibility – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DEV402

–    The Architect – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DPR201

–    Agile Estimation – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DPR202

–    Debugging a Dysfunctional Team – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DPR208

–    Executable Requirements Let You Play More Foosball! – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DPR301

–    Cost-Oriented Development – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DPR307

–    Let’s Get Visual: The Art of Report Design – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DBI334

–    Jason Zander Unplugged – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DEV212

–    Demystifying Debugging with Microsoft Visual Studio Ultimate and IntelliTrace – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DEV320

–    Using Tests to Drive the Entire Software Development Lifecycle – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DEV350

–    The Agile Buffet – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DPR306

–    The Accidental Team Foundation Server Admin – http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DEV327

–    Application Lifecycle Management: Microsoft Project Server 2010 and Microsoft Team Foundation Server 2010, Better Together –  http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/OSP203

É isso, conforme eu for assistindo vou postando minha opinião sobre as palestras. Espero que aproveitem! :)
Categorias:Sem categoria

Mundo .NET de Abril nas Bancas

Pessoal,

Não sei se todos sabem, mas eu sou editor-chefe da revista Mundo .NET desde a edição de Fevereiro de 2011.

Está nas bancas e disponível para assinatura a edição de Abril. Vale a pena conferir, ficou muito legal!

Pesquisa Fonética em Português
Divirta-se com um case de adaptação do mais famoso algoritmo de busca fonética para o nosso idioma.
Integração do ERP com os novos recursos do Windows 7
Familiarize-se com as diversas possibilidades de integração de aplicativos com o Windows 7 e torne-os mais dinâmicos, confiáveis e fáceis de usar. Proporcione uma experiência de uso muito melhor aos usuários!
Desenvolvimento de aplicações de Business Intelligence utilizando o SharePoint 2010
Fique por dentro dos novos componentes do SharePoint 2010 para construção de aplicações de Business Intelligence.
Overview do Windows Identity Foundation
Os desafios de desenvolver aplicações que exigem um alto nível de segurança e as soluções oferecidas pela Microsoft para transformar essa tarefa em algo bem mais simples e reutilizável do que existe atualmente.
Windows Azure Platform
Ainda não consegue imaginar como é ter um ambiente para desenvolver, hospedar e gerenciar serviços sem necessidade de manter infraestrutura para isso?
Visual Studio ALM Rangers
Um pouco do ecossistema dos Rangers, o grupo que opera em conjunto com a divisão de desenvolvimento da Microsoft, promovendo a colaboração entre os grupos de produtos Microsoft e os membros de comunidades.
Criando aplicações de baixa latência com a plataforma Windows Azure
Saiba como desenvolver e executar aplicações com baixo custo e potencial de acesso para uma grande quantidade de usuários com a plataforma Windows Azure.
Resolvendo o dilema entre Ágil e PMO 
Confira o lançamento do Feature Pack de Integração entre o Visual Studio Team Foundation Server 2010 e Project Server em primeira mão!
Afinal, o que é Windows Server App Fabric?
Conheça o conjunto de tecnologias integradas que une o mundo da hospedagem de serviços WCF e Workflows WF, proporcionando um ambiente único para gerenciamento de hospedagem de serviços e serviços de cache de dados.
Entrevista com Ken Schwaber, um dos criadores do Scrum
Dicas e Truques
Não deixe de conferir as dicas de conteúdo sobre Windows e SQL Azure, App Fabric, desenvolvimento com Kinect, as novidades do Silverlight 5 e muitas outras dicas e truques pra você ficar por dentro de tudo que acontece no mundo .NET!
Categorias:Mundo .NET

Criando uma Extensão de Validação no Visual Studio 2010

novembro 10, 2010 1 comentário

 

Continuando a explorar extensibilidade nas ferramentas de arquitetura vamos ver um pouco melhor como implementar um tipo de extensão que é Validation Extension.

Primeiro de tudo: Por que devo me importar???

Ao criar validações nos modelos UML você garante que desde os estágios iniciais do ciclo de vida de um requisito serão seguidos padrões determinados. É muito mais fácil corrigir um parâmetro ou método com um nome que saiu do padrão quando este modelo está sendo definido do que quando for feita revisão do código.

O nome é bem claro, com esta extensão podemos criar validações para nossos diagramas.

A extensibilidade nas ferramentas de arquitetura utiliza Managed Extensibility Framework como base. Para saber mais sobre MEF recomendo o artigo Managed Extensibility Framework Overview e também o blog do Rogério Moraes de Carvalho (@rogeriomc).

Acessando File –> New Project –> Modeling Project –> Extensibility vemos dois tipos de extensão de validação:

image

O primeiro projeto Layer Designer Validation Extension trata-se de criar uma validação para um Layer Diagram. O projeto Model Validation Extension trata-se e criar uma validação para os diagramas UML. É a última que vamos criar, portando de um nome para a extensão e clique em Ok.

Depois de criarmos o Model Validation Extension, se abrirmos a Solution Explorer vemos um artigo chamado source.extension.vsixmanifest.

Esse arquivo contém algumas informações sobre nossa extensão. Podemos ver ao abrí-lo:

image

Aperte Control+Shift+B e acesse no Windows Explorer a pasta do projeto\bin\debug.  Observe que nesta pasta temos o arquivo NomeDoProjeto.vsix.

Este arquivo vsix é o instalador da nossa extensão. Quando for feito  o deploy desta extensão basta enviar o arquivo e com dois cliques os desenvolvedores podem instalar a extensão. Alegre

Abaixo vemos o código gerado ao criar o projeto:

using System;
using System.Collections.Generic;
using System.Linq;
using System.ComponentModel.Composition;
using Microsoft.VisualStudio.Modeling.Validation;
using Microsoft.VisualStudio.Uml.Classes;
using Microsoft.VisualStudio.Modeling;

namespace UMLModelValidation
{
    // Custom validation constraint
    // See http://msdn.microsoft.com/en-us/library/ee329482(VS.100).aspx
    public class ValidationConstraints
    {
        [Export(typeof(System.Action<ValidationContext, object>))]
        [ValidationMethod(ValidationCategories.Save | ValidationCategories.Menu | ValidationCategories.Open)]
        public void ValidateSomething(ValidationContext context, IClassifier elementToValidate)
        {
         
        }
    }
}

Algumas informações importantes sobre o código que é criado.

Na linha 14 temos :

[Export(typeof(System.Action<ValidationContext, object>))]

Nesta linha o que estamos fazendo é exportar o ValidationContext para que esteja acessível pelo host da nossa extensão que é o Visual Studio.

Outro ponto importante é o seguinte:

[ValidationMethod(ValidationCategories.Save | ValidationCategories.Menu | ValidationCategories.Open)]

Nesta linha estamos utilizando o atributo ValidationMethod e o enumerador ValidationCategories para indicar qual será disparado o meu método de validação. Neste caso será disparado quando: o diagrama for salvo, o diagrama for aberto ou clicando com o botão direito e clicando em Validate.

Na assinatura do método temos dois itens importantes:

public void ValidateSomething(ValidationContext context, IClassifier elementToValidate)

O primeiro parâmetro que passamos é o contexto de validation que será utilizado para gravarmos o resultado das nossas validações. O segundo é o elemento que deve ser validado. Por padrão o elemento é IClassifier que é um tipo genérico que temos nos diagramas.

Vamos fazer uma alteração e ao invés do método receber IClassifier receberá IClass. Nossa assinatura ficará da seguinte maneira:

public void ValidateSomething(ValidationContext context, IClass elementToValidate)

A validação que faremos é que nossos atributos no modelo de classe UML deverá começar com letra maiúscula. Por isso faz sentido recebermos um IClass que se trata de uma classe no nosso diagrama de classe UML no Visual Studio.

O código para fazer a validação é bem simples:

using System;
using System.Collections.Generic;
using System.Linq;
using System.ComponentModel.Composition;
using Microsoft.VisualStudio.Modeling.Validation;
using Microsoft.VisualStudio.Uml.Classes;
using Microsoft.VisualStudio.Modeling;

namespace UMLModelValidation
{
    // Custom validation constraint
    // See http://msdn.microsoft.com/en-us/library/ee329482(VS.100).aspx
    public class ValidationConstraints
    {
        [Export(typeof(System.Action<ValidationContext, object>))]
        [ValidationMethod(ValidationCategories.Save | ValidationCategories.Menu
| ValidationCategories.Open)]
        public void ValidateSomething(ValidationContext context,
IClass elementToValidate)
        {
            //Percorre todos os atributos da classe sendo validada.
            foreach (IProperty item in elementToValidate.OwnedAttributes)
            {
                if (String.IsNullOrWhiteSpace(item.Name))
                {
                    //Grava um erro de validação no diagrama.
                    //O primeiro parâmetro é a mensagem de validação.
                    //O segundo parâmetro é o código do erro
                    //O terceiro parâmetro são elementos que devem
                    //ser destacados quando o usuário clicar na mensagem de erro
                    context.LogError(“O nome de um atributo não pode ser vazio.”,
                    “001”, (ModelElement) item);   
                }
                else if (Char.IsLower(item.Name[0]))
                {
                    //Grava um erro de validação no diagrama.
                    //O primeiro parâmetro é a mensagem de validação.
                    //O segundo parâmetro é o código do erro
                    //O terceiro parâmetro são elementos que devem
                    //ser destacados quando o usuário clicar na mensagem de erro
                    context.LogError(“A primeira letra do nome do atributo deve
                    ser maiúscula”, “002”, (ModelElement)item);  
                }
            }
        }

Já podemos testar nossa extensão. Coloque um breakpoint no início do método e aperte F5. Ao apertar F5 a mágica acontece:

image

Como vemos uma nova instância do Visual Studio é aberta e podemos testar nossa extensão.

Essa instância do Visual Studio é chamado Experimental Instance. É uma instância totalmente separada da instância que você utiliza para desenvolver. Uma vantagem enorme de termos essa instância separada é que as extensões instaladas para teste não afetarão o seu ambiente de desenvolvimento.

Na instância experimental acesse Architecture –> New Diagram –> Class Diagram e aperte Ok.

Crie uma classe e Adicione três atributos: um com o nome em branco, com o o nome atributo1 e por fim um com o nome Atributo 2. Clique com o botão direito e acesse Validate.

O que deve acontecer é que o debugger vai parar no breakpoint que vc colocou anteriormente. Explore o código a vontade a qnd terminar a execução veja que foram mostradas as mensagens de erro na Error list da Experimental Instance.

Ao clicar no erro o Visual Studio destaca o item que deve ser corrigido. ‘

Bem, é isso. É simples criar extensões de  validação e podem trazer um ganho muito grande na padronização dos modelos definidos na sua organização. Alegre

Building Extensions for Visual Studio Architecture Tools

(This post has been written in English because it’s about the webcast Building Great Extensions fo Visual Studio Architecture Tools)

Visual Studio 2010 has some great points to write extensibility, and so the Architecture tools within Visual Studio 2010.

There are 3 types of extensions:

  • Command Extensions: this type of extension creates a new item in the context menu.
  • Gesture Extensions: in this type of extension you write code that will run when the user does some actions like drag and drop, click and so on
  • Validation Extension: this extensions will be called when Visual Studio calls the validation method.

In the webcast we’ve developed a extension to generate a word document from the UML Class Diagram. This extension is available to download here.

Another extension that we’ve developed is a application to generate a Dependency Graph showing the relationship between work items. This extension is available to download here.

If future posts I can explain a little better the anatomy of an extension. For now I hope you enjoy the demo code.

Regards

Categorias:Sem categoria

Desenvolvendo Aplicações para Nuvem com Windows Azure

 

Imperdível!!

Evento Desenvolvimento Aplicações Para Nuvem com Windows Azure no Microsoft Innovation Center de Curitiba. Clique na imagem para se inscrever:

cloud

Categorias:Sem categoria
%d blogueiros gostam disto: