Code Snippet para TestMethods no VisualStudio

Filed Under (.NET, Boas Práticas, TDD, Visual Studio 2010) by Vinicius Quaiato on 09-03-2010

Tagged Under : ,

Sempre achei um “pé” ter que ficar copiando métodos de teste, tudo pela preguiça de colocar o attribute [TestMethod] public void etc, etc.

Criei um CodeSnippet pra ser usado com C# que resolve alguns desses problemas. Abaixo segue o código do Snippet, à noite eu mostro como inserir o mesmo no VisualStudio, e coloco um link para download também:

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2010/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>Test Method</Title>
      <Shortcut>test</Shortcut>
      <Description>Code snippet to create a test method</Description>
      <Author>Vinicius Quaiato</Author>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
    </Header>
    <Snippet>
      <Declarations>
        <Literal>
          <ID>Test_Method_Name</ID>
          <ToolTip>The name of the method. Try using a name that indicates the purpose of the test</ToolTip>
          <Default>Test_Method_Name</Default>
       </Literal>
     </Declarations>
     <Code Language="csharp">
       <![CDATA[	[TestMethod]
	public void $Test_Method_Name$()
	{   
 
	}]]>
     </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

Espero que ajude um pouco. É mais rápido digitar “test + tab + tab” do que copiar, colar e alterar o nome do método anterior.

Abraços,
Vinicius Quaiato.

Dojo .Net Architects: Vídeo e Apresentação

Filed Under (.NET, Boas Práticas, Dojos, Publicações, TDD) by Vinicius Quaiato on 27-02-2010

Tagged Under : , ,

Fala galera. Abaixo está o vídeo e apresentação do Coding Dojo do .Net Architects.

Apresentação:

Vídeo do Dojo:

Mais detalhes podem ser vistos aqui:
http://dojo.dotnetarchitects.net/index.php/2010/02/27/resultado-1-coding-dojo-net-architects/

Abraços,
Vinicius Quaiato.

Asp.Net Ajax Library: Nova biblioteca do Asp.Net 4.0

Filed Under (.NET, .NET 4.0) by Vinicius Quaiato on 26-02-2010

Tagged Under : , , , ,

Asp.Net Ajax Library é uma nova biblioteca JavaScript que nos permite criar aplicações orientadas a dados de forma simples e prática.

Ela difere do Ajax Control Toolkit no sentido de que todos os seus controles e funcionalidades rodam inteiramente no client, ou seja, é possível utilizar o Ajax Library em páginas 100% html, nenhum code behind, nenhum arquivo .aspx e nenhum arquivo .cs (é possível trabalhar com .aspx e codebehind, só não é obrigatório).

Para realizarmos este exemplo vamos fazer o download da biblioteca no CodePlex neste link: http://ajax.codeplex.com/

Neste exemplo veremos como gerar uma tabela de dados contendo o nome de algumas bandas e suas respectivas fotos.
Não utilizaremos ainda acesso a webservices, trabalharemos com dados locais.

Para isso criaremos um projeto Asp.Net WebSite vazio, e adicionaremos um arquivo html, chamado Default.htm (Sim, nossa aplicação toda executará em um arquivo .htm).
Vamos adicionar ao projeto os arquivos .js que fazem parte da biblioteca, como mostra a imagem abaixo:

Feito isso adicionarei os trechos de código abaixo na página Default.html. Separei em dois blocos para mostrar primeiro o código JavaScript e depois o código HTML, no final colocarei o código completo da página.

1
2
3
4
5
6
7
8
9
10
11
12
13
<script src="Scripts/Start.js" type="text/javascript"></script>
<script type="text/javascript">
    Sys.require([Sys.components.dataView],
        function () {
            var bandas = [
                { Nome: 'Metallica', Foto: 'metallica.jpg' },
                { Nome: 'The Smiths', Foto: 'smiths.jpg' },
                { Nome: 'Depeche Mode', Foto: 'depeche.jpg' },
                { Nome: 'Los hermanos', Foto: 'hermanos.jpg' }
            ];
            Sys.create.dataView("#corpo",{data: bandas});
        });  
</script>

Como pode ser visto na linha 1 estou adicionando uma referência para o arquivo Start.js, que faz parte do Asp.Net Ajax Library, e adicionamos no nosso projeto.
Na linha 3 começa a acontecer a “mágica”. Chamamos o método require que recebe neste caso dois parâmetros. O primeiro é uma biblioteca a ser carregada, neste caso o Sys.components.dataView. o segundo parâmetro é uma função a ser executada depois que a biblioteca foi carregada, ou seja, seus recursos já estão disponíveis.
Um dos principais recursos para a exibição de dados é o DataView. DataView é basicamente um template, criamos marcações HTML e então pedimos para o Ajax Library transformar em um dataview.
Da linha 5 até linha 10 eu crio um objeto utilizando notação JSON, contendo o nome de uma banda, e o nome de um arquivo com a imagem da banda, bastante simples. Este objeto será nossa fonte de dados.
Na linha 11 ocorre o bind dos dados. Utilizando o Sys.create.dataView passamos como primeiro parâmetro o id de um elemento HTML onde deve ser criado o dataview. E como segundo parâmetro dizemos que o objeto bandas deve ser usado como fonte de dados.
Bastante simples.

