Microsoft® Visual Studio® LightSwitch

25 08 2010

Acabei de rodar minha primeira aplicação construida com o lightswitch e não digitei nenhuma linha de codigo. Simplesmente dei alguns cliques e pronto ja tinha uma aplicação com um CRUD completo e que alem de tudo exportava os dados pro excel.

Agora podemos criar uma aplicação sem precisar digitar nenhuma linha de codigo, isso é preocupante! o que sera dos desenvolvedores… rs  ^^

Não deixem de dar uma olhada nessa novidade.

Linq para Download.

E uma pequena introdução no bloh do Jason Zanders – Introducing Microsoft® Visual Studio® LightSwitch™

Se eu tiver um tempo essa semana eu faço um demo e disponibilizo para download.

Obs: Na hora da instalação se você ja tiver instalado o WCF RIA Services, desinstale-o antes de instalar LightSwitch. Caso contrario o setup dara um erro na hora de instalar o RIA. É que o WCF Ria Services faz parte da instalação do LightSwitch. Qualquer outro problema me mande um email com a duvida/problema.

email : adrielcodeco@hotmail.com

Anúncios




Passo a passo: POCO Template para o Entity Framework

5 08 2010

Dessa vez estava pesquisando sobre o Template ADOM.NET C# POCO Entity Generator e cheguei ao Team blog onde tinha um post em ingles e então estudei o template e achei importante compartilhar com vocês, para isso eu traduzi o post e aqui esta.

para quem quiser conferir a versao original em ingles clique aqui.

O POCO Template pode ser usado para gerar persistência tipos de entidades ignorantes de um Entity Data Model. O objetivo deste passo a passo é demonstrar um cenário básico da sua utilização com o Entity Framework.

Requisitos

  1. Qualquer edição do Visual Studio 2010 post Beta-2.
  2. Entity Framework POCO Modelo para C#, disponível aqui.
  3. Um local SQL Server 2008 Express instância tem que ser instalado como SQLEXPRESS. Caso contrário, poderá ser necessário fazer alterações a connection string no arquivo de configuração ou para regenerar o banco de dados do script SQL incluído.
  4. Baixe e extraia a solução inicial anexado a este post.

Nota: Embora o passo a passo a seguir usa C#, todos os conceitos aqui descritos se aplicam ao Visual Basic versão do modelo que está disponível aqui.

1. Configurando o projeto

A solução inclui um projeto chamado POCOTemplateWalkthrough que é um aplicativo de console. Para facilitar a nos concentrar em como usar o POCO Template, a solução já contém os seguintes arquivos:

  • Blogging.edmx: um simples Entity Data Model para um pedido de blogging.
  • Blogging.mdf: um banco de dados SQL Server para o modelo de blogging.
  • Blogging.edmx.sql: SQL Server script que pode ser usado para regenerar o banco de dados se necessário.
  • Program.cs: a classe inicial do programa criado para aplicativos de console.
  • App.config: um arquivo de configuração do aplicativo que contém a connection string para o banco de blogging.

Normalmente, quando você inicia um novo projeto usando Entity Framework você pode importar um modelo de um banco de dados existente. Na versão 4.0, agora você pode criar um banco de dados a partir do modelo. Para saber mais sobre o primeiro Model Features, veja este post.

2. Compreender o modelo de Blogging

Se você abrir o arquivo “Blogging.edmx, é isso que você vai ver:

image

Cinco classes simples são usadas para modelar uma aplicação de blogging: Blog representa um blog real.Uma pessoa pode agir como o proprietário de um blog, mas também como o autor de um post ou um comentário, tanto que herdam da classe abstrata Entry. Um blog pode ter vários Posts, e por sua vez, cada Post pode ter vários Comments.

Observe que estamos usando chaves estrangeiras nesse modelo: Blog tem tanto o Owner como OwnerID propriedades. É importante notar, contudo, que a exposição da chave estrangeira em entidades não é um requisito para Entity Framework ou o modelo POCO.

Por padrão, um modelo criado com o Designer Entity Data Model produz classes de entidade com base em System.Data.Objects.DataClasses.EntityObject, que fornece serviços básicos às entidades, como a notificação de mudança, gerenciamento de identidade e relacionamento. atributos especiais são usados para decorar as classes e propriedades, de modo que Entity Framework em tempo de execução pode relacionar cada classe e da propriedade com a propriedade correspondente no modelo. Para ver o tipo de código que é gerado por padrão, expanda o Blogging.edmx arquivos associados clicando na seta próximo a ele, e depois abra o arquivo Blogging.Designer.cs:

image

