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.

Related posts:

1. TDD na .Net Magazine 69

Capa .NET Magazine #71

Foi publicado mais um artigo meu na .Net Magazine, edição 71.

O artigo fala sobre Dynamic Types e mostra alguns cenários de utilização das novas funcionalidades dinâmicas incorporadas ao .Net Framework 4.0.
Uma pequena amostra pode ser conferida aqui: http://www.devmedia.com.br/articles/viewcomp.asp?comp=16159

Esta edição está bem bacana, focando principalmente nas novidades do .Net 4.0 e do Visual Studio 2010. Vale conferir, temos também os seguintes artigos das feras:

• .Net Brasil – Por: Rodrigo Sendin
• Dynamic types – Por: Vinicius Quaiato
• Dicas para otimizar o acesso ao SQL Server – Por: Danielle da Silva Monteiro
• Visual Studio 2010 e .NET 4.0 – Por: Leandro Daniel
• Criando controles personalizados no ASP.NET – Por: Thomas Alexander
• SharePoint – Por: Braian Takahira
• Produtividade com T4 – Por: Rodrigo Sendin
• Desenvolvimento Desktop no .NET – Por: Everton Coimbra de Araújo
• ASP.NET e ADO.NET – Por: Erysson Batista Barros de Souz

Deve chegar nas bancas nos próximos dias!

Por favor dêem seu feedback, é realmente muito importante!

Abraços,
Vinicius Quaiato.

Related posts:

1. TDD na .Net Magazine 69
2. ExpandoObject: dinamismo no .NET 4.0

Vamos fazer um exemplo bem simples, trabalhando com produtos e lojas. Cada produto poderá estar em muitas lojas, e uma loja poderá conter muitos produtos.
Abaixo temos o desenho de nosso modelo inicial:

Modelo de Classes Entity Framework 4.0

Feito isso vamos criar uma associação entre nossas entidades, como pode ser visto abaixo:

Criando associação no modelo do EF 4.0

Definindo a Associacao Many-To_Many no EF 4.0

Feito isso basta salvarmos nosso modelo e gerar o banco de dados. Lembrando de desmarcar a opção de geração de código no modelo (veja aqui como fazer isso).

Nossas classes ficarão simples, como não poderia deixar de ser.
Abaixo vemos a classe Produto, que como pode-se notar não possui nenhuma dependência do entity Framework e nem conhece nada relacionado com banco de dados:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class Produto
{
    public virtual int Id { get; set; }
    public virtual string Nome { get; set; }
    public virtual decimal ValorSugerido { get; set; }
    private IList<Loja> lojasOndeVende = new List<Loja>();
    public virtual IList<Loja> LojasOndeVende
    {
        get
        {
            return this.lojasOndeVende;
        }
        set
        {
            this.lojasOndeVende = value;
        }
    }
}

Abaixo temos a classe Loja:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class Loja
{
    public virtual int Id { get; set; }
    public virtual string Nome { get; set; }
    public virtual string Cidade { get; set; }
    private IList<Produto> produtosQueVende = new List<Produto>();
    public virtual IList<Produto> ProdutosQueVende
    {
        get
        {
            return this.produtosQueVende;
        }
        set
        {
            this.produtosQueVende = value;
        }
    }
}}

E aqui temos nossa classe de contexto do Entity Framework, que também criamos, de forma bastante simples:

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

public class EF4Context : ObjectContext
{
    public EF4Context()
        : base("name=ModeloManyToManyContainer", "ModeloManyToManyContainer") { }
 
    private IObjectSet<Produto> produtos;
    public IObjectSet<Produto> Produtos
    {
        get
        {
            if (produtos == null)
                produtos = CreateObjectSet<Produto>();
 
            return produtos;
        }
    }
 
    private IObjectSet<Loja> lojas;
    public IObjectSet<Loja> Lojas
    {
        get
        {
            if (lojas == null)
                lojas = CreateObjectSet<Loja>();
 
            return lojas;
        }
    }
}

E isto é tudo que precisamos. Já podemos trabalhar com nossas entidades de forma a terem a relação Many-to-Many feita e funcionando.
Criei uma aplicação console para demonstrar isso. O método abaixo faz algumas inserções no banco, e o resultado da consulta pode ser visto na imagem a seguir:

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

