Twitter API e C#: um tutorial – parte 3

E aí, beleza? Essa é a terceira e última parte desse xodózinho que eu tenho escrito: um tutorial de como fazer uma aplicação simples com a Twitter API e C#. Na parte 1, criamos nossa app na Twitter e pegamos as chaves de consumo que precisávamos e na parte 2 salvamos nossas chaves em um XML no projeto e fizemos a classe de autorização. Vamos finalizar, pegando os tweets e mostrando-os no nosso Console?

Um homem está sentado na frente do PC coçando o queixo enquanto a frase "I am a programming god!" aparece.
Eu sou um deus da programação!

Somente relembrando que este tutorial está dividido em três partes:

  1.  Criação da app no Twitter, na parte destinada à desenvolvedores, e vamos perceber quais partes dela são importantes para nós no projeto (spoiler: as chaves)
  2. Criação e configuração do projeto no Visual Studio, da maneira que eu gosto, e criação da classe de autorização (que é quem vai te ligar de fato à API do Twitter)
  3. 👉Construção do método de “pegar” tweets de um usuário e exibição em um console (desculpem amigos, se eu fosse fazer algo com mais firula, esse tutorial seria beeeeem mais longo)

Instalando o Newtonsoft

Para esse tutorial, vamos precisar instalar uma biblioteca via NuGet chamada Newtonsoft.Json. É ela quem vai nos ajudar a deserializar a resposta JSON do Twitter para o nosso objeto.

Clique com o botão direito no projeto, vá até Manage NuGet Packages… (Gerenciar pacotes do NuGet) e vai aparecer uma nova aba no seu Visual Studio. É só digitar Newtonsoft no campo de busca, clicar no resultado Newtonsoft.Json e ir em Install (Instalar). Pode instalar a versão mais recente mesmo.

✳ Caso você precise de mais detalhes sobre como instalar pacotes com o NuGet, nesse meu post sobre testes automatizados com C# e Selenium eu explico o processo de maneira mais detalhada. Também pode ficar à vontade para entrar em contato em caso de dúvidas, OK?

Imagem detalhando a aba do NuGet, conforme explicado nos parágrafos acima.
Aqui no meu o botão está como “Update” porque eu já tenho o pacote instalado, mas o “Install” vai ficar ali na mesma posição.

Método GetTweets()

Bora codar que nem só de cliques vive o nosso projeto!

Crie uma nova classe, aqui vou chamá-la de TwitterApi.cs (botão direito no projeto > Add (adicionar) > Class… (Classe…) > renomeie a classe > Add (adicionar)). A nossa classe, com o nosso método de GetTweets(), vai ficar da seguinte forma:

public class TwitterApi
{
    public dynamic GetTweets()
    {
        Authorization authorization = new Authorization();
        string accessToken = authorization.GetAccessToken();

        var getTimeline = WebRequest.Create(@"https://api.twitter.com/1.1/statuses/user_timeline.json?" +
                                            "screen_name=oliviamattiazzo&" +
                                            "count=10&" +
                                            "include_rts=false&"+
                                            "tweet_mode=extended") as HttpWebRequest;
        getTimeline.Method = "GET";
        getTimeline.Headers[HttpRequestHeader.Authorization] = "Bearer " + accessToken;

        dynamic responseItems;
        try
        {
            string respBody = null;
            using (var resp = getTimeline.GetResponse().GetResponseStream())
            {
                var respR = new StreamReader(resp);
                respBody = respR.ReadToEnd();
            }

            responseItems = JsonConvert.DeserializeObject(respBody);
        }
        catch
        {
            throw new Exception("Error getting tweets!");
        }

        return responseItems;
    }
}

A primeira coisa que estamos fazendo no método é: através de uma instância da nossa classe de autorização (Authorization.cs), chamamos o método GetAccessToken(), que vai nos prover o token de acesso que precisamos para nos conectar à API do Twitter (fizemos isso na parte 2 do tutorial).