POCO stands para objetos CLR Plain-Velha. POCO apoio da Entidade Framework 4.0 significa que estes tipos EntityObject baseados podem ser substituídas com as classes mais simples. tipos de entidade POCO não são obrigados a herdar de qualquer classe e não precisam de atributos para mapear os elementos homólogos no modelo. Em vez disso, os tipos e propriedades nos objetos e no modelo estão associadas ao tempo de execução simplesmente com base em seus nomes.

Para uma visão geral das entidades de apoio POCO você pode ler as partes 1, 2 e 3 desta série blog sobre POCO e Entity Framework, e também este post sobre o uso de padrões com Entity Framework 4.0.

3. Adicionando o POCO modelo

Uma das vantagens das entidades POCO é que eles são simples. Portanto, em geral, é muito fácil de escrever à mão. No entanto, quando você tem um Entity Data Model como ponto de partida e querem suas classes de entidade a ser POCO, o Modelo POCO pode proporcionar um salto bom, gerando POCO classes que correspondem ao modelo, em vez das classes EntityObject padrão.

Para fazer isso, você pode clicar com o botão direito em uma área vazia da “tela” Blogging.edmx e selecione “Add Code Generation Item…”

image

Isso fará com que o diálogo Add New Item, na qual você pode escolher qual o modelo que deseja usar. O Modelo POCO normalmente pode ser encontrado no Visual C# Itens ou o Visual Basic categoria Artigos.

image

Nesta tela, selecione “ADO.NET Entity POCO Generator” e digite “Blogging.tt” como o nome do novo item.Em seguida, clique no botão “Adicionar”.

Nota: A caixa de diálogo Aviso de Segurança será exibida cada vez que um T4 gera o código de um modelo em sua máquina:

image

Normalmente, os arquivos de modelo T4 geram o código quando eles são adicionados a um projeto ou quando eles são salvos. Se você tiver baixado e instalado o modelo de formulário de uma fonte confiável, você pode clicar em “OK”.

4. Entender como funciona o modelo POCO

Depois de ter adicionado o POCO modelo, o projeto será parecido com este:

image

Quando você escolhe o modelo T4 POCO dois arquivos de modelo são adicionados ao seu projeto. Neste caso, um é chamado de “Blogging.Context.tt” e o outro é chamado de “Blogging.tt”. T4 representa Text Template Transformation Toolkit, e é um modelo de motor que vem com o Visual Studio. O Entity Framework POCO Template aproveita o T4 para permitir que você personalizar a geração de código.

O “Blogging.tt arquivo” é responsável por gerar um arquivo para cada EntityType e ComplexType no modelo “Blogging.edmx. Por exemplo, a versão da classe POCO Blog parecido com este:

image

“Blogging.tt” também gera um arquivo chamado “Blogging.cs”, que contém uma classe FixupCollection <T> utilizado pelas classes POCO para manter as extremidades opostas de uma relação em sincronia.

Por exemplo, no modelo que temos vindo a utilizar, quando você definir autor de um comentário de uma pessoa especial, a classe FixupCollection <T> assegura que a recolha de comentários da Pessoa conterá a comentario também.

O segundo modelo (“Blogging.Context.tt”) produz uma rigidez ObjectContext para o “modelo” Blogging.edmx. Você usa essa rigidez ObjectContext para interagir com o banco de dados.

Observe que cada vez que você editar e salvar qualquer modelo T4 os arquivos dependentes são regenerados, para que você não deve editar os arquivos gerados diretamente, ou suas alterações serão perdidas. Se desejar modificar o código gerado, você pode modificar uma ou ambos os modelos.

Nota: Por que dois modelos?

O principal objetivo do modelo POCO é produzir persistência de classes de entidade ignorante.

No entanto, a rigidez ObjectContext deriva ObjectContext, que é uma entidade de classe Framework.Portanto, este modelo tem de estar em um projeto com uma referência para o Entity Framework.

Ao dividir o modelo em duas partes, uma parte que gera os tipos de entidade e tipos complexos e que gera um contexto de rigidez, torna-se possível não só ter Entidades e ComplexType que são persistência ignorantes, mas mais para colocar as classes em um assembly / projeto que não tem conhecimento no código de persistência em tudo.

Os próximos passos mostram como fazer isso.

5. Movendo tipos de entidade para um projeto separado

Para continuar, adicione um novo projeto Class Library para a solução chamada Entities.

image

Você pode remover o arquivo Class1.cs criado por padrão no novo projeto.

Agora, no projeto POCOTemplateWalkthrough, adicione uma referência de projeto ao projeto Entities:

image