private static void InserirNovosProdutosELojas()
{
    var contexto = new EF4Context();
 
    var produto = new Produto();
    produto.Nome = "Produto de Soja";
    produto.ValorSugerido = 10;
 
    var produto2 = new Produto();
    produto2.Nome = "Produto de tofu";
    produto2.ValorSugerido = 10;
 
    var loja = new Loja();
    loja.Nome = "Loja do Vinicius";
    loja.Cidade = "São Paulo";
    loja.ProdutosQueVende.Add(produto);
 
    var loja2 = new Loja();
    loja2.Nome = "Loja Vegetariana";
    loja2.Cidade = "São Paulo";
    loja2.ProdutosQueVende.Add(produto);
    loja2.ProdutosQueVende.Add(produto2);
 
    contexto.AddObject("Produtos", produto);
    contexto.AddObject("Produtos", produto2);
    contexto.AddObject("Lojas", loja);
    contexto.AddObject("Lojas", loja2);
 
    contexto.SaveChanges();
 
    Console.ReadKey();
}

Reparem que apenas adicionamos os produtos nas lojas, e não precisamos adicionar as lojas aos produtos também. O Entity Framework é esperto para fazer essa associação.

Aqui podemos ver uma saída gráfica das nossas relações:

Resultado da relação Many-to-Many

Bom pessoal, éisso aê. A relação Many-to-Many com POCOs no Entity Framework 4.0 é bastante simples e natural. Não requer passos adicionais e nem complicados.

Qualquer dúvida, crítica ou sugestão, deixem seus comentários ou podem escrever email.

Att,
Vinicius Quaiato.

Related posts:

1. Entity Framework 4 – Model First com POCOs

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.

Related posts:

1. Coding Dojo .NET Architects – 30/01/2010 – São Paulo
2. Podcast Princípios SOLID – .NET Architects
3. TDD na .Net Magazine 69

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:

Adicionando arquivos js Asp.Net Ajax Library 4.0

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

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.

Related posts:

1. ASP.NET MVC + JQuery
2. DynamicObject: dinamismo no .NET 4.0

Parallel LINQ, ou PLINQ, é uma implementação do padrão LINQ que trabalha de forma paralela sobre qualquer fonte de dados em memória que implemente IEnumerable ou IEnumerable<T>, possuindo ainda a execução adiada até o momento em que a query é enumerada, ou seja, de fato utilizada.

Umas das novidades é o extension AsParallel que está disponível em IEnumerable e IEnumerable<T>. AsParallel diz que à partir daquele momento as operações realizadas sobre aquela fonte de dados serão executas de forma paralela, é bem simples. O código abaixo demonstra isso:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

static void Main(string[] args)
{
    var numeros = Enumerable.Range(0, 10);
 
    var dobrados = from n in numeros.AsParallel()
                   select Dobro(n);
 
    foreach (var dobro in dobrados)
        Console.WriteLine(dobro);
 
    Console.ReadKey();
}
 
private static int Dobro(int numero)
{
    Thread.Sleep(500);
    return numero * 2;
}

Como vemos na linha 5 estamos chamando o método AsParallel na nossa coleção de números. Então apenas chamamos um método passando o número como parâmetro. Este método apenas congela a thread por meio segundo para que possamos notar como os valores são executados de forma paralela. Na imagem abaixo temos o resultado:

Enumerando com AsParallel do PLINQ

O PLINQ também permite de forma simples e fácil especificar quantos processadores queremos utilizar para executar as operações paralelas. É possível especificar até um máximo de 64 processadores (ô loco meu!).
Abaixo segue a alteraçãono código anterior especificando 2 processadores a serem utilizados (só tenho 2):

5
6

    var dobrados = from n in numeros.AsParallel().WithDegreeOfParallelism(2)
                   select Dobro(n);

Na linha 5 do nosso código adicionamos uma chamada para a extensão WithDegreeOfParallelism e passamos como parâmetro o total de processadores a ser utilizado. No mais o código permanece exatamente igual.

Outro recurso bastante interessante é realizar o processamento paralelo e conseguir que o resultado seja ordenado. Isso é possível utilizando a extension AsOrdered.
No código anterior poderíamos utilziar AsParallel e continuar realizando o processamento de forma paralela mas mantendo a saída ordenada, como pode ser visto abaixo:

5
6

    var dobrados = from n in numeros.AsParallel().AsOrdered()
                   select Dobro(n);

A saída pode ser vista na imagem abaixo:

PLINQ usando AsParallel com AsOrdered

Existem ainda diversos recursos no PLINQ. Em breve abordarei mais sobre eles aqui.
Uma boa documentação está disponível no MSDN aqui, aqui e aqui.

Comentários, críticas e sugestões, basta escrever.

Att,
Vinicius Quaiato.

Related posts:

1. Visual Studio 2010 – Novas Features – Parallel For

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

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#

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

Related posts:

1. TweetSharp: Acessando o Twitter com C#

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

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

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

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.

Related posts:

1. Postando no Twitter com TweetSharp em C#

O link para download é este: http://www.microsoft.com/downloads/details.aspx?FamilyID=457bab91-5eb2-4b36-b0f4-d6f34683c62a&displaylang=en

Você pode obter mais informações sobre esta versão aqui: http://msdn.microsoft.com/pt-br/vstudio/dd582936.aspx

Algumas informações (comentários, bugs e melhorias) podem ser vistas aqui no blog do Scott Guthrie.

Estou preparando mais alguns posts sobre funcionalidades do VS2010, e logo mais estarão por aqui.

É isso, espero que utilizem, dêem seu feedback, e se divirtam!

Att,
Vinicius Quaiato.

Related posts:

1. Visual Studio 2010 – Novas Features – Parallel For
2. Visual Studio 2010 – Novas Features – Generate from usage
3. Visual Studio 2010 – Novas Features – Docking Janelas

Não basta contratar o profissional com o maior conhecimento técnico disponível no mercado. Este conhecimento técnico pode ser, e acredite que é, suprimido pela falta de motivação. E se você quer que sua empresa, time, equipe, etc, esteja entre os melhores:

• Conheça os anseios e desejos deste profissional – Entenda o que ele almeja, e ajude-o a conquistar
• Dê a ele a chance de participar – Faça-o parte de um time
• Invista nele, além do salário – Apagar incêndio é importante, mas permita-o crescer
• Preocupe-se com a qualidade técnica do trabalho executado – Mostre que o que ele faz tem valor
• Fuja dos modelos organizacionais batidos e ultrapassados – Se quer mentes brilhantes, inove!
• Crie um ambiente colaborativo – É muito melhor trabalhar em grupo
• Mostre a ele que perder a batalha não é perder a guerra – Participe com ele das derrotas e construam vitórias juntos
• Desafie-o constantemente – Os melhores aguentam a pressão e criam soluções inesperadas
• Deseje tê-lo em sua equipe – Mostre o quão importante é sua participação

O mercado está cheio de profissionais medíocres, que se contentam em receber um contra-cheque no final do mês, porém, o mercado é construído por aqueles que se importam com os itens mencionados acima.

Um profissional brilhante pode tornar-se medíocre em razão do ambiente desfavorável, e quando isso acontecer, esteja certo, ele vai abandonar este time.
Não se pode apagar mentes brilhantes, então se você realmente deseja tê-las em sua equipe, faça por merecer. Cultive os talentos que você possui na sua empresa.
Cultive os seus diamantes!

Mantenha seus profissionais motivados, e eles terão os melhores resultados. Eles farão a diferença. Eles se importarão com o que fazem. Eles se importarão com o que entregam. Farão com qualidade. Participarão das decisões, evitarão cometer erros. Assumirão os erros.

Se você deseja resultados medíocres, se deseja apenas pagar incêndios, e receber de seus clientes, não se importe com nada do que foi dito. Agora, se você deseja que sua empresa se destaque, se deseja os melhores profissionais, se quer fazer diferente e tornar-se referência, não atue da mesma maneira que os medíocres, faça de sua empresa uma empresa brilhante.

Motivação matters.

Att,
Vinicius Quaiato.

No related posts.