Twitter API e C#: um tutorial – parte 2

Oi! Seja bem vindo à segunda parte do meu singelo tutorial de como fazer uma aplicação simples com a Twitter API e C#. Na parte 1 nós criamos a nossa app no Twitter for Developers e pegamos as consumers keys que vamos precisar para conectar a nossa aplicação ao Twitter. Agora vamos de fato iniciar a programação do nosso sisteminha! Bora codar juntos?

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)

Caso surja alguma mudança na trajetória enquanto esse tutorial está nascendo, prometo atualizar a listinha acima no próximo post! 

---

Salvando suas chaves no código

Antes de mais nada, abra seu Visual Studio e crie uma nova solução, com um projeto do tipo Console App. Coloque um nome bonitinho nele e salve onde for melhor para você.

⚠️ Comecei a usar o VS2019 e criei um Console App do .NET Core. Ainda não sei quais são as grandes diferenças dele pro Entity Framework, vou descobrir junto com vocês!

Projeto criado, vamos começar “salvando” as chaves da sua App no código, em um arquivo XML. Clique com o botão direito no seu projeto e vá em Add (Adicionar) > New Item… (Novo Item…). Procure por “xml” na busca e adicione o arquivo com o nome de AuthorizationKeys.xml clicando em Add (Adicionar).

Nesse ponto, de duas uma: ou você salvou as API keys da sua App no Twitter em algum lugar ou você precisa ir até o Twitter for Developers para pegá-las, OK? O layout do nosso XML vai ser o seguinte:

<?xml version="1.0" encoding="utf-8" ?>
<Keys>
	<ConsumerKey></ConsumerKey>
	<ConsumerSecret></ConsumerSecret>
</Keys>

Dentro da tag de ConsumerKey, vai ficar a sua chave correspondente à API key e dentro da tag de ConsumerSecret, vai ficar a sua chave de API secret key. E dessa forma temos as nossas chaves prontas para ser usadas no código. Só lembrando aqui: essa é a forma que eu gosto, se você preferir fazer de outra maneira, fique à vontade!

⚠️Importante: caso você vá subir esse projeto no seu GitHub de forma pública, lembre-se de incluir o AuthorizationKeys.xml no seu .gitignore, para que mais ninguém tenha acesso às suas chaves, OK? É muito importante guardá-las em segurança. Vou deixar como exemplo aqui o .gitignore do meu projeto do Hey, Pepita.

Classe de autorização

Pronto, temos nossas chaves de API prontas para serem acessadas pelo nosso código. O que precisamos fazer agora é o seguinte: enviar essas duas chaves para a API do Twitter, que vai nos responder com um token de acesso.

🔖 Caso você tenha interesse pela parte mais teórica sobre como funciona o processo de autenticação/autorização do Twitter através do protocolo OAuth, eu dei uma lida na primeira parte do artigo Utilizando a API do Twitter no desenvolvimento de aplicações web com PHP e cURL e gostei bastante! Achei bem explicativo.

Vamos lá: dentro do nosso projeto, adicione uma nova classe, a Authorization.cs (ou Autorizacao.cs, em português, caso seja sua preferência). Dentro dela, vamos criar três métodos: dois métodos estáticos para recuperarmos cada chave do nosso XML e um método que, de fato, vai conter o algoritmo que manda as chaves para o Twitter e recebe o token de acesso. A nossa classe vai ficar dessa forma:

public class Authorization
{
    private static string GetConsumerKey()
    {
        var xml = XDocument.Load("../../../AuthorizationKeys.xml");
        return xml.Root.Element("ConsumerKey").Value;
    }

    private static string GetConsumerSecret()
    {
        var xml = XDocument.Load("../../../AuthorizationKeys.xml");
        return xml.Root.Element("ConsumerSecret").Value;
    }

    public string GetAccessToken()
    {
        string accessToken = "";
        string consumerKey = GetConsumerKey();
        string consumerSecret = GetConsumerSecret();
        var credentials = Convert.ToBase64String(new UTF8Encoding().GetBytes(GetConsumerKey() + ":" + GetConsumerSecret()));

        var request = WebRequest.Create("https://api.twitter.com/oauth2/token") as HttpWebRequest;
        request.Method = "POST";
        request.ContentType = "application/x-www-form-urlencoded";
        request.Headers[HttpRequestHeader.Authorization] = "Basic " + credentials;

        var reqBody = Encoding.UTF8.GetBytes("grant_type=client_credentials");
        request.ContentLength = reqBody.Length;

        using (var req = request.GetRequestStream())
        {
            req.Write(reqBody, 0, reqBody.Length);
        }

        try
        {
            string respbody = null;
            using (var resp = request.GetResponse().GetResponseStream())
            {
                var respR = new StreamReader(resp);
                respbody = respR.ReadToEnd();
            }

            accessToken = respbody.Substring(respbody.IndexOf("access_token\":\"") + "access_token\":\"".Length, respbody.IndexOf("\"}") - (respbody.IndexOf("access_token\":\"") + "access_token\":\"".Length));
        }
        catch
        {
            throw new Exception("Error getting Twitter Access Token!");
        }

        return accessToken;
    }
}

Os métodos GetConsumerKey() e GetConsumerSecret() são bem simples: eles vão acessar o nosso AuthorizationKeys.xml, pegar o valor do nó que eles precisam e retornar para uma variável dentro do nosso outro método.

Já o GetAccessToken() é mais complexo: ele cria uma WebRequest (que nada mais é que uma chamada à API do Twitter) e envia nossas chaves como credenciais. Essa requisição nos retorna uma resposta, que é o token de acesso que utilizaremos na parte 3 desse tutorial.

👍 Sobre o método GetAccessToken(), já quero deixar aqui o agradecimento ao autor do artigo Twitter API for beginners, porque eu simplesmente não sabia por onde começar a mexer com isso. Usei muito dos códigos dali de base para construir o meu bot da Pepita e fui adaptando conforme a minha necessidade. Obrigada mesmo!

Vamo testá?

Há uma maneira bem simples de ver que nosso método de autorização funciona: vamos imprimir o retorno dele no console. Assim é possível ver algum tipo de resultado, e não somente confiar na palavra desta programadora que vos fala hehe.

Vá até o Program.cs, instancie a classe e faça o console imprimir o retorno do seu método GetAccessToken(), desta forma:

class Program
{
    static void Main(string[] args)
    {
        Authorization autorizacao = new Authorization();
        Console.WriteLine(autorizacao.GetAccessToken());
    }
}

Depois, é só executar e você verá o seu token de acesso impresso no seu console:

E terminamos a parte dois! Espero que tenha gostado e vejo você em breve, para terminarmos a nossa aplicação. Até já!

---

🔄 Atualizações

• Parte três publicada! – em 11/09/2020
• Publiquei o projeto final em um repositório no meu GitHub! – em 13/09/2020

---

📜 Posts relacionados

Twitter API e C#: um tutorial – parte 1

Um novo projeto pessoal: o Hey, Pepita bot!

---

📩 Recadinhos da paróquia

1- 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! ✨

2- Se você está vendo essa mensagem, saiba que meu site migrou! #yay Agora todos os posts e conteúdos ficarão disponíveis no oliviamattiazzo.dev, que é um endereço que faz muito mais sentido para mim. O domínio .com.br segue ativo por enquanto, mas em breve vai abaixo. Desde já, obrigada por estar aqui e acompanhar o meu trabalho! 💕