Em seguida, mova o arquivo “Blogging.tt” para o projeto Entities. Para fazer isso, você pode simplesmente arrastar e soltar o arquivo para o projeto Entities na janela Solution Explorer, enquanto você mantiver a tecla Shift ao mesmo tempo.

6. Edit “Blogging.tt ” para corrigir o link para “blogging.edmx”

O POCO Template os arquivos T4 template precisam ser capazes de ler os metadados do modelo EDM, a fim de gerar o código de direito. Desde que mudaram o modelo, a localização relativa do modelo mudou, portanto, temos de corrigir o modelo para o seu link para o modelo está correto novamente. Para fazer isso, você pode modificar uma linha próxima ao topo do modelo a partir de:

string inputfile = @”Blogging.edmx”;

Para:

string inputfile = @”.. \ POCOTemplateWalkthrough \ Blogging.edmx”;

Isto é simplesmente um caminho relativo a partir do modelo do novo local para o arquivo Blogging.edmx em outro projeto.

Uma vez que você fez isso Salve o modelo, e isso vai gerar as classes de entidade POCO. Você pode verificar que o conteúdo do arquivo “Blogging.cs” em “Blogging.tt” tem o direito de verificar o conteúdo que o caminho digitado acima está correta:

image

Além disso, observe o projeto Entities não tem nenhuma referência a System.Data.Entity (aka o Entity Framework), e é completamente ignorante de persistência.

7. Mudar “Blogging.Context.tt” namespaces para coincidir com “entidades”

As classes do projeto Entities estão agora no namespace Entities” em vez do namespace POCOTemplateWalkthrough”, então você precisa modificar o espaço usado pelo modelo de contexto. Caso contrário, o compilador não vai encontrar os tipos de entidade e a solução não irá compilar. Você pode fazer isso definindo o valor da propriedade “Custom Tool Namespace” para “entities” no navegador de propriedade do Template item.

image

Uma vez que você fizer isso, salve o arquivo de modelo novo (ou seja, pressionando Ctrl + S) e você deve ser capaz de compilar a solução sem erros.

8. Teste de sanidade: adição e consulta de dados no banco de dados Blogging

Agora que estamos a fazer produção de classes POCO é hora de verificar que podemos adicionar alguns dados ao banco de dados e recuperá-lo novamente usando nossas classes POCO eo Entity Framework.

Primeiro, adicione esta instrução usando no topo da Program.cs “file:

using Entities;

Em seguida, modificar o método Main(), adicionando as duas seguintes blocos de código:

using (var ctx = new BloggingContainer())
{
var person = new Person();
person.EmailAddress = "billg@microsoft.com";
person.Firstname = "Bill";
person.Surname = "Gates";
ctx.People.AddObject(person);
ctx.SaveChanges();
Console.WriteLine("Saved {0}", person.Firstname);
}
using (var ctx = new BloggingContainer())
{
var person = ctx.People.First();
Console.WriteLine("Found {0}", person.Firstname);
}

9. etapa final: compilar e executar o código

Depois de seguir todos os passos descritos anteriormente, você deve ser capaz de compilar e executar o código e ver a seguinte tela:

image

Personalizar classes e modelos

O tipo de entidade, tipo complexo e classes ObjectContext gerados pelo modelo são todas a classes POCO partial. Por isso, muitas vezes é possível estender o comportamento de entidades apenas adicionando uma classe partial que contém o código adicional para o projeto.

Em outros casos, poderia ser melhor para modificar os modelos próprios para gerar o código diferente. Na verdade, toda a questão de uma solução baseada em modelo é que você pode decidir o comportamento que você quer apenas uma vez e, em seguida, obter o resultado desejado a partir de diferentes modelos através da aplicação de um modelo modificado.

Modificando os arquivos T4 Template consiste em modificar um arquivo de texto, mas está além do escopo desta explicação passo a passo básico. Personalização de modelos T4 para geração de código de entidade é descrita no presente post.

Criar o seu próprio modelo T4 não é coberto neste passo a passo também. Você pode esperar futuro lugares para explorar mais a fundo nesta área. No entretanto, vale ressaltar que o T4 fornece um mecanismo pelo qual você pode escrever utilitários comuns que partilham entre modelos, em algo chamado incluir arquivos.POCO Template usa um arquivo de inclusão chamado EF.Utility.CS.ttinclude. Isto inclui fornece uma série de recursos que tornam a escrita de utilidade T4 modelos Entity Framework para facilitar, entre outros:

  • O suporte a múltiplos arquivo de saída. Por padrão, cada arquivo TT produz apenas um arquivo de saída, o apoio de vários arquivos torna possível criar uma única classe por arquivo, que tem várias vantagens.
  • Funções para produzir segurança identificadores. É possível, no EDM ter identificadores, como o nome de uma entidade tipo, que estão reservados na língua-alvo CLR.
  • Funções para controlar a visibilidade (pública / etc protegidas) das propriedades, etc
  • Funções para interagir com os metadados Entity Framework
