How To – Converter uma cor em String para Brush

23 08 2010

Quando vocês estão trabalhando com cores no code-behind e precisam setar o Background de um Grid por exemplo como #00554433 o que vocês fazem?
Algo assim: ?

grid.Background = new SolidColorBrush(Color.FromArgb(
    byte.Parse("00"),
    byte.Parse("55"),
    byte.Parse("44"),
    byte.Parse("33")
    ));

Eu simplesmente faço assim:

grid.Background = “#00554433”.ToBrush();

Um pequeno truque que eu uso, eu criei uma extension que pega a string com a cor e retorna um Brush.

public static Brush ToBrush(this string color)
{
    Brush brush =
        XamlReader.Load(
        "<Brush xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\" " +
        "       xmlns:x=\"http://schemas.microsoft.com/winfx/2006/xaml\">" +
        color +
        "</Brush>") as Brush;
    return brush;
}




Criando um Sidebar Gadget para Vista usando o Microsoft Silverlight

5 08 2010
Seguindo meus estudos me deparei com o sidebar gadget feito com Silverlight e como de costume semple que encontro um bom material em ingles traduzo para poder entender e posto aqui para que outras pessoas tambem se beneficien desse material. Apesar desse post ter sido escrito em 2008 a forma de desenvolvimento ainda e a mesma tornando-o valido.
Esse post foi copiado e traduzido do blog do Ioan Lazarciuc’s.
Introdução

Algum tempo atrás eu fiz um post sobre como criar uma Vista Sidebar gadget usando JavaScript. Também mencionei que eu tentei criar o gadget usando XBAP ou Silverlight, mas devido às limitações nessas tecnologias, nesse momento, eu decidi que tinha que desistir de muita da funcionalidade específica gadget da barra lateral (flyouts, os dados de domínio cruzado recuperação).

Mais de 6 meses se passaram desde então e agora tenho o prazer de anunciar que eu mudei minha opinião sobre Sidebar gadgets Silverlight. Devido ao fato de que a tecnologia Silverlight amadureceu muito (versão 2.0 beta 2 já está disponível), os gadgets da barra lateral podem ser desenvolvidos usando essa tecnologia, sem sacrificar qualquer funcionalidade específica gadget da barra lateral. Isto é devido ao fato de que existe a plena interoperabilidade entre Silverlight e código JavaScript. Além disso, chama domínio cruz agora são permitidos em Silverlight, para recuperação de dados não é mais um problema. Além disso, tem sido muito maior devido ao fato de que uma pessoa pode consumir WCF serviços usando Silverlight.

Primeiros passos

O primeiro passo é ter um olhar sobre a “clássica” forma de desenvolver gadgets da barra lateral. Mesmo que a maioria do trabalho duro “pode agora ser feito em Silverlight, a fiação”, as entranhas do gadget todo ainda são os clássicos, com base em JavaScript e HTML. Em seguida, se você não estiver familiarizado com o desenvolvimento do Silverlight, eu recomendo que você gaste algum tempo a ficar confortável com o Silverlight. Para isso, você pode visitar http://www.silverlight.net e experimentar os tutoriais lá.

O resultado de minhas investigações neste assunto é um projeto do Visual Studio modelo que pode ser usado para iniciar rapidamente o desenvolvimento de um gadget da Barra Lateral do Silverlight. Eu tenho inspirado no modelo Tim Heuer criou para saltar a partir do desenvolvimento Sidebar gadget usando apenas JavaScript / HTML. Os requisitos para instalar e usar o modelo são:

  • Microsoft Visual Studio 2008 (Standard ou mais)
  • Microsoft Silverlight 2.0 beta 2
  • Silverlight Tools Beta 2 do Visual Studio 2008

Depois de baixar o instalador a partir do modelo aqui, a fim de instalá-lo, basta executar o arquivo baixado. O Visual Studio Content Installer irá lidar com o resto (clique ao lado e ignorar os avisos de segurança, porque eu não assinar o modelo).