Depois disso, criamos uma WebRequest, com o endereço que precisamos da API (https://api.twitter.com/1.1/statuses/user_timeline.json), juntamente com os parâmetros que queremos buscar. No exemplo, estou solicitando os 10 últimos tweets (count=10) da minha conta (screen_name=oliviamattiazzo), sem incluir retweets (include_rts=false) e que os tweets venham de forma extendida (tweet_mode=extended), para que possamos ter o texto todo na resposta da nossa request. Aí no seu você pode colocar os parâmetros que desejar: se você quer mais tweets, menos tweets, da sua conta, da conta de alguém que você gosta… Fica totalmente à seu critério.

Também deixamos claro para a WebRequest que estamos fazendo um GET à API e enviamos na header o token de acesso que recuperamos antes disso tudo.

Dentro do try-catch, esperamos que nos seja enviada a resposta dessa request e a deserializamos, através do pacote Newtonsoft, para uma variável do tipo dynamic. Assim não precisamos modelar uma classe.

Ao final desse processo todo, retornamos a variável com a resposta e poderemos usá-la no nosso Main(), para mostrar os tweets no nosso Console.

Uma pessoa clica em um botão escrito "Tweet" e passarinhos saem do celular

Tipo dynamic, WTF?

Trabalhando com a Twitter API e o C#, descobri uma coisa nova: o tipo dynamic. Eu sabia que ele existia, mas não sabia muito bem como funcionava, nem como aplicá-lo; honestamente, ainda não tive muito tempo para estudar mais a à fundo sobre ele. Então, fica aqui prometido, em breve, um post mais completo sobre o tipo dynamic, escrito com mais tempo e carinho, com exemplos de utilização e tudo (assim me forço a estudá-lo). Por hora, deixo a definição do tipo dynamic de acordo com a documentação da Microsoft:

O C# 4 apresenta um novo tipo, dynamic. O tipo é um tipo estático, mas um objeto do tipo dynamic ignora a verificação de tipo estático. Na maioria dos casos, ele funciona como se tivesse o tipo object. Em tempo de compilação, supõem-se que um elemento que tem o tipo dynamic dá suporte a qualquer operação. Portanto, você não precisa se preocupar se o objeto obtém seu valor de uma API COM, de uma linguagem dinâmica como o IronPython, do HTML DOM (Modelo de Objeto do Documento), a reflexão ou de algum outro lugar no programa. No entanto, se o código não for válido, os erros serão capturados em tempo de execução.

Documentação da Microsoft

Vamos ver o resultado!

Tudo que precisamos para rodar está feito! Vamos fazer esses tweets aparecerem no nosso console então.

Lá na classe Program.cs, você vai adicionar esses dois métodos:

static void Main(string[] args)
{
    TwitterApi twitterApi = new TwitterApi();
    dynamic tweets = twitterApi.GetTweets();

    foreach(dynamic t in tweets)
    {
        Console.WriteLine($"{t.user.name} (@{t.user.screen_name}) em {AjustaDataHora(t.created_at)}\n" +
                            $"{t.full_text}\n");

        Console.WriteLine("*********************************************\n");
    }
}

private static string AjustaDataHora(dynamic dynamicDate)
{
    //Date time format example: Thu Oct 17 20:06:45 + 0000 2019
    DateTime dataHora = DateTime.ParseExact(dynamicDate.ToString(), "ddd MMM dd HH:mm:ss K yyyy", CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal);
    return dataHora.ToString("g", CultureInfo.CreateSpecificCulture("pt-BR"));
}

O primeiro método é o famoso Main(). Tudo o que está contido nele vai ser executado logo que você rodar o programa. No caso, só precisamos instanciar a classe TwitterApi e atribuir à uma variável de tipo dynamic o resultado do nosso método GetTweets(). Essa é a beleza do tipo dinâmico: você não precisa especificar que o retorno do método é uma lista de um determinado tipo: o compilador vai compreender isso instantaneamente. (Também é o perigo desse tipo né, porque todos os erros vão ser pegos em tempo de execução. É como diz o ditado: cada escolha, uma perda 😅)

Dentro do Main() ainda, há um trecho de código que vai rodar todos os elementos retornados pelo GetTweets() e vai printá-los no nosso Console. Eu fiz de forma bem simples, mostrando somente o nome do usuário (user.name), o “arroba” do usuário (user.screen_name), a data e hora do tweet (created_at) e o texto completo (full_text). É importante você escrever bem certinho os caminhos e os nomes das propriedades quando estiver usando o tipo dinâmico: se ele não encontrar, vai ser lançado um erro em tempo de execução e não queremos isso, belê?

Para mostrar a data e hora de uma maneira mais compreensível para nós, brasileiros, também fiz o método logo abaixo do Main(), o AjustaDataHora(), recebendo como parâmetro um tipo dinâmico. Fique à vontade para adicionar qualquer perfumaria que você ache melhor na sua versão!

Eis o meu resultado final (para executar, só pressionar F5 ou o botão de play lá em cima):

Imagem com os tweets mais recentes da conta @oliviamattiazzo printados em um console do .NET

C’est fini!

Espero que você tenha gostado e aprendido mais sobre a Twitter API e C# com esse tutorial. Mesmo eu tendo feito um projeto usando essas tecnologias, escrever esses três posts me ajudou muito a fixar conhecimento e também pesquisar algumas coisas mais teóricas.

Lembrando sempre que feedback é muito bem vindo! Nos vemos numa próxima! 😚✌


🔄 Atualizações


📜 Posts relacionados

Twitter API e C#: um tutorial – parte 1

Twitter API e C#: um tutorial – parte 2

Um novo projeto pessoal: o Hey, Pepita bot!


📩 Recadinhos da paróquia

Gostou do texto? Tem algo a adicionar? Alguma crítica construtiva? Feedbacks? Sugestões? Pedidos? Fique à vontade para me contatar via email (oli.pmatt@gmail.com), via Twitter (@oliviamattiazzo) ou pela caixa de comentários aqui embaixo! Vai ser um prazer conversar contigo! ✨

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Esse site utiliza o Akismet para reduzir spam. Aprenda como seus dados de comentários são processados.