Os problemas conhecidos nesta versão
  1. O Modelo POCO não trabalho com projetos ASP.NET WebSite: Um erro no arquivo de saída suporta múltiplos impede que o modelo POCO de trabalhar em projetos WebSite. A correção estará disponível em uma atualização futura. Nesse ínterim, você pode colocar o modelo em uma biblioteca de classes do projeto separado e adicionar uma referência para a biblioteca de classes do WebSite.
  2. Executando uma consulta com inclusão e MergeOption igual NoTracking pode causar uma exceção: Há um problema na interação entre a implementação das relações de código de correção de classes geradas pelo POCO modelo eo controle de alterações POCO Proxies habilitado pelo modelo POCO. Somos actualmente a investigar este assunto.
  3. Separe pode causar estrangeiros propriedades chaves anulável a ser anulado: A aplicação da correção relacionamento não consegue distinguir a razão pela qual uma entidade está sendo removido de um gráfico de objeto. Quando Detach é aplicada a uma entidade que está relacionada com outras associações de estrangeiros através de chave, a lógica de correção vai reagir a nulled sendo feitas e elementos que estão sendo removidos do colecções e irá definir o FK propriedades correspondentes a um valor nulo. Nós estamos investigando esta questão.
  4. O evento AssociationChanged pode ser aumentado duas vezes: O evento AssociationChanged é gerado o dobro com correção CollectionChangeAction.Add quando ocorre no modelo de tal forma que uma coleção é modificado. Nós estamos investigando esta questão.

POCOTemplateWalkthrough.zip





How To – Desabilitando Warnings

5 08 2010

Você pode estar incomodado com alguns warnings e que desabilitar eles.

Pois bem, o que você precisa e usar uma diretiva de compilação.

A diretiva de compilação que é usado para desabilitar os warnings e o #pragma

Veja na documentação do MSDN
http://msdn.microsoft.com/en-us/library/441722ys(VS.80).aspx

Vamos a um exemplo rápido

    class testWarning
    {
        public string test;

        public testWarning()
        {

        }
    }

Quando compilado o código acima var gerar um warning como na imagem a seguir.

Para desabilitar esse warning  eu preciso saber o código desse warning, então eu vou na lista de warnings do MSDN e procuro por esse warning  e pego o código dele.

E faço como no exemplo abaixo

    class testWarning
    {
#pragma warning disable 0649
        public string test;
#pragma warning restore 0649

        public testWarning()
        {

        }
    }

O comando #pragma warning disable [WarningCode] desabilita o warning com esse código, então depois desse comando todos os warning com esse código não serão exibidos, a te que seja restaurado usando o comando #pragma warning restore [WarningCode]

Na imagem a seguir o resultado do build usando o #pragma

Note que não exibe mais o warning.

Você pode procurar o warning na lista de warnings do MSDN ou dar uma googada com o texto do warning pra ver se acha o código do warning.

A seguir a lista de Erros e Warnings da documentação do MSDN
http://msdn.microsoft.com/en-us/library/ms228296.aspx





Visual Studio 2010 – Ferramentas de Produtividade

5 08 2010

Estava lendo o blog de ScottGu e ele falava de uma ferramentas para aumentar a produtividade no desenvolvimento. Resolvi dar uma olhada na ferramenta, baixei e instalei e ao usar… que ferramenta ein! Recomendo para todos os desenvolvedores que usam o Visual Studio Professional ou superior.

Eu encontrei uma definição da ferramenta na pagina de download só que estava tudo em inglês. Então traduzi e esta a seguir. Caso tenha alguma coisa que não ficou claro me desculpem, mas meu inglês e péssimo, apesar de ter usado uma ferramenta para tradução nem tudo é traduzido corretamente assim sobra pra mim ter que acertar o texto.

Mas espero que de pra entender alguma coisa.

Linq para download

A seguir a Descrição traduzida.

Visual Studio 2010 Ferramentas de Produtividade

Um conjunto de extensões para o Visual Studio Professional (ou superior), que melhora a produtividade do desenvolvedor. Nesta segunda versão do Power Tools nós adicionamos as quatro seguintes extensões:

Opções de ferramentas de suporte
O número um pedido de recurso, de longe, foi a capacidade de desativar as extensões individual no Productivity Power Tools. Nesta versão, nós adicionamos uma extensão que adiciona uma categoria para Tools Options que permite que você alterne as extensões on / off e fornece um único lugar para encontrar as opções para uma determinada extensão.

Solution Navigator

Solution Navigator é uma janela nova ferramenta que funciona como um reforço ao Solution Explorer. Com ele, você pode:

  • Expandir os arquivos de código para navegar para suas classes, expandir classes para navegar para seus membros, e assim por diante (VB e C # somente)
  • Pesquisar membros de sua solução, todo o caminho para a classe
  • Filtrar a sua solução ou projetos para ver apenas arquivos abertos, salvos os arquivos, e assim por diante
  • Exibir informações relacionadas sobre classes e membros (tais como referências ou chamadas / chamadas para C #)
  • Pré-visualização de imagens ou visualizar informações ricas passando o mouse sobre o código.

Em outras palavras, mistura funcionalidade do Solution Explorer, exibição de classe, Object Browser, Call Hierarchy, Navigate To, e Find Symbol Reference tudo em uma janela de ferramentas!

Note que a janela da ferramenta não suporta (ainda) tudo o que Solution Explorer suporta, como multiselect e arrastar e soltar.

Solution Navigator também fornece tooltip em código C # e VB (que substitui o padrão “quick info”) que lhe dão o mesmo tipo de dados, mas na ponta dos dedos. Além de receber as dicas em hover, você pode:

  • Pressione Ctrl +1 para abrir uma dica relevante na localização atual do cursor
  • Pressione Ctrl +2 para navegar rapidamente para qualquer classe / member no atual arquivo de código

Quick Access

Quick Access é uma nova janela de ferramentas que permite aos usuários pesquisar e executar tarefas comuns no Visual Studio IDE. Não tenho certeza se um comando de menu especial está localizado? Quer uma maneira rápida de criar um projeto Silverlight novo? Ao usar o Quick Access, você pode encontrar de forma eficiente e executar operações comuns no VS sem tirar as mãos do teclado. Quick Access permite que os usuários:

  • Execute comandos do menu principal e menu de contexto
  • Abra a caixa de dialigo “New Project” com um determinado modelo de projeto selecionado
  • Mostrar uma janela de ferramenta
  • Ir para um Visual Studio Options
  • Navegue até um documento aberto com Tab
  • Criar e executar uma série de ações (Task)

Para usar, pressione Ctrl +3 para abrir o Quick Access, escreva o seu termo de pesquisa (por exemplo, “debug”) e pressione Enter no resultado desejado. Se o seu termo de busca retorna muitos resultados, continuar pressionando Ctrl +3 para percorrer cada tipo de resultados.

Auto Brace Completion

Auto Brace Completion melhora a produtividade de escrever código automaticamente inseri o código de encerramento quando a abertura é digitado para VB e C #. Mais especificamente, esta extensão:

  • Suporta as seguintes construções: () {}, [], <>,””e”.
  • Permite que você carregue <TAB> para ir para o próximo bloco, próxima abertura.
  • Permite-lhe completar automaticamente uma declaração em C #, inserindo o encerramento ponto e vírgula e pular para a próxima linha com a tecla SHIFT + ENTER

As extensões do anterior Producitivity Power Tools foram incluídos e aprimorados.

Searchable caixa de diálogo Adicionar referência
O Adicionar novo diálogo Referência torna mais rápido e mais fácil para você encontrar a referência que você está procurando e adicioná-lo ao seu VB, C # ou F # projeto. Partir do Solution Explorer, simplesmente clique direito do mouse no nó References, selecione Adicionar Referência comando para ver a actualização de diálogo Adicionar Referência.

Destaque da linha atual

Conforme a resolução dos monitores aumenta, é cada vez mais difícil encontrar o cursor no editor de código. O destaque extensão da linha atual torna mais fácil encontrar o acento circunflexo, destacando a linha que o cursor está no editor. Você pode até mesmo configurar o cor padrão, alterando a configuração de “Current Line (Extensão)” e “atual linha inativa (Extensão)” em Ferramentas Opções Fontes & Cores.

HTML Copie
Esta extensão fornece suporte para o formato HTML clipboard para cortar ou copiar o código do editor. Isto significa que você não terá mais que ir arrumar a formatação do seu código quando você colá-lo em uma forma TFS bug ou qualquer outro baseado em HTML controle.

Clique Triple
Nunca foi tão fácil para selecionar uma linha de código a partir do rato por simples triplo-clicar em qualquer ponto da linha.

Fix Tabs Mixed
Alguns desenvolvedores preferem guias, outros preferem espaços, e ninguém gosta de misturar tabs e espaços. Esta extensão promove a harmonia desenvolvedor alerta que elas estão abertas ou salvar um arquivo que tem uma mistura de tabulações e espaços. A barra de informação também fornece uma maneira fácil de corrigir o arquivo para atender às suas preferências.

Ctrl + Clique em Ir para definição
Essa extensão dá ao editor de um navegador web, adicionando links clicáveis para símbolos no seu código que você mantenha pressionada a tecla Ctrl.

Alinhar Atribuições
Esta extensão é útil para tornar seu código um pouco mais legível através do alinhamento das atribuições quando você digita Ctrl + Alt +] tal que leva o seguinte:

E transforma-o assim:

Atenção: Este conflito pode, com suas configurações de formatação. Por exemplo, em C # você precisará desativar: Ferramentas> Opções> Editor de Texto-> C # -> Formatação-> Espaçamento-> “Ignorar os espaços nas declarações de declaração”

Line Up Move / Comandos Down
Isso mapeia a extensão + Alt + Seta para cima e teclas Alt Seta para baixo de tal forma que eles vão passar a linha atual de código ou as linhas selecionadas para cima e para baixo através do editor.

Coluna Guias
Desde Visual Studio 2002, tem havido uma chave de registro não tão secreto que permitiu usuário para desenhar uma linha vertical no editor de código. Isto é muito útil para desenvolvedores lembram que a sua completa linha de código ou comentários podem não se encaixar uma única tela. Graças a esta extensão deste recurso voltou com UI configura-lo. Basta colocar o cursor na coluna apropriada e selecione Adicionar orientação do menu de contexto 

Colorized Ajuda parâmetro
Esta ampliação melhora a coerência com o editor sintaxe highlighting, aplicando-se ao conteúdo da janela da Ajuda de parâmetro para C # e VB.
Atenção: A sintaxe destacando as cores podem ser customizadas usando os itens de mostrar o prefixo “Help Assinatura” no “Fontes e Cores” no menu.





How To – Criando Snippets

14 06 2010

As vezes nós temos que ficar repetindo alguns trechos de código que na maioria das vezes muda uma palavra ou duas. Esses trecos de código podem ser encapsulados em uma snippet e depois chamados com um mínimo de trabalho.

Download da Snippet aqui.

Me sigam, vamos criar uma snippet.

Eu quando estou Desenvolvendo um controle e tenho que criar as propriedades do controle não gosto de ficar digitando aquela estrutura, entao vamos criar uma snippet pra montar um propriedade com o minimo de trabalho.

O trecho de código que vamos encapsular será :

#region [ MyProperty ]

public static readonly DependencyProperty MyPropertyProperty = DependencyProperty.Register(
    name: "MyProperty",
    propertyType: typeof(MyPropertyType),
    ownerType: typeof(MyOwnerType),
    typeMetadata: new PropertyMetadata(
        defaultValue: MyDefaultValue,
        propertyChangedCallback: new PropertyChangedCallback(MyPropertyPropertyChanged)
        )
    );

public MyPropertyType MyProperty
{
    get { return (MyPropertyType)GetValue(MyOwnerType.MyPropertyProperty); }
    set { SetValue(MyOwnerType.MyPropertyProperty, value); }
}

private static void MyPropertyPropertyChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
{
    if (o != null &amp;&amp; o is MyOwnerType)
    {
        MyOwnerType current = o as MyOwnerType;
    }
}

#endregion [ MyProperty ]

Em meu computador eu criei uma pasta em C:\ com o nome Visual Studio Snippets assim fica mais facil de adicionar a snippet no visual studio.

Dentro da pasta crie um arquivo de texto chamado DependencyProperty.txt e troque a extensao para .snippet vai ficar “C:\Visual Studio Snippets\DependencyProperty.snippet” agora abra ele com o visual studio.

No visual studio clique com o botão direito do mouse na janela e selecione a opção Insert Snippet … .

Agora vai abrir o Intellisense, selecione Snippet.

E pronto, Esta criada a estrutura da nossa snippet.

<CodeSnippet Format="1.0.0" xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <Header>
    <Title>title</Title>
    <Author>author</Author>
    <Shortcut>shortcut</Shortcut>
    <Description>description</Description>
    <SnippetTypes>
      <SnippetType>SurroundsWith</SnippetType>
      <SnippetType>Expansion</SnippetType>
    </SnippetTypes>
  </Header>
  <Snippet>
    <Declarations>
      <Literal>
        <ID>name</ID>
        <Default>value</Default>
      </Literal>
    </Declarations>
    <Code Language="XML">
      <![CDATA[<test>
      <name>$name$</name>
      $selected$ $end$</test>]]>
    </Code>
  </Snippet>
</CodeSnippet>

Agora é só alterar o modelo, altere o titulo(Title), o autor(Author), o atolho(Shortcut), a descrição(Description), retire o SnippetTypes SurroundsWith deixe somente Expansion.

Vamos alterar também o Code Language do nosso código XML para csharp. esse Code Language se refere ao tipo de código que vamos encapsular em nossa snippet.

O meu ficou assim:

<CodeSnippet Format="1.0.0" xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <Header>
    <Title>DependencyProperty.Register</Title>
    <Author>Mit</Author>
    <Shortcut>ndp</Shortcut>
    <Description>Create New DependencyProperty</Description>
    <SnippetTypes>
      <SnippetType>Expansion</SnippetType>
    </SnippetTypes>
  </Header>
  <Snippet>
    <Declarations>
      <Literal>
        <ID<name</ID>
        <Default>value</Default>
      </Literal>
    </Declarations>
    <Code Language="csharp">
      <![CDATA[<test>
      <name>$name$</name>
      $selected$ $end$</test>]]>
    </Code>
  </Snippet>
</CodeSnippet>

Agora retiramos a parte dentro do e vamos colocar o código que vamos encapsular.

Vai ficar assim:

<CodeSnippet Format="1.0.0" xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <Header>
    <Title>DependencyProperty.Register</Title>
    <Author>Mit</Author>
    <Shortcut>ndp</Shortcut>
    <Description>Create New DependencyProperty</Description>
    <SnippetTypes>
      <SnippetType>Expansion</SnippetType>
    </SnippetTypes>
  </Header>
  <Snippet>
    <Declarations>
      <Literal>
        <ID>name</ID>
        <Default>value</Default>
      </Literal>
    </Declarations>
    <Code Language="csharp">
      <![CDATA[#region [ MyProperty ]

        public static readonly DependencyProperty MyPropertyProperty =
            DependencyProperty.Register(
                name: "MyProperty",
                propertyType: typeof(MyPropertyType),
                ownerType: typeof(MyOwnerType),
                typeMetadata: new PropertyMetadata(
                    defaultValue: MyDefaultValue,
                    propertyChangedCallback: new PropertyChangedCallback(MyPropertyPropertyChanged)
                )
            );

        public MyPropertyType MyProperty
        {
            get { return (MyPropertyType)GetValue(MyOwnerType.MyPropertyProperty); }
            set { SetValue(MyOwnerType.MyPropertyProperty, value); }
        }

        private static void MyPropertyPropertyChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
        {
            if (o != null &amp;&amp; o is MyOwnerType)
            {
                MyOwnerType current = o as MyOwnerType;
            }
        }

        #endregion [ MyProperty ]]]>
    </Code>
  </Snippet>
</CodeSnippet>

Agora trocamos Ajustamos os literais. Eles são os termos que mudam de declaração pra declaração. Por exemplo, o que mudaria no nosso código seriam o nome da propriedade(MyProperty), o tipo da propriedade(MyPropertyType), o tipo do proprietário da propriedade(MyOwnerType), o valor default(MyDefaultValue). Os literais são como variáveis dentro do nosso código e ficam entre %.

Vai ficar assim :

<CodeSnippet Format="1.0.0" xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <Header>
    <Title>DependencyProperty.Register</Title>
    <Author>Mit</Author>
    <Shortcut>ndp</Shortcut>
    <Description>Create New DependencyProperty</Description>
    <SnippetTypes>
      <SnippetType>Expansion</SnippetType>
    </SnippetTypes>
  </Header>
  <Snippet>
    <Declarations>
      <Literal>
        <ID>PropertyName</ID>
        <Default>MyProperty</Default>
        <ToolTip>Replace with the name of the PropertyName</ToolTip>
      </Literal>
      <Literal>
        <ID>PropertyType</ID>
        <Default>MyPropertyType</Default>
        <ToolTip>Replace with the name of the PropertyType</ToolTip>
      </Literal>
      <Literal>
        <ID>OwnerType</ID>
        <Default>MyOwnerType</Default>
        <ToolTip>Replace with the name of the OwnerType</ToolTip>
      </Literal>
      <Literal>
        <ID>DefaultValue</ID>
        <Default>MyDefaultValue</Default>
        <ToolTip>Replace with the name of the DefaultValue</ToolTip>
      </Literal>
    </Declarations>
    <Code Language="csharp">
      <![CDATA[#region [ $PropertyName$ ]

        public static readonly DependencyProperty $PropertyName$Property =
            DependencyProperty.Register(
                name: "$PropertyName$",
                propertyType: typeof($PropertyType$),
                ownerType: typeof($OwnerType$),
                typeMetadata: new PropertyMetadata(
                    defaultValue: $DefaultValue$,
                    propertyChangedCallback: new PropertyChangedCallback($PropertyName$PropertyChanged)
                    )
                );

        public $PropertyType$ $PropertyName$
        {
            get { return ($PropertyType$)GetValue($OwnerType$.$PropertyName$Property); }
            set { SetValue($OwnerType$.$PropertyName$Property, value); }
        }

        private static void $PropertyName$PropertyChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
        {
            if (o != null && o is $OwnerType$)
            {
                $OwnerType$ current = o as $OwnerType$;
            }
        }

        #endregion [ $PropertyName$ ]]]>
    </Code>
  </Snippet>
</CodeSnippet>

E pra terminar, Caso seu trecho de código use alguma referencia e namespace que podem não estar sendo usado vamos referenciar ambos da seguinte forma:

<Imports>
    <Import>
        <Namespace>System.Windows</Namespace>
    </Import>
</Imports>
<References>
    <Reference>
        <Assembly>System.Windows.dll</Assembly>
    </Reference>
</References>

E esta pronta nossa snipet.

Veja como ficou.

<CodeSnippet Format="1.0.0" xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <Header>
    <Title>DependencyProperty.Register</Title>
    <Author>Mit</Author>
    <Shortcut>ndp</Shortcut>
    <Description>Create New DependencyProperty</Description>
    <SnippetTypes>
      <SnippetType>Expansion</SnippetType>
    </SnippetTypes>
  </Header>
  <Snippet>
    <Imports>
      <Import>
        <Namespace>System.Windows</Namespace>
      </Import>
    </Imports>
    <References>
      <Reference>
        <Assembly>System.Windows.dll</Assembly>
      </Reference>
    </References>
    <Declarations>
      <Literal>
        <ID>PropertyName</ID>
        <Default>MyProperty</Default>
        <ToolTip>Replace with the name of the PropertyName</ToolTip>
      </Literal>
      <Literal>
        <ID>PropertyType</ID>
        <Default>MyPropertyType</Default>
        <ToolTip>Replace with the name of the PropertyType</ToolTip>
      </Literal>
      <Literal>
        <ID>OwnerType</ID>
        <Default>MyOwnerType</Default>
        <ToolTip>Replace with the name of the OwnerType</ToolTip>
      </Literal>
      <Literal>
        <ID>DefaultValue</ID>
        <Default>MyDefaultValue</Default>
        <ToolTip>Replace with the name of the DefaultValue</ToolTip>
      </Literal>
    </Declarations>
    <Code Language="csharp">
      <![CDATA[#region [ $PropertyName$ ]

        public static readonly DependencyProperty $PropertyName$Property =
            DependencyProperty.Register(
                name: "$PropertyName$",
                propertyType: typeof($PropertyType$),
                ownerType: typeof($OwnerType$),
                typeMetadata: new PropertyMetadata(
                    defaultValue: $DefaultValue$,
                    propertyChangedCallback: new PropertyChangedCallback($PropertyName$PropertyChanged)
                    )
                );

        public $PropertyType$ $PropertyName$
        {
            get { return ($PropertyType$)GetValue($OwnerType$.$PropertyName$Property); }
            set { SetValue($OwnerType$.$PropertyName$Property, value); }
        }

        private static void $PropertyName$PropertyChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
        {
            if (o != null &amp;&amp; o is $OwnerType$)
            {
                $OwnerType$ current = o as $OwnerType$;
            }
        }

        #endregion [ $PropertyName$ ]]]>
    </Code>
  </Snippet>
</CodeSnippet>

Agora temos que adicionar nossa snippet no visual studio para poder usa-la.

No menu Tools selecione Code Snippets Manager … .

Abrira uma janela onde vamos adicionar a pasta que criamos para nossa snippet clicando no botão add, mas primeiro certifique-se de que em language esteja selecionada a opção Visual C#.

Após adicionado pode testar a snippet. Abra um projeto ou crie um para teste e no código digite a shortcut. Minha shortcut é ndp então eu digito ndp em meu código e vo precionando tab para ela criar o código e ir pulando de literal em literal. Eu vou precionando tab e alterando os literais e quando acabo preciono Esc para sair do modo de edição da snippet.

Download da Snippet aqui.