Depois de instalar o modelo, a fim de criar um novo gadget da barra lateral, no Visual Studio, clique em File> New> Project. Você vai notar que sob o nó C #, no fundo, em “My Templates”, uma entrada nova apareceu: “Silverlight Sidebar Gadget”. Dê o nome de uma solução e, em seguida, clique em OK.

NewProject

Você vai notar que 6 projetos foram automaticamente adicionado à solução recém-criado: SilverlightSidebarGadgetWeb, SilverlightGadgetDocked, SilverlightGadgetUnDocked, SilverlightGadgetSettings, SilverlightGadgetFlyout e SilverlightGadgetUtilities. Em fim, estas correspondem a: o principal projeto de web site gadget que vai realmente acabar sendo implantado (todo o conteúdo eo código é adicionado a este site), o controle do Silverlight que é exibida quando o gadget está acoplado, o controle do Silverlight que é exibido quando o gadget é desencaixado, o controle do Silverlight que é exibido na página de configurações do gadget, o controle do Silverlight que é exibido na página flutuante do dispositivo e uma biblioteca de utilidades para o Silverlight, fornecendo um código gerenciado da API de gadgets da barra lateral. Esta API traduz em chamadas na JavaScript Sidebar Gadget API.

IMPORTANTE: Devido às limitações na forma como o modelo é construído, as aplicações Silverlight tem que ser adicionado o principal projeto gadget manualmente. Isso pode ser feito indo para as páginas de propriedades para o projeto de site, o Silverlight guia Aplicativos e clique em Adicionar para cada projeto Silverlight adicionais. Desmarque a opção “Adicionar uma página de teste que faz referência ao controle de caixa”, e certifique-se o Silverlight Enable “depuração” está marcada se você quiser capacidade de depuração para o Silverlight.Silverlight e depuração de JavaScript simultânea não for possível no momento atual (depuração requer Silverlight desativar depuração de script do IE).

AddSilverlightApplications

Em uma versão mais recente do modelo de projeto este não será mais necessário, mas para isso eu tenho que adicionar um assistente personalizado para o modelo de projeto que pode preparar os projetos no modelo.

O código é comentado, então eu não vou cobri-lo em detalhe. Além disso, por orientação do desenvolvimento Sidebar gadget, leia o meu anterior post sobre o assunto. O dispositivo é configurado para usar controles Silverlight para cada página do gadget. Isso não é obrigatório, e os controles do Silverlight pode ser removido do projeto (junto com seus projetos de forma a solução), conforme necessário. Há duas classes principais definidos na classe SilverlightGadgetUtilities: SilverlightGadget e SilverlightGadgetEvents. O primeiro é usado para acessar o JavaScript Sidebar Gadget API. O segundo é usado para expor os eventos relacionados com JavaScript como um dispositivo gerenciado eventos nos controles Silverlight.

Conhecido “solavancos”

Há algumas coisas que simplesmente não vai funcionar, não importa o quão duro você tente fazê-los funcionar. Geralmente isso ocorre devido ao fato de que o gadget da barra lateral atual API ou a experiência do usuário gadget fornecido pela Microsoft não permite isso. Estes “caipira-ups” estão especificados nos comentários de documentação das classes ou diretamente como comentários.

Devido ao fato de que o objeto Gadget JavaScript não permite anexar manipuladores de eventos para o mesmo evento, deve-se tomar cuidado que manipulador de evento é registrado para um evento particular. resultados possíveis são: eventos que não se desencadeou a todos nos controles Silverlight, os eventos que se desencadeou em apenas alguns controles Silverlight.

Devido à experiência do usuário com os gadgets da barra lateral, alguns eventos não podem ser acionados em Silverlight controles: o encaixado, eventos Cortada, todos os eventos gadget no flutuante, etc

