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 && 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.

Anúncios

Ações

Information

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s




%d blogueiros gostam disto: