<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Lucas Queiroz on Medium]]></title>
        <description><![CDATA[Stories by Lucas Queiroz on Medium]]></description>
        <link>https://medium.com/@bylucasqueiroz?source=rss-69ffaa623f14------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*KTC-D4SQGemkB0DMP47yDQ@2x.jpeg</url>
            <title>Stories by Lucas Queiroz on Medium</title>
            <link>https://medium.com/@bylucasqueiroz?source=rss-69ffaa623f14------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 15:47:15 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@bylucasqueiroz/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Implementing a Go local cache solution]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://bylucasqueiroz.medium.com/implementing-a-go-local-cache-solution-45e3e10242fd?source=rss-69ffaa623f14------2"><img src="https://cdn-images-1.medium.com/max/1536/1*XVRPDwTGEOKDpOXC1zCyPw.png" width="1536"></a></p><p class="medium-feed-snippet">How to implement a cache solution that scales in Go that you can reuse across multiple applications</p><p class="medium-feed-link"><a href="https://bylucasqueiroz.medium.com/implementing-a-go-local-cache-solution-45e3e10242fd?source=rss-69ffaa623f14------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://bylucasqueiroz.medium.com/implementing-a-go-local-cache-solution-45e3e10242fd?source=rss-69ffaa623f14------2</link>
            <guid isPermaLink="false">https://medium.com/p/45e3e10242fd</guid>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Lucas Queiroz]]></dc:creator>
            <pubDate>Wed, 18 Feb 2026 17:22:15 GMT</pubDate>
            <atom:updated>2026-02-18T17:22:15.910Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Scalability and Performance]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://bylucasqueiroz.medium.com/scalability-and-performance-9205cb21b1c1?source=rss-69ffaa623f14------2"><img src="https://cdn-images-1.medium.com/max/1536/1*b4nz0uanQPkDde5zy1L0EA.png" width="1536"></a></p><p class="medium-feed-snippet">Understanding the difference between scalability and performance.</p><p class="medium-feed-link"><a href="https://bylucasqueiroz.medium.com/scalability-and-performance-9205cb21b1c1?source=rss-69ffaa623f14------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://bylucasqueiroz.medium.com/scalability-and-performance-9205cb21b1c1?source=rss-69ffaa623f14------2</link>
            <guid isPermaLink="false">https://medium.com/p/9205cb21b1c1</guid>
            <category><![CDATA[system-design-concepts]]></category>
            <dc:creator><![CDATA[Lucas Queiroz]]></dc:creator>
            <pubDate>Fri, 13 Feb 2026 21:01:01 GMT</pubDate>
            <atom:updated>2026-02-14T14:04:31.916Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[How to ensure thread-safety in Go]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://bylucasqueiroz.medium.com/how-to-ensure-thread-safety-in-go-f928e21b6470?source=rss-69ffaa623f14------2"><img src="https://cdn-images-1.medium.com/max/1536/1*FvmczG0w4O53i-1LLUY9EQ.png" width="1536"></a></p><p class="medium-feed-snippet">Working with Mutex to ensure thread-safeness in Go</p><p class="medium-feed-link"><a href="https://bylucasqueiroz.medium.com/how-to-ensure-thread-safety-in-go-f928e21b6470?source=rss-69ffaa623f14------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://bylucasqueiroz.medium.com/how-to-ensure-thread-safety-in-go-f928e21b6470?source=rss-69ffaa623f14------2</link>
            <guid isPermaLink="false">https://medium.com/p/f928e21b6470</guid>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Lucas Queiroz]]></dc:creator>
            <pubDate>Thu, 12 Feb 2026 01:12:09 GMT</pubDate>
            <atom:updated>2026-02-12T01:13:03.745Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Unbuffered and Buffered Channels in Go]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://bylucasqueiroz.medium.com/unbuffered-and-buffered-channels-in-go-06e7a80be2e6?source=rss-69ffaa623f14------2"><img src="https://cdn-images-1.medium.com/max/1536/1*xkbT5VijXU2Bu_Wxje7VBw.png" width="1536"></a></p><p class="medium-feed-snippet">Whats the difference between Unbuffered and Buffered Channels and how to use it.</p><p class="medium-feed-link"><a href="https://bylucasqueiroz.medium.com/unbuffered-and-buffered-channels-in-go-06e7a80be2e6?source=rss-69ffaa623f14------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://bylucasqueiroz.medium.com/unbuffered-and-buffered-channels-in-go-06e7a80be2e6?source=rss-69ffaa623f14------2</link>
            <guid isPermaLink="false">https://medium.com/p/06e7a80be2e6</guid>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Lucas Queiroz]]></dc:creator>
            <pubDate>Thu, 12 Feb 2026 00:43:20 GMT</pubDate>
            <atom:updated>2026-02-12T01:04:12.372Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Configurando Golang no WSL]]></title>
            <link>https://bylucasqueiroz.medium.com/configurando-golang-no-wsl-7e0b97592a07?source=rss-69ffaa623f14------2</link>
            <guid isPermaLink="false">https://medium.com/p/7e0b97592a07</guid>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[vscode]]></category>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[wsl]]></category>
            <category><![CDATA[go]]></category>
            <dc:creator><![CDATA[Lucas Queiroz]]></dc:creator>
            <pubDate>Mon, 26 Feb 2024 01:43:26 GMT</pubDate>
            <atom:updated>2024-02-26T12:18:43.317Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DI4ZCQnCuNxMfZyFfBhR7g.png" /></figure><p>Como desenvolvedores sabemos que existem muitas configurações nativas no Linux que não encontramos no Windows.</p><p>Alguns dias atrás, estava desenvolvendo uma aplicação em Go que me obrigaria a instalar algumas ferramentas no Windows para que tudo funcionasse da maneira esperada.</p><p>Foi aí que lembrei do WSL, e decidi executar a aplicação no Ubuntu através da ferramenta.</p><p>O WSL não é novo, é uma ferramenta que foi introduzida no Windows 10, para auxiliar desenvolvedores a terem acesso ao ambiente Linux, estando no Windows.</p><p>Se você ainda não tem o WSL instalado ou quer entender um pouco mais sobre, só acessar a <a href="https://learn.microsoft.com/pt-br/windows/wsl/install">página de instalação</a> da Microsoft.</p><p>Vamos para a configuração.</p><h4>Baixar</h4><p>Consulte a versão <a href="https://go.dev/dl/">aqui</a>, antes de realizar a execução do wget, dessa forma você instalará a versão mais recente.</p><pre>wget https://go.dev/dl/go1.22.0.linux-amd64.tar.gz</pre><h4>Instalar</h4><pre>sudo tar -xzf go1.22.0.linux-amd64.tar.gz</pre><h4>Configurar Variáveis de Ambiente do Bash</h4><p>Agora basta executar o comando abaixo para abrirmos o arquivo de configuração do Shell Bash no VSCode.</p><pre>code ~/.bashrc</pre><p>Após abrir o arquivo, basta inserir a configuração abaixo:</p><pre>export GOROOT=/usr/local/go<br>export GOPATH=$HOME/go<br>export PATH=$GOPATH/bin:$GOROOT/bin:$PATH</pre><h4>Checar versão</h4><p>Agora basta executar o comando <strong>go version</strong>, e deverá aparecer a versão do Go instalada no WSL.</p><pre>go version</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7e0b97592a07" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CI/CD no Github Actions em aplicações .NET 5 com Docker]]></title>
            <link>https://bylucasqueiroz.medium.com/ci-cd-no-github-actions-em-aplica%C3%A7%C3%B5es-net-5-com-docker-5d425faddc12?source=rss-69ffaa623f14------2</link>
            <guid isPermaLink="false">https://medium.com/p/5d425faddc12</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[csharp]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Lucas Queiroz]]></dc:creator>
            <pubDate>Fri, 18 Dec 2020 17:44:10 GMT</pubDate>
            <atom:updated>2021-04-22T15:11:09.765Z</atom:updated>
            <content:encoded><![CDATA[<h3>CI/CD no Github Actions em aplicações .NET 5 com Docker</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BZ_jv-xjX_FfJR5fQH_6UQ.png" /></figure><p>Fala pessoal! Sabemos a quantidade de benefícios que encontramos com a implementação de CI/CD, integração contínua em projetos, e o quanto melhora a qualidade das entregas.</p><p>Neste artigo você verá a implementação de algumas etapas do CI/CD no <em>Github Actions</em>, utilizando .NET 5. Você vai ver que é bem simples a implementação básica, mas não pare neste artigo, você pode implementar muitos outros <em>flows </em>além destes.</p><h3>1. Estruturando o Projeto</h3><p>Vamos criar uma <em>WebApi </em>simples que exibe alguns dados de cores. Também adicionaremos um projeto de testes com <em>XUnit, </em>utilizaremos também esse projeto como um dos flows do CI/CD<em>.</em></p><ol><li>Criando Solução</li></ol><p>dotnet new sln -n Colors</p><p>2. Adicionando a <em>WebApi</em></p><p>dotnet new webapi -n Colors.WebApi</p><p>3. Adicionando Projeto de Testes</p><p>dotnet new xunit -n Colors.Tests</p><p>4. Integrando projetos a solução</p><pre>dotnet sln add .\Colors.WebApi\Colors.WebApi.csproj<br>dotnet sln add .\Colors.Tests\Colors.Tests.csproj</pre><p>5. Por fim restauramos o projeto</p><pre>dotnet restore<br>dotnet build Colors.sln</pre><h3>2. Implementação da WebApi</h3><p>Implementei uma <em>api </em>simples com um repositório de cores, que realiza get e retorna cores. E alguns testes simples. A estrutura do projeto ficou assim:</p><h4>1. ColorController.cs</h4><pre>using System.Linq;<br>using Colors.WebApi.Repositories;<br>using Microsoft.AspNetCore.Mvc;</pre><pre>namespace Colors.WebApi.Controllers<br>{<br>    [ApiController]<br>    [Route(&quot;api/colors&quot;)]<br>    public class ColorController : ControllerBase<br>    {<br>        [HttpGet]<br>        public IActionResult GetAllColors()<br>        {<br>            var colors = ColorsRepository.Get();<br>            return Ok(colors);<br>        }</pre><pre>        [HttpGet(&quot;{name}&quot;)]<br>        public IActionResult GetByName(string name)<br>        {<br>            var colors = ColorsRepository.Get();<br>            var response = colors.Where(x =&gt; <br>                     x.Name.ToLower() == name.ToLower())<br>                     .FirstOrDefault();<br>            return Ok(response);<br>        }<br>    }<br>}</pre><h4>2. Model — Color.cs</h4><pre>namespace Colors.WebApi.Models<br>{<br>    public class Color<br>    {<br>        public int Id { get; set; }<br>        public string Name { get; set; }<br>    }<br>}</pre><h4>3. Repositório — ColorRepository.cs</h4><pre>using System.Collections.Generic;<br>using Colors.WebApi.Models;</pre><pre>namespace Colors.WebApi.Repositories<br>{<br>    public static class ColorsRepository<br>    {<br>        public static List&lt;Color&gt; Get()<br>        {<br>            var colors = new List&lt;Color&gt;();</pre><pre>            colors.Add(new Color { Id = 1, Name = &quot;Red&quot; });<br>            colors.Add(new Color { Id = 2, Name = &quot;Black&quot; });<br>            colors.Add(new Color { Id = 3, Name = &quot;Pink&quot; });<br>            colors.Add(new Color { Id = 4, Name = &quot;Green&quot; });<br>            colors.Add(new Color { Id = 5, Name = &quot;Gray&quot; });</pre><pre>            return colors;<br>        }<br>    }<br>}</pre><h4>3. Teste— ColorControllerTest.cs</h4><pre>using System.Collections.Generic;<br>using Colors.WebApi.Controllers;<br>using Colors.WebApi.Models;<br>using Microsoft.AspNetCore.Mvc;<br>using Xunit;</pre><pre>namespace Colors.Tests<br>{<br>    public class ColorControllerTest<br>    {<br>        private ColorController _controller;</pre><pre>       public ColorControllerTest()<br>        {<br>            _controller = new ColorController();<br>        }</pre><pre>        [Fact]<br>        public void GetAllColorsTest()<br>        {<br>            var response = _controller.GetAllColors() <br>                                             as OkObjectResult;</pre><pre>            var colors = response.Value as List&lt;Color&gt;;</pre><pre>            Assert.NotNull(colors);<br>        }</pre><pre>        [Theory]<br>        [InlineData(&quot;red&quot;)]<br>        [InlineData(&quot;black&quot;)]<br>        public void GetColorTest(string color)<br>        {<br>           var response = _controller.GetByName(color) <br>                                                 as OkObjectResult;</pre><pre>           var returnColor = response.Value as Color;</pre><pre>           Assert.NotNull(returnColor);<br>           Assert.Equal(color.ToUpper(),returnColor.Name.ToUpper());<br>        }<br>    }<br>}</pre><h3>3. Configuração do Docker</h3><p>Agora vamos configurar o Docker. Crie um arquivo chamado <strong><em>Dockerfile</em></strong> na raiz do projeto. Utilizaremos o <a href="https://hub.docker.com/_/microsoft-dotnet-aspnet">ASP.NET Core Runtime</a> e o <a href="https://hub.docker.com/_/microsoft-dotnet-sdk">.NET SDK</a> do .NET 5, que encontramos no <a href="https://hub.docker.com/">DockerHub</a>. Agora vamos inserir os dois projetos criados Colors.Tests e Colors.WebApi, se você tiver mais projetos além desses, poderá inserir, assim também serão compilados. O arquivo ficará assim:</p><pre>FROM mcr.microsoft.com/dotnet/aspnet:5.0 AS base</pre><pre>WORKDIR <em>/app</em></pre><pre>FROM mcr.microsoft.com/dotnet/sdk:5.0 AS build</pre><pre>WORKDIR <em>/src</em></pre><pre>COPY <em>Colors.sln</em> <em>./</em></pre><pre>COPY <em>Colors.WebApi/*.csproj</em> <em>./Colors.WebApi/</em></pre><pre>COPY <em>Colors.Tests/*.csproj</em> <em>./Colors.Tests/</em></pre><pre>RUN <em>dotnet</em> <em>restore</em></pre><pre>COPY <em>.</em> <em>.</em></pre><pre>WORKDIR <em>/src/Colors.WebApi</em></pre><pre>RUN <em>dotnet</em> <em>build</em> <em>-c</em> <em>Release</em> <em>-o</em> <em>/app</em></pre><pre>WORKDIR <em>/src/Colors.Tests</em></pre><pre>RUN <em>dotnet</em> <em>build</em> <em>-c</em> <em>Release</em> <em>-o</em> <em>/app</em></pre><pre>FROM build AS publish</pre><pre>RUN <em>dotnet</em> <em>publish</em> <em>-c</em> <em>Release</em> <em>-o</em> <em>/app</em></pre><pre>FROM base AS final</pre><pre>WORKDIR <em>/app</em></pre><pre>COPY <em>--from</em>=publish <em>/app</em> <em>.</em></pre><pre>CMD <em>ASPNETCORE_URLS=http://*:</em>$PORT <em>dotnet</em> <em>Colors.WebApi.dll</em></pre><p>Basicamente o arquivo <em>Dockerfile</em>, descreve uma rotina de publicação que geralmente realizamos manualmente. Ele copiará todo nosso projeto para dentro da imagem, em seguida, restaurará as dependências. Feito isso, é realizado um build no modo release, para por fim, caso tudo esteja correndo bem, realizar a publicação do projeto, que gera os arquivos corretos de publicação, e então executá-lo.</p><h3>4. Configurando o Github Actions no projeto</h3><p><em>Essa etapa, você também poderia ter feito antes de tudo e clonar o projeto, e começar o desenvolvimento a partir dele.</em></p><p>Supondo que seguiu o fluxo do artigo, você precisará criar um projeto no <em>Github , f</em>eito isso, iremos no nosso repositório em <strong><em>Actions</em></strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/882/1*uvVKLNg6NPAf6mPmBBGPaQ.png" /></figure><p>Vamos procurar pelo Workflow do .NET:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o93lMYGauV0Kuf_btuLTlQ.png" /></figure><p>Ele vai gerar um arquivo com extensão (.yml), é nele que suas configurações deverão ser realizadas, aqui você define quais etapas você deseja que seja executada no processo de integração contínua. Como havia falado antes, configuraremos a parte de teste e build utilizando a imagem do <em>Dockerfile </em>que configuramos anteriormente. Modifique o arquivo ele deve ficar assim:</p><pre>name: .NET </pre><pre>on:  <br>   push:    <br>      branches: [ master ]  <br>   pull_request:    <br>      branches: [ master ] <br>jobs:  <br>   build:     <br>      runs-on: ubuntu-latest     <br>steps:    <br>   - uses: actions/checkout@v2    <br>   - name: Setup .NET      <br>     uses: actions/setup-dotnet@v1      <br>     with:        <br>       dotnet-version: 5.0.100    <br>   - name: Restore dependencies      <br>     run: dotnet restore    <br>   - name: Build      <br>     run: dotnet build --no-restore    <br>   - name: Test      <br>     run: dotnet test --no-build --verbosity normal    <br>   - name: Docker Build      <br>     run: docker build . --file Dockerfile --tag colors-api</pre><p>Agora que você configurou seu projeto remoto no <em>Github</em>, e não tenha conectado com o projeto local basta fazer o seguinte, na raiz do seu projeto:</p><pre>git init<br>git remote add origin {endereço do seu repositório}<br>git pull</pre><p>Pronto, vamos baixar as configurações inseridas e adicionar nossos arquivo e realizar o <em>commit</em>.</p><pre>git add .<br>git commit -m “meu primeiro commit”<br>git push -u origin master</pre><h3>5. Conclusão</h3><p>Prontinho, após realizar o <em>commit</em>, você poderá ir no seu projeto no Github Actions, e ver todas as etapas rodando. A utilização de integração contínua em nosso projetos, melhora muito a qualidade das nossas entregas, e implementar isso em projetos pessoais é excelente, e serve de prática.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iRnh1omh6_DUjpg-VQjicg.png" /></figure><p>Aqui está o projeto que foi desenvolvido durante o artigo:</p><p><a href="https://github.com/lucqroz/colors-api">lucqroz/colors-api</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5d425faddc12" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Consultando serviços REST utilizando RestSharp e .NET Core (C#)]]></title>
            <link>https://bylucasqueiroz.medium.com/realizando-consultas-de-servi%C3%A7os-rest-utilizando-restsharp-e-net-core-c-456fba279abe?source=rss-69ffaa623f14------2</link>
            <guid isPermaLink="false">https://medium.com/p/456fba279abe</guid>
            <category><![CDATA[github]]></category>
            <category><![CDATA[csharp]]></category>
            <category><![CDATA[rest]]></category>
            <category><![CDATA[dotnet-core]]></category>
            <category><![CDATA[dotnet]]></category>
            <dc:creator><![CDATA[Lucas Queiroz]]></dc:creator>
            <pubDate>Tue, 01 Sep 2020 21:36:55 GMT</pubDate>
            <atom:updated>2021-04-22T15:09:51.575Z</atom:updated>
            <content:encoded><![CDATA[<h3>Consumindo serviços REST utilizando RestSharp e .NET Core (C#)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*skty3CapHw4Y4g4ngZagMw.png" /></figure><p>Geralmente durante nosso desenvolvimento, sempre nos deparamos com a necessidade de utilizar serviços externos aos nossos. Temos algumas opções de bibliotecas que podem ser utilizadas para realizar consultas destes serviços externos, <strong>REST </strong>(Representational State Transfer), como HttpClient, WebClient, RestSharp entre outras. Hoje falaremos um pouco sobre a biblioteca RestSharp. Neste exemplo utilizaremos .NET Core para implementar uma mini Api de exemplo para nossos testes, que irá consultar a Api do GitHub. Vamos lá!</p><p>Estou supondo que seu ambiente de desenvolvimento já esteja pré configurado para utilizar os serviços .NET.</p><p><strong>API do GitHub</strong> = api.github.com</p><h3>Criando uma WebApi .NET Core</h3><p>Com essa WebApi consultaremos o endpoint de usuários do GitHub, que nos retornará as informações de perfil. Para criar utilizaremos o comando:</p><blockquote><strong>dotnet new webapi -o dotnet-restsharp</strong></blockquote><p>Após criado seu projeto deverá ficar assim:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/241/1*w4qtE-3q3sf8_zOqFEApDA.png" /><figcaption>Projeto após criação</figcaption></figure><p>Você poderá remover os exemplos que vem no modelo, se preferir. Não irá interferir no nosso desenvolvimento caso os mantenha.</p><h3>Instalando o RestSharp</h3><p>Utilizaremos o seguinte comando para instalar o RestSharp:</p><blockquote><strong>dotnet add package RestSharp</strong></blockquote><h3>Implementação</h3><p>Agora iremos codificar nossa WebApi, configuraremos nosso modelo, controlador e serviços. Como dito anteriormente o endpoint que consultaremos é o de Usuários que tem o seguinte endereço:</p><blockquote><strong>api.github.com/users/{login}</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C9ngRfohkaICgwTAvJbn2Q.png" /><figcaption>Exemplo passando usuário</figcaption></figure><p>Retorno da consulta acima:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/620/1*oWAYi2hoa-wkqqRbzPNiVw.png" /><figcaption>Response para api.github.com/users/microsoft</figcaption></figure><h4><strong>Criando nosso modelo de dados (Model)</strong></h4><p>Observando o retorno da api do GitHub para usuários devemos criar um modelo contendo as informações que desejamos adquirir do serviço <strong>REST</strong> deles. Se você desejar todos os itens então, deverá criar um modelo compatível com a sua necessidade.</p><p>Criaremos uma pasta chamada Models, e vamos inserir o modelo de dados (model) para tratar os dados, e retornar somente o que desejamos, chamarei de Users.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/241/1*JVyzV17QXfCJpgvidHzA-Q.png" /><figcaption>Model — Users.cs</figcaption></figure><p>Após escolhida as informações que deseja receber do serviço <strong>REST</strong> implemente o modelo. Escolhi as seguintes propriedades: Id, Name, Login, Bio e Company.</p><pre>namespace dotnet_restsharp.Models<br>{<br>    public class Users<br>    {<br>        public int Id { get; set; }<br>        public string Name { get; set; }<br>        public string Login { get; set; }<br>        public string Bio { get; set; }<br>        public string Company { get; set; }<br>    }<br>}</pre><h4>Criando nosso Serviço (Services)</h4><p>Agora implementaremos o nosso serviço RestSharp, criaremos uma pasta e chamaremos de Services, em seguida adicionaremos um arquivo que chamarei de RestService.cs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/242/1*bxKKGqCQKlF9kpjOz2itog.png" /><figcaption>Service — RestService.cs</figcaption></figure><p>Agora a implementação do serviço:</p><pre>using dotnet_restsharp.Models;<br>using RestSharp;<br><br>namespace dotnet_restsharp.Services<br>{<br>    public static class RestService<br>    {<br>        public  static Users GetUsers(string nameUser)<br>        {<br>            var client = new RestClient(&quot;https://api.github.com&quot;);<br>            var request = new RestRequest($&quot;/users/{nameUser}&quot;, Method.GET);<br>            var response = client.Execute&lt;Users&gt;(request).Data;<br>            return response;<br>        }<br>    }<br>}</pre><p>A classe do serviço foi definida como estática (static), para que não haja necessidade de instanciar o serviço quando chamado. Foi criado um método dentro do nosso serviço RestService.cs, no qual chamamos de GetUsers. É ai que tudo acontece, definimos uma variável chamada client que recebe uma instância de RestClient, passando o serviço <strong>REST</strong> que desejamos consultar. Em seguida, será criada a requisição ao endpoint que desejamos consultar da Api. Neste caso como consultaremos o endpoint de usuários informamos <strong><em>/users/{nameUser}</em></strong>, o nameUser é recebido pelo método, e passado para a requisição, assim podemos escolher o usuário que queremos consultar.</p><h4>Criando nosso Controlador (Controller)</h4><p>Agora para finalizar criaremos nosso controlador, que irá receber nossa interação com a WebApi e realizará a chamada do nosso serviço.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/240/1*_xIXKIjE_C5Zkj_CQ4W2wg.png" /><figcaption>Controller — UsersController.cs</figcaption></figure><p>Ao criarmos nosso controlador ele ficará dessa forma:</p><pre>using dotnet_restsharp.Models;<br>using Microsoft.AspNetCore.Mvc;<br>using dotnet_restsharp.Services;<br><br>namespace dotnet_restsharp.Controller<br>{<br>    [Route(&quot;api/users&quot;)]<br>    [ApiController]<br>    public class UsersController : ControllerBase<br>    {<br>        [HttpGet(&quot;{login}&quot;)]<br>        public ActionResult&lt;Users&gt; GetUser(string login){<br>            return RestService.GetUsers(login);<br>        }<br>    }<br>}</pre><p>Definimos a rota de nossa WebApi como: <strong><em>api/users</em></strong>, para o método get definimos que o parâmetro será passado pela rota, onde foi atribuído o nome {login}. Basicamente ele ficará dessa forma quando realizarmos a consulta:</p><p><strong>Ex: api/users/{login}</strong></p><p>Assim finalizamos a implementação da nossa consulta com RestSharp.</p><h4>Testando nossa WebApi consultando a Api do GitHub</h4><p>Após finalizar, iremos rodar nossa aplicação, você pode utilizar o seguinte comando no seu terminal, dentro da pasta:</p><blockquote><strong>dotnet run</strong></blockquote><p>Provavelmente abrirá automaticamente no seu navegador você pode acessar o endereço localhost da sua Api, geralmente localhost:5001 ou localhost:5000. Agora digitaremos nossa consulta, passando o login do usuário que desejam consultar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ptVIaYrKWOWI2GsiAH8VMw.png" /><figcaption>Retorno da consulta passando login: Microsoft</figcaption></figure><h3>Conclusão</h3><p>Então, esse artigo foi basicamente para explicar como funciona a utilização do RestSharp, podemos ver que é bastante simples a implementação. Existem muitos outros métodos que você pode utilizar com essa biblioteca, como: PUT, POST, DELETE, só utilizamos o GET. Você também poder utilizar métodos de autenticação, para acessar alguns serviços, que necessitam de token entre outras formas de acesso aos dados. Também poderá passar parâmetros passar no body e no head da requisição e muito mais. Deixo aqui o link da documentação, para mais informações.</p><p><a href="https://restsharp.dev/getting-started/">Introduction | RestSharp</a></p><p>Obrigado a todos, e bons estudos. Para ver o projeto criado acesse:</p><p><a href="https://github.com/lucqroz/dotnet-restsharp">lucqroz/dotnet-restsharp</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=456fba279abe" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>