Abaixo está o código HTML, onde definimos o elemento que será o dataView:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<table>
    <thead>
        <tr>
            <th>Banda</th>
            <th>Foto</th>
        </tr>
    </thead>
    <tbody id="corpo" class="sys-template">
        <tr>
            <td>
                <span>{{Nome}}</span>
            </td>
            <td>
                <img sys:src="{{Foto}}" width="100" height="100" />
            </td>
        </tr>
    </tbody>
</table>

Apenas criamos uma table, simples. Na linha 8 está um detalhe importante pois utilizamos uma class chamada sys-template. Esta class é necessária para que o Ajax Library reconheça este elemento como um template com o qual ele poderá trabalhar.
Na linha 11 criamos um span e como valor do span utilizamos a marcação {{Nome}} que diz para o Ajax Library que ali deve ser colocado o campo Nome da fonte de dados que passamos para ele.
Na linha 14 fazemos quase a mesma coisa, a diferença é que ao invés de utilizarmos o atributo src do elemento img, utilizamos sys-src, pois o valor deste atributo {{Foto}} está entre as aspas, e é com o sys-src que o Ajax Library consegue fazer o bind corretamente.

Pronto! Agora temos nossa aplicação funcionando, realizando o bind da nossa fonte de dados, e exibindo tudo da maneira desejada. Como mostra a figura abaixo:

Página usando Asp.Net Ajax Library

Página usando Asp.Net Ajax Library

O código completo da página Default.html está aqui:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <title></title>
        <script src="Scripts/Start.js" type="text/javascript"></script>
        <script type="text/javascript">
            Sys.require([Sys.components.dataView],
                function () {
                    var bandas = [
                        { Nome: 'Metallica', Foto: 'metallica.jpg' },
                        { Nome: 'The Smiths', Foto: 'smiths.jpg' },
                        { Nome: 'Depeche Mode', Foto: 'depeche.jpg' },
                        { Nome: 'Los hermanos', Foto: 'hermanos.jpg' }
                    ];
                    Sys.create.dataView("#corpo",
                     {
                         data: bandas
                     });
                });  
        </script>
    </head>
    <body>
        <table>
            <thead>
                <tr>
                    <th>Banda</th>
                    <th>Foto</th>
                </tr>
            </thead>
            <tbody id="corpo" class="sys-template">
                <tr>
                    <td>
                        <span>{{Nome}}</span>
                    </td>
                    <td>
                        <img sys:src="{{Foto}}" width="100" height="100" />
                    </td>
                </tr>
            </tbody>
        </table>
    </body>
</html>

Bom pessoal, por hoje é isso. O Asp.Net Ajax Library possui uma série de recursos e controles incríveis. São 3 tipos diferentes de bindings, e os bindings podem ser feitos de maneiras variadas.
Pretendo ir dando mais detalhes e informações por aqui, na medida do possível.
Alguns How To podem ser vistos aqui.

Comentário, críticas e sugestões são bem vindos.

Att,
Vinicius Quaiato.

Postando no Twitter com TweetSharp em C#

Filed Under (.NET, Twitter) by Vinicius Quaiato on 22-02-2010

Tagged Under : , ,

Continuando a falar da API TweetSharp, neste post mostrarei como enviar tweets e retweetar mensagens.

Novamente estamos utilizando as interfaces fluentes do TweetSharp, o que torna o trabalho bem simples e fácil, pois com a ajuda do intellisense podemos realizar todo trabalho simplesmente navegando através dos métodos, que possuem nomes bem definidos e claros.

Bom vamos lá, continuaremos utilizando o código apresentado neste post aqui.

Abaixo estou criando o método que envia uma nova mensagem para o Twitter:

1
2
3
4
5
6
7
8
9
10
public static void PostarMensagemTwitter(string mensagem)
{
    var request = FluentTwitter
                   .CreateRequest()
                   .AuthenticateAs("seuLogin", "suaSenha")
                   .Statuses()
                   .Update(mensagem);
 
    var result = request.Request();
}

Este método é bem simples e a única novidade é a linha 7, onde chamamos o método Update, passando uma string, que é a mensagem que será enviada para o Twitter. Para entender mais sobre os outros métodos, veja a explicação aqui.

Agora vou alterar o método Main para enviar uma nova mensagem e depois fazer a consulta das últimas 10 mensagens para verificar se realmente conseguimos enviar o tweet:

static void Main(string[] args)
{
    PostarMensagemTwitter("Enviando tweet através do post do blog!!!");
 
    var tweets = Obter10ultimosTweets();
    foreach (var tweet in tweets)
    {
        Console.WriteLine("@{0} {1}\n\n", tweet.User.ScreenName, tweet.Text);
    }
 
    Console.ReadKey();
}

O resultado pode ser visto na imagem abaixo:

Postando mensagem Twitter com C# e Tweetsharp

Postando mensagem Twitter com C# e Tweetsharp

Para fazer um retweet, ou seja, repassar uma mensagem que alguém enviou, utilizaremos o método abaixo:

1
2
3
4
5
6
7
8
9
10
public static void Retweetar(TwitterStatus tweet)
{
    var request = FluentTwitter
       .CreateRequest()
       .AuthenticateAs("seuLogin", "suaSenha")
       .Statuses()
       .Retweet(tweet, RetweetMode.Prefix);
 
    var result = request.Request();
}

Na linha 1 podemos notar que recebemos como parâmetro um TwitterStatus, que é a mensagem que queremos retweetar. Veremos depois como obter este objeto. Na linha 7 estamos chamando o método Retweet e passando como primeiro parâmetro o tweet que queremos retweetar, e passamos também um valor do enum RetweetMode, neste caso o valor Prefix, indiicando que o prefixo ‘RT’ deve ser adicionado ao nosso retweet.

Alterei o método Main para selecionar um tweet específico, retweetar, e então listar os últimos 10 para vermos o nosso retweet:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
static void Main(string[] args)
{
    var tweets = Obter10ultimosTweets();
    var paraRetweetar = tweets.Where(t => t.User.ScreenName == "vquaiato").First();
 
    Retweetar(paraRetweetar);
 
    tweets = Obter10ultimosTweets();
 
    foreach (var tweet in tweets)
    {
        Console.WriteLine("@{0} {1}\n\n", tweet.User.ScreenName, tweet.Text);
    }
 
    Console.ReadKey();
}

A única novidade aqui é que estou selecionando um tweet específico na linha 4, no caso um tweet que tenha sido enviado por mim.

O resultado pode ser conferido na imagem abaixo (e se você me segue no twitter, deve ter visto estas mensagens também @vquaiato):

Retweet com TweetSharp em C#

Retweet com TweetSharp em C#

É isso aê! Deste jeito teremos um cliente para twitter pronto de forma bem simples e objetiva.

Recebi algumas dicas de outras bibliotecas para acessar o Twitter também, e em breve postarei algo aqui.
O @juloliveira indicou o Linq2Twitter.
O @brunokenj indicou o Twitterizer.
Logo mais falo sobre estas bibliotecas aqui.

Abraços, e lembrando que os comentários e dúvidas, críticas, etc, são sempre bem vindos.
Vinicius Quaiato.

TweetSharp: Acessando o Twitter com C#

Filed Under (.NET, Twitter) by Vinicius Quaiato on 19-02-2010

Tagged Under : , ,

twitter_bird

Fala galera, vou demonstrar como é simples acessar o Twitter utilizando a biblioteca TweetSharp e suas interfaces fluentes.

Primeiramente baixe as dlls do Tweetsharp aqui.

O TweetSharp é uma api que fornece acesso de forma simplificada à API do Twitter.

Vamos então criar um projeto utilizando o Visual Studio 2010 beta 2 porém estou utilizando a versão 3.5 para o projeto, pois existem alguns conflitos com o framework 4.
Estou criando uma Console Application, para que possamos ver uma saída gráfica do nosso código.

Vamos adicionar a referência para o TweetSharp em nosso projeto, como mostra a figura abaixo:

Adicionando Referencias TweetSharp

Adicionando Referencias TweetSharp

Feito isso vou criar 2 métodos. Um para para buscar os 10 últimos tweets da minha lista e o outro para exibir a lista de amigos.

Primeiramente inclua estes 3 statements using:

using Dimebrain.TweetSharp.Model;
using Dimebrain.TweetSharp.Fluent;
using Dimebrain.TweetSharp.Extensions;

No código acima estamos adicionando as referências para usarmos os métodos de extensão e as interfaces fluentes do TweetSharp e também as classes do mesmo.

Abaixo temos o método que busca os 10 últimos tweets:

1
2
3
4
5
6
7
8
9
10
11
12
13
private static IEnumerable<TwitterStatus> Obter10UltimosTweets()
{
    var search = FluentTwitter
                    .CreateRequest()
                    .AuthenticateAs("seuLogin", "suaSenha")
                    .Statuses()
                    .OnHomeTimeline()
                    .Take(10)
                    .AsJson();
 
    var result = search.Request();
    return result.AsStatuses();
}

Por utilizar interfaces fluentes O código fica bem simples e legível. Na linha 4 criamos um request utilizando a api do TweetSharp. Na linha 5 dizemos quais credenciais devem ser utilizadas. Na linha 6 informamos que queremos trabalhar com os “statuses” ou seja, os tweets. Na linha 7 dizemos que queremos os tweets que aparecem na nossa home, ou seja, de quem seguimos e os nossos também. Já na linha 8 pegamos apenas 10 destes tweets e os formatamos em Json na linha 9.
O código em si é realmente bastante legível.

E o nosso método main fica assim:

static void Main(string[] args)
{
    var tweets = Obter10ultimosTweets();
    foreach (var tweet in tweets)
    {
        Console.WriteLine("@{0} {1}\n\n", tweet.User.ScreenName, tweet.Text);
    }
 
    Console.ReadKey();
}

Este método é bem simples, apenas itera os elementos retornados pelo método anterior. As propriedades do objeto TwitterStatus podem ser conferidas com ajuda do intellisense ou então pressionado F12 sobre a classe.
O resultado pode ser visto na imagem abaixo:

10 Últimos Tweets com TweetSharp

10 Últimos Tweets com TweetSharp

Para exibir a lista de amigos vou utilizar o método abaixo:

1
2
3
4
5
6
7
8
9
10
11
12
public static IEnumerable<TwitterUser> ObterListaDeAmigos()
{
    var search = FluentTwitter
                    .CreateRequest()
                    .AuthenticateAs("seuLogin", "suaSenha")
                    .Users()
                    .GetFriends()
                    .AsJson();
 
    var result = search.Request();
    return result.AsUsers();
}

A diferença neste código para o anterior está na linha 6 onde informamos que queremos trabalhar com os usuários, e na linha 7 onde dizemos que queremos obter os friends, ou seja, as pessoas que estamos seguindo.

E alteramos o código do método main de forma que fique assim;

static void Main(string[] args)
{
    var tweets = Obter10ultimosTweets();
    foreach (var tweet in tweets)
    {
        Console.WriteLine("@{0} {1}\n\n", tweet.User.ScreenName, tweet.Text);
    }
 
    Console.WriteLine("\n\nLISTA DE AMIGOS\n\n");
 
    var amigos = ObterListaDeAmigos();
    foreach (var amigo in amigos)
    {
        Console.WriteLine("@{0}", amigo.ScreenName);
    }
 
    Console.ReadKey();
}

O resultado pode ser conferido na imagem abaixo:

Lista de amigos com TweetSharp

Lista de amigos com TweetSharp

Bom pessoal, é basicamente isso. A biblioteca TweetSharp oferece ainda diversos outros recursos, tudo que é necessário para se fazer um bom trabalho com o twitter.

Dúvidas, sugestões, reclamações: os comentários estão aí pra isso.

Att,
Vinicius Quaiato.

Coding Dojo .NET Architects – 30/01/2010 – São Paulo

Filed Under (.NET, Boas Práticas, Dojos, TDD) by Vinicius Quaiato on 29-01-2010

Tagged Under : , ,

Fala galera! Sábado, dia 30/01/2010 teremos um Coding Dojo, organizado pela comunidade .NET Architects.

Este Coding Dojo dará início ao grupo de Dojo do .NET Architects, que fará encontros regulares focando os dojos nas diversas linguagens e tecnologias .NET.

Local: Unip Jaguaré – São Paulo – SP
Horário: à partir das 10hs
Data: sábado, 30/01/2010

Confira o mapa do local e faça sua incrição aqui: http://dojo.dotnetarchitects.net
Totalmente gratuito!

Não existem pré-requisitos para participar, basta ter vontade e comparecer!

Saiba mais sobre Coding Dojo aqui.

Abraços, nos vemos lá!

Vinicius Quaiato.

Entity Framework 4 – Model First com POCOs

Filed Under (.NET, .NET 4.0, Boas Práticas, Entity Framework, Visual Studio 2010) by Vinicius Quaiato on 27-01-2010

Tagged Under : , ,

Fala galera, de buenas? Resolvi escrever um pouco sobre o Entity Framework 4.0 (na verdade é a versão 2 do EF mas para acompanhar o .NET 4.0 ele será chamado assim também).

Hoje vou mostrar uma característica bem interessante, que é o model first trabalhando com POCOs.
Model First diz respeito a primeiro criar suas entidades, ou seja, suas classes, e somente depois modelar o banco de dados – e é isto que queremos fazer quando desenvolvemos aplicações usando Orientação a Objetos, não é?
POCOs são classes simples, que não herdam nem implementam nenhuma outra classes/interface específica de frameworks, dizendo respeito exclusivamente ao nosso domínio e contendo apenas o necessário ao nosso domínio.

Para começar vamos criar um projeto de testes e adicionar um arquivo .edmx como mostra a figura abaixo:



Feito isso vamos selecionar o tipo de modelo “empty model”:

Selecionando o empty model

Selecionando o empty model


Pronto!
Vamos então adicionar duas entidades ao nosso design surface. Estas serão nossas entidades POCO, ou seja, não terão nenhuma dependência do Entity Framework, nem do Linq, nem de nada, é apenas o nosso modelo de classes, vamos ainda desabilitar a geração de código do Visual Studio, para que ele não “polua” as classes:


E então clicamos na parte branca do design e abrimos a janela de propriedades para desabilitar a geração de código:


Estamos a meio caminho andado. Pode parecer muito trabalho a ser feito, mas isso não leva mais do que 2 minutos. É realmente simples e os resultados são muito bons.
Agora vamos para a parte bacana, codificar nossas classes.
Vamos iniciar codificando as classes Pedido e ItemPedido, que são classes realmente bastante simples:

public class Pedido
{
    public virtual int Id { get; set; }
    private IList<ItemPedido> itens = new List<ItemPedido>();
    public virtual IList<ItemPedido> Itens
    {
        get { return this.itens; }
        set { this.itens = value; }
    }
}
 
public class ItemPedido
{
    public virtual int Id { get; set; }
    public virtual string Produto { get; set; }
    public virtual int Quantidade { get; set; }
    public virtual Pedido Pedido { get; set; }
}

Os virtuais que usamos nas nossas classes são para que o Entity Framework possa fazer o “tracking” dos nossos objetos. Internamente ele criará proxies para nossas classes. Em um primeiro momento basta colocarmos as propriedades como virtual e ele se encarregará de tudo, isso ainda ajudará no Lazy Loading.

Agora, como desabilitamos a geração de código, precisamos também criar o nosso contexto do EF. Isso é bastante simples, e neste cenário nos obrigará a escrever apenas umas 10 linhas de código, como pode ser visto abaixo:

public class EF4Context : ObjectContext
{
    public EF4Context()
        : base("name=EF4Container", "EF4Container") { }
 
    private IObjectSet<Pedido> pedidos;
    public IObjectSet<Pedido> Pedidos
    {
        get
        {
            if (pedidos == null)
                pedidos = CreateObjectSet<Pedido>();
 
            return pedidos;
        }
    }
}

Feito isso nos resta apenas gerar o banco de dados. Como dissemos, geramos primeiro nossas classes, sem nos preocupar em como estes dados seriam armazenados, conseguimos focar puramente no nosso domínio e no nosso modelo, afinal estamos pensando em classes e objetos, e não em linhas/tuplas de banco, chaves, índices, etc.
O Visual Studio irá gerar o código necessário para nosso banco de dados veja abaixo:


Agora é só executar o SQL gerado:


Se vocês fizeram tudo certinho até o momento, devem ser capazes de executar os seguintes códigos de testes com sucesso:

[TestMethod]
public void Deve_Adicionar_Um_Pedido_No_DB_Usando_Contexto_E_Poco()
{
    var contexto = new EF4Context();
 
    var pedido = new Pedido();
 
    pedido.Itens.Add(new ItemPedido
    {
        Produto = "Novo Produto",
        Quantidade = 5,
        Pedido = pedido
    });
 
    contexto.AddObject("PedidoSet", pedido);
    contexto.SaveChanges();
}

Depois este:

[TestMethod]
public void Deve_Obter_Todos_Os_Pedidos_Do_Banco_Usando_Contexto_E_Pocos()
{
    var contexto = new EF4Context();
 
    var pedidos = contexto.Pedidos.ToList();
 
    Assert.IsTrue(pedidos.Count > 0);
}

E por fim este:

1
2
3
4
5
6
7
8
9
10
11
12
13
[TestMethod]
public void Deve_Selecionar_1_Pedido_Do_Banco_Usando_Contexto_E_Pocos()
{
    var contexto = new EF4Context();
    contexto.ContextOptions.LazyLoadingEnabled = true;
 
    var pedido = contexto.Pedidos
                            .Where(p => p.Id == 1).Single();
 
    Assert.AreEqual(1, pedido.Id);
    Assert.IsTrue(pedido.Itens.Count > 0);
    Assert.AreEqual("Novo Produto", pedido.Itens[0].Produto);
}

Percebam como na linha 5 habilitamos o lazy loading para que as propriedades sejam carregadas no momento em que forem chamadas apenas.

E se fizermos uma consulta no banco de dados, veremos que de fato os dados estão lá:


Bom pessoal, é isso.
Esta é uma das funcionalidades presentes no Entity Framework 4.0. É claro que existe muita coisa a ser explorada ainda, e existem muitas coisas a serem feitas ainda, mas é um enorme avanço poder trabalhar com POCOs e utilizar os recursos de uma ferrmenta ORM como o EF. Poder dar “tchau” para os SqlConnection, SqlCommand, ExecuteScalar, etc, é algo realmente incrível.

Espero que tenham gostado. Dúvidas, críticas e sugestões me enviem email ou comentários.

Abraços,
Vinicius Quaiato.

ASP.NET MVC + JQuery

Filed Under (.NET, ASP.NET, ASP.NET MVC, Visual Studio 2010) by Vinicius Quaiato on 25-01-2010

Tagged Under : , , , ,

Neste artigo mostrarei um pouco de como usar o ASP.NET MVC com o Jquery para criar páginas mais dinâmicas e funcionais.

Este não é um artigo introdutório ao ASP.NET MVC, posso escrever sobre isso depois, e você pode encontrar tudo sobre o MVC do asp.net aqui: http://www.asp.net/mvc/.

Neste exemplo estou utilizando o VS2010 beta 2, Asp.Net MVC 2 e Jquery 1.3.2. Também utilizarei o plugin DataTables para o Jquery, que você deve baixar aqui: http://datatables.net/

Primeiramente vamos criar um website do tipo Asp.Net MVC no VS2010. Feito isso eu vou excluir todas as Views e Controllers que são criados por padrão, mantendo apenas os configs e a pasta Scripts.

Agora vamos criar um Controller para retornar uma lista de objetos, para que possamos montar um grid e executar algumas ações. Vou criar um Controller chamado HomeController, e adicionar o código abaixo:

public ActionResult Index()
{
    var items = new List<ExpandoObject>();
    for (int i = 0; i < 10; i++)
    {
        dynamic item = new ExpandoObject();
        item.Id = i + 1;
        item.Nome = string.Format("Item {0}", i + 1);
        item.Valor = 10 + i;
        item.Descricao = string.Format("Descricao do Item {0}", i + 1);
 
        items.Add(item);
    }
 
    ViewData["items"] = items;
    return View();
}

O código é bastante simples, cria apenas uma lista de ExpandoObjects e manda esta lista para a View(leia mais sobre ExpandoObjects aqui).

Agora crie uma pasta chamada Home dentro da pasta Views e então crie uma View chamada Index dentro da pasta Home, a solution deve ficar assim:

Solution com View e Controller

Solution com View e Controller

Vamos para o código .aspx da nossa View que deve ficar assim:

<%@ Page Language="C#" Inherits="System.Web.Mvc.ViewPage" %>
 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head id="Head1" runat="server">
    <title>HomeView</title>
</head>
<body>
    <div>
        <table id="dataTable">
            <thead>
                <tr style="background-color:#aabbcc; color:#fff;">
                    <th style="width: 50px;">
                        Id
                    </th>
                    <th style="width: 100px;">
                        Nome
                    </th>
                    <th style="width: 70px;">
                        Preço
                    </th>
                    <th style="width: 200px;">
                        Descrição
                    </th>
                </tr>
            </thead>
            <tbody>
                <%
                    var items = ViewData["items"] as List<System.Dynamic.ExpandoObject>;
                    foreach (dynamic item in items)
                    {
                %>
                <tr id="<%=item.Id %>">
                    <td>
                        <%=item.Id %>
                    </td>
                    <td>
                        <%=item.Nome %>
                    </td>
                    <td>
                        R$
                        <%=item.Valor.ToString("N2") %>
                    </td>
                    <td>
                        <%=item.Descricao %>
                    </td>
                </tr>
                <%} %>
            </tbody>
        </table>
    </div>
</body>
</html>

Tudo que este código faz é obter nossa lista de items e então desenhá-los na tela em forma de uma tabela.
Agora vamos usar o Jquery para ir até o servidor, excluir um item da lista no servidor, e então removê-lo da lista no client utilizando Ajax.

Para isso incluiremos uma referência para o Jquery em nossa View. O Jquery já vem junto com os projetos MVC do asp.net em sua versão 2, basta arrastar o arquivo da pasta Scripts para dentro da View que a referência é adicionada:

<head id="Head1" runat="server">
    <title>HomeView</title>
    <script src="../../Scripts/jquery-1.3.2.js" type="text/javascript"></script>
</head>

Agora vamos criar uma function javascript que fará a chamada via Ajax para o Controller:

1
2
3
4
5
6
7
8
9
10
function Remover(action, param) {
    $.post(action + "/" + param,
    function (data) {
        alert(data);
 
        $("#" + param).fadeOut("slow");
    });
 
    return false;
}

Esta function recebe 2 parâmetros, o primeiro é o nome da Action que executaremos no Controller, e o segundo é o parâmetro que passaremos, nesse caso o id do nosso item.
A linha 2 utiliza uma função do Jquery para fazer chamas Ajax usando post. O primeiro parâmetro é a url a ser chamada, no nosso exemplo será algo como “remover/5″. O segundo parâmetro é uma function de callback, que será executada depois que a resposta vier do servidor, e o que estamos fazendo é exibindo a resposta, e então removendo da nossa tabela a linha excluída, utilizando uma animação do Jquery chamada fadeOut.

No nosso Controller adicionaremos um método para simular a exclusão do item, como pode ser visto abaixo:

[AcceptVerbs(HttpVerbs.Post)]
public string Remover(int id)
{
    return string.Format("removeu item: {0}", id);
}

Tudo que esta Action faz é retornar uma string dizendo que o item foi removido.
Agora precisamos fazer com que exista um link na nossa tabela para executar esta ação, e para isso incluiremos mais uma coluna, a coluna Ação, e este código será necessário para renderizar os dados:

<td>
    <a href="remover/<%=item.Id %>" onclick="return Remover('remover','<%=item.Id %>')">
        Remover</a>
</td>

Pronto! Agora já temos uma tabela capaz de excluir itens usando Ajax e ainda ter a linha removida da tabela utilizando um efeito bem bacana.

E para deixar as coisas um pouco mais “profissionais” vamos deixar esta tabela com cara e comportamente de grid, usando o plugin DataTables.
Para isso inclua o arquivo jquery.dataTables.js que você baixou dentro da pasta Scripts, e então arraste o mesmo até a View, para incluir a referência.
Agora coloque o seguinte código javascript dentro do da sua view:

$(document).ready(function () {
    $("#dataTable").dataTable();
});

Este código irá aplicar o plugin na nossa tabela, e o resultado será como mostrado abaixo:

table usando plugin DataTables

table usando plugin DataTables

Agora podemos filtrar, ordenar e paginar nossos dados, sem nenhum esforço adicional, veja um exemplo de filtro abaixo:

plugin DataTable filtrando dados

plugin DataTable filtrando dados

Bom galera, é isso!
O código fonte desta solução está disponível aqui.

Qualquer dúvida, email ou comentários.

Abraços,
Vinicius Quaiato.

IronRuby: Rodando Ruby dentro do .NET

Filed Under (.NET, .NET 4.0, IronRuby) by Vinicius Quaiato on 21-01-2010

Tagged Under : , , ,

O IronRuby é um port da linguagem Ruby para ser executada juntamente com o .Net Framework.
Atualmente o IronRuby está em release candidate(versão 1.0 – RC1), e em algum tempo devemos ter a versão oficial.

A idéia aqui não é descrever em pormenores os detalhes da linguagem Ruby, pois inúmeras referências podem ser encontradas na web: Ruby on Br é uma delas.

Vou demonstrar como começar a utilizar o IronRuby juntamente com as bibliotecas do .Net e como produzir algum código.

Vamos iniciar instalando o IronRuby, e para isso faça o download no site oficial do Ironruby no CodePlex aqui. Eu utilizei a versão Windows Installer.
Execute este instalador após o download, ele irá extrair os arquivos para uma pasta especificada.

Assim como a maioria das linguagens dinâmicas o IronRuby possui um console interativo, onde podemos escrever código e testar seu uso. E é desta forma que trabalharemos neste primeiro momento.

Execute o console do IronRuby, que deve ser encontrado na [pasta de instalação]\bin\ir.exe.

Você deverá ver uma tela semelhante a esta:

IronRuby Console

IronRuby Console

Agora já podemos começar a escrever nosso código Ruby/IronRuby.
Como nosso primeiro código, vamos criar uma classe que terá apenas um método, um famoso Olá Mundo:

class OlaIronRuby
    def DigaOi
	puts "Olá Mundo IronRuby!"
    end
end

Quando digitarmos esse código no console do IronRuby esta classe estará disponível para uso, e a utilizaremos assim:

instancia = OlaIronRuby.new

E fazemos a chamada para o método assim:

instancia.DigaOi

Abaixo vocês conferem todo o código no console do IronRuby:

Criando instancia de classe no IronRuby

Criando instancia de classe no IronRuby

Agora vamos criar uma nova classe que irá trabalhar com bibliotecas do framework.
Para referenciarmos um assembly no console, vamos utilizar o require ‘nome do assembly’, como pode ser visto no código abaixo, onde utilizamos o WindowsForms.MessageBox para exibir uma mensagem usando o IronRuby:

require 'System.Windows.Forms'
 
System::Windows::Forms::MessageBox.show "Olá MessageBox!"

E o resultado podemos ver aqui:

Usando MessageBox com IronRuby

Usando MessageBox com IronRuby

Podemos ainda criar aplicações WPF por exemplo. Para isso vamos digitar nosso código em um arquivo e salvá-lo como WpfIronRuby.rb, o código pode ser visto abaixo:

require 'wpf'
include Wpf
 
janela = Wpf::Window.new
janela.Title = 'WPF com IronRuby'
janela.content = Wpf::TextBlock.new
janela.content.text = "Janela WPF usando IronRuby!"
janela.content.font_size = 60
 
app = Application.new
app.run janela

Para este código funcionar eu copiei o arquivo wpf.rb da pasta [instalação do ironruby]\Samples\Tutorial\app\wpf.rb para [instalação do ironruby]\Lib\ironruby

Para executar a aplicação eu abri o command do windows e naveguei a até a pasta onde salvei o arquivo, no meu caso o Desktop e digitei: ir.exe WpfIronRuby.rb como pode ser visto na imagem abaixo:



Rodando aplicação Wpf com IronRuby

Rodando aplicação Wpf com IronRuby

Bom galera, é isso.
O ironRuby ainda está saindo do forno, e com certeza será(e já é) uma grande soma para o .Net Framework.

Qualquer dúvida, mail-me ou comentem.

Abraços,
Vinicius Quaiato.

Injeção de Dependência com MS Unity

Filed Under (.NET, Boas Práticas, Patterns) by Vinicius Quaiato on 18-01-2010

Tagged Under : , , , ,

Bom pessoal, pudemos ver os benefícios e alguns usos de Inversão de Controle e Injeção de Dependências aqui e aqui.

Uma das formas de obter excelentes ganhos com a inversão de controle é através da utilização de um contêiner de Injeção de Dependências.

Um contêiner de injeção de dependências é capaz de criar objetos com todas suas dependências injetadas e totalmente pronto para uso. Em geral estes conteiners podem ser configurados manualmente(programaticamente) ou dinamicamente(através de arquivos de configuração por exemplo).

Falaremos um pouco do Unity que é um contêiner de Injeção de Dependência que faz parte dos Application Blocks da Microsoft.

Para que vejamos como o Unity funciona faça o download do mesmo aqui e execute o setup, que irá apenas criar uma pasta com as DLLs do Unity.

O Unity, como veremos nos exemplos, suporta 3 tipos de injeção de dependência:

  • Constructor Injection (injeção por construtor)
  • Property Injection (injeção de propriedade)
  • Method Call Injection (injeção de chamada de métodos)

Vamos usar como exemplo estas classes e interfaces:

public interface ILogger
{
    void RegistrarMensagem(string mensagem);
}
 
public class SqlLogger : ILogger
{
    public void RegistrarMensagem(string mensagem)
    {
        //abre conexão SQL
 
        //Executa insert da mensagem
    }
}
 
public class EnviadorDeEmails
{
    public ILogger Logger { get; set; }
    public EnviadorDeEmails(ILogger logger)
    {
        this.Logger = logger;
    }
    public void EnviarEmail(string email, string mensagem)
    {
        //Envia email
 
        //registra envio
        this.Logger.RegistrarMensagem(string.Format("Email enviado para {0}", email));
    }
}

Adicione as seguintes referências ao seu projeto: Microsoft.Practices.ObjectBuilder2.dll e Microsoft.Practices.Unity.dll que se encontram na pasta que você “instalou” o Unity, como pode ser visto na figura abaixo:
Incluindo Dlls do Unity

As classes acima são bem simples, no final das contas o que faremos é com que o Unity crie um EnviadorDeEmails com a dependência de ILogger injetada e resolvida, ou seja, que ele crie um EnviadorDeEmails passando para ele um SqlLogger. Para isso vamos “ensinar” ao Unity como resolver a interface ILogger, como pode ser visto no código abaixo:

1
2
    var unityContainer = new UnityContainer();
    unityContainer.RegisterType<ILogger, SqlLogger>();

Na linha 1 criamos uma instância do contêiner do Unity. Na linha 2 dizemos para o Unity que quando quisermos o tipo ILogger (interface) ele deve utilizar a classe concreta SqlLogger. Simples assim.

Constructor Injection

Agora podemos mandar que o Unity construa nosso EnviadorDeEmails usando constructor injection, conforme visto abaixo:

1
2
3
4
5
6
7
8
9
10
[TestMethod]
public void Configurando_Unity_Para_Resolver_ILogger()
{
    var unityContainer = new UnityContainer();
    unityContainer.RegisterType<ILogger, SqlLogger>();
 
    var enviadorEmails = unityContainer.Resolve<EnviadorDeEmails>();
 
    Assert.IsInstanceOfType(enviadorEmails.Logger, typeof(SqlLogger));
}

O grande segredo aí está na linha 7 onde dizemos para o Unity construir nosso EnviadorDeEmails. O Unity percebe que existe uma dependência no construtor do EnviadorDeEmails, e baseado na configuração que fizemos ele sabe como resolver esta dependência. Na linha 9 apenas verificamos se de fato o ILogger utilizado é o SqlLogger, e executando o teste obtemos sucesso.
E notem que neste caso utilizamos o constructor injection pois a classe EnviadorDeEmails possui um construtor com uma dependência para uma interface, que o Unity conhece.

Property Injection

Poderíamos dizer que a dependência não deve ser resolvida via construtor, mas sim diretamente na propriedade, para isso alteraríamos a classe EnviadorDeEmails assim:

1
2
3
4
5
6
7
8
9
10
11
12
public class EnviadorDeEmails
{
    [Dependency]
    public ILogger Logger { get; set; }
    public void EnviarEmail(string email, string mensagem)
    {
        //Envia email
 
        //registra envio
        this.Logger.RegistrarMensagem(string.Format("Email enviado para {0}", email));
    }
}

A única diferença aqui foi a utilização do DependencyAttribute na linha 3 para marcar que a propriedade Logger, do tipo ILogger, deve ser resolvida pelo Unity.
Executando nosso teste mais uma vez devemos obter sucesso.

Method Call Injection

A outra forma que o Unity tem para injetar nossas dependências é através da chamada de um método. Por exemplo, imaginem que temos um método Initialize na nossa classe, que é responsável por criar os objetos que nossa classe precisa. Podemos fazer com que o Unity execute este método resolvendo todas as dependências.
Vejamos o código da classe EnviadorDeEmails utilizando um Method Call Injection:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class EnviadorDeEmails
{
    public ILogger Logger { get; set; }
    public void EnviarEmail(string email, string mensagem)
    {
        //Envia email
 
        //registra envio
        this.Logger.RegistrarMensagem(string.Format("Email enviado para {0}", email));
    }
 
    [InjectionMethod]
    public void Inicializador(ILogger logger)
    {
        this.Logger = logger;
    }
}

Tudo o que fizemos desta vez foi criar um método, neste caso o método Inicializador, na linha 13, que recebe como parâmetros as dependências da nossa classe. E marcamos este método com o InjectionMethodAttribute, para dizer ao Unity que este método deve ser chamado e resolvidor por ele na criação de nosso EnviadorDeEmails.
E novamente se executarmos o mesmo método de teste, obteremos sucesso.

Como vimos nos três exemplos acima, o Unity após configurado consegue resolver as dependências de nossas classes de forma simples e trivial. Basta alterarmos a forma de resolução da dependência, por exemplo de constructor para setter, e nada no código mudará, assim como se mudar de SqlLogger para XmlLogger, nada no código mudará, apenas a configuração do Unity.

Bom galera, é mais ou menos isso. O Unity é uma ferramenta bastante poderosa, extensível e simples de usar.

Qualquer dúvida é só escrever nos comentários ou enviar email.

Abraços,
Vinicius Quaiato.