Algumas propriedades da classe SilverlightGadget são somente leitura mesmo que o gadget da barra lateral JavaScript API especifica que são de leitura e escrita. Isto é devido ao fato de que tentar definir essas propriedades resultaram em exceções em tempo de execução e as exceções são provavelmente causados pela própria API JavaScript.

Eu tentei “descobrir” todos esses “solavancos” que possam aparecer e documentá-los diretamente no modelo. Se há algo que eu perdi ou você tem uma pergunta, por favor entre em contato comigo ou postar um comentário e vou tentar modificar o modelo para corrigir o problema ou documento. Além disso, quaisquer sugestões para melhorar este modelo de projeto são bem-vindas.

Estou ansioso para ver muitos gadgets Silverlight Sidebar sendo desenvolvido. Se você criar um dispositivo tão usando este modelo de projeto, por favor me avise por postar um comentário com um link para a página do Live Gallery gadget ou um link para uma página que descreve-lo.

Mais uma vez, o link para o projeto do Visual Studio modelo é mostrada abaixo.

FILE: SilverlightSidebarGadget.vsi

UPDATE: Se você tiver o Microsoft Visual Studio 2008 SP1 instalado, você precisará doMicrosoft Visual Studio Tools Beta 2 do Visual Studio 2008 , a fim de ser capaz de criar projetos Silverlight. Isto também significa que você não pode usar o modelo fornecido sem instalar a nova versão do Silverlight Tools.

UPDATE 2: Eu tenho atualizado os projetos no modelo para o Silverlight 3 Beta. O modelo correspondente pode ser encontrado aqui.

UPDATE 3: Eu criei uma versão do modelo para o Silverlight 2 final. O modelo correspondente pode ser encontrado aqui.

UPDATE 4: eu atualizei os projetos no modelo para o Silverlight 3 RTW. O modelo correspondente pode ser encontrado aqui.

UPDATE 5: Eu criei uma versão do modelo usando o Visual Basic projetos. O modelo correspondente pode ser encontrado aqui.

UPDATE 6: Eu criei uma versão do modelo para o Visual Studio 2010, usando o formato de nova prorrogação. O modelo correspondente pode ser encontrado aqui.





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





How To – Instanciar controle a partir de um xaml, e extrair xaml de um controle

4 08 2010
/*
 * Dica do dia.
 *
 * Essa dica e útil para quem quer montar um controle
 * a partir de um xaml de forma programática, e caso
 * queira fazer o inverso também, extrair o xaml do
 * controle.
 *
 * Infelizmente a segunda opção só tem suporte no
 * WPF, O Silverlight não extrai o xaml dos controles.
 *
 */

//Recebe uma string e instancia o Controle
//Funciona no WPF e no Silverlight.
Grid grid = System.Windows.Markup.XamlReader.Load("&lt;Grid /&gt;") as Grid;
//Recebe um Controle e extrai o xaml.
//Funciona apenas no WPF
string strGrid = System.Windows.Markup.XamlWriter.Save(grid);




How To : Descobrindo qual versão do Framework esta instalada

30 06 2010

Pra quem precisa descobrir quais versões do Framework estão instaladas, aqui vai uma dica bacana.

Um amigo do trabalho precisou descobrir qual a versão do framework estava instalada nas maquinas para um projeto e pesquisando na internet descobriu esse programa.

O .Net Version Detector e um programa gratuito da empresa ASoft.

É so baixar o programa e nem precisa instalar, vai aparecer apenas uma tela de licença de uso, clica em concorda e vai abrir o programa que por sinal e muito simples mas objetivo.

Nesse quadro abaixo é listado as versões que estão instaladas na sua maquina. Para atualizar a lista clique em refresh.

Os botões do lado esquerdo são para fazer o download do framework e do SDk (botão verde = download do Framework, botão roxo = download do SDK).

Download do programa:

linq 1 : http://www.asoft.be/prod_netver.html
linq 2 : netver2010.zip

E é isso ai, ate a próxima.





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.