DEV Community: Flávio Ribeiro

Diferença entre Dependency Injection e Service Locator em C#

Flávio Ribeiro — Fri, 21 Mar 2025 12:35:34 +0000

Diferença entre Dependency Injection e Service Locator

A injeção de dependência (Dependency Injection - DI) e o localizador de serviço (Service Locator - SL) são padrões utilizados para gerenciar dependências em aplicações C#. Ambos ajudam a desacoplar componentes, mas funcionam de maneiras diferentes.

Dependency Injection (DI)

A Dependency Injection é um padrão que permite que dependências sejam passadas para uma classe em vez de serem instanciadas dentro dela. Isso melhora a testabilidade, manutenção e extensibilidade do código.

Exemplo de Dependency Injection

// Interface do Serviço
public interface IEmailService
{
    void SendEmail(string message);
}

// Implementação do Serviço
public class EmailService : IEmailService
{
    public void SendEmail(string message)
    {
        Console.WriteLine($"Email enviado: {message}");
    }
}

// Classe que recebe a dependência via construtor
public class NotificationService
{
    private readonly IEmailService _emailService;

    public NotificationService(IEmailService emailService)
    {
        _emailService = emailService;
    }

    public void Notify(string message)
    {
        _emailService.SendEmail(message);
    }
}

// Configuração do Dependency Injection
var serviceProvider = new ServiceCollection()
    .AddScoped<IEmailService, EmailService>()
    .BuildServiceProvider();

// Resolvendo a dependência
var notificationService = new NotificationService(serviceProvider.GetRequiredService<IEmailService>());
notificationService.Notify("Olá, DI!");

Service Locator (SL)

O padrão Service Locator usa um contêiner global para gerenciar e recuperar dependências. Embora facilite a resolução dinâmica de serviços, pode dificultar testes e depuração, pois cria um forte acoplamento com o contêiner de injeção.

Exemplo de Service Locator

public static class ServiceLocator
{
    private static IServiceProvider _serviceProvider;

    public static void SetLocator(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public static T GetService<T>() => _serviceProvider.GetRequiredService<T>();
}

// Configuração do contêiner
var serviceProvider = new ServiceCollection()
    .AddScoped<IEmailService, EmailService>()
    .BuildServiceProvider();

ServiceLocator.SetLocator(serviceProvider);

// Resolvendo a dependência via Service Locator
var emailService = ServiceLocator.GetService<IEmailService>();
emailService.SendEmail("Olá, SL!");

Comparando Dependency Injection e Service Locator

Critério	Dependency Injection	Service Locator
Acoplamento	Baixo	Alto
Testabilidade	Melhor	Difícil
Facilidade de uso	Pode requerer configuração	Fácil de usar
Manutenção	Melhor para evolução	Pode dificultar depuração

Snippet Exclusivo - Comparando os Dois Padrões

public class Program
{
    public static void Main()
    {
        var services = new ServiceCollection()
            .AddScoped<IEmailService, EmailService>()
            .BuildServiceProvider();

        // Dependency Injection
        var notificationServiceDI = new NotificationService(services.GetRequiredService<IEmailService>());
        notificationServiceDI.Notify("Usando Dependency Injection");

        // Service Locator
        ServiceLocator.SetLocator(services);
        var emailServiceSL = ServiceLocator.GetService<IEmailService>();
        emailServiceSL.SendEmail("Usando Service Locator");
    }
}

Conclusão

Embora ambos os padrões possam ser usados, a Dependency Injection é preferida por proporcionar menor acoplamento e maior testabilidade. O Service Locator pode ser útil em cenários específicos, mas seu uso excessivo pode levar a dificuldades na manutenção do código. Escolha o padrão que melhor atende às necessidades do seu projeto!

Artigo Curl API (GET/POST/PUT/DELETE)

Flávio Ribeiro — Sat, 22 Feb 2020 11:17:52 +0000

Chamadas da API cURL com dados PHP e json (GET POST PUT DELETE)

Recentemente surgiu uma task em um projeto compartilhado com um grupo de programadores, consumir uma API Rest externa usando solicitações HTTP cURL em um simples projeto, eu já havia lido sobre, até tinha feito algumas usando outras APIs, mas com a falta de pratica acabamos não lembrando, escrevo esse artigo mais para eu poder me lembrar das chamadas que aprendi nos estudos e poder ajudar vocês.

Curl Simples

Para implementar uma simples API no projeto você pode usar algumas simples chamadas:




```

$url = "https://reqres.in/api/users?page=2";
$ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
    $response = curl_exec($ch);
        curl_close($ch);

$users = json_decode($response, true);
$user = $users['data']; 

```

Nesse caso, o código vai consumir os dados do array contidos na page $url e depois transforma em json através do json_decode(), usar true para ele validar o array, assim facilitando o retorno.

cURL Composto com os Requests

Mas vamos nos aprofundar mais criando scripts PHP que permite chamar essa função, como um conjunto de parâmetros, para que a solicitação cURL seja feita e você possa usar o codigo para qualquer tipo de API-HTTP.

- Coloque o arquivo da função geral que possa ser acessado por todo o projeto.

app/module




```

 function pullAPI($param1, $uri, $data){
   $curl = curl_init();
   switch ($param1){
      case "POST":
         curl_setopt($curl, CURLOPT_POST, 1);
         if ($data)
            curl_setopt($curl, CURLOPT_POSTFIELDS, $data);
         break;
      case "PUT":
         curl_setopt($curl, CURLOPT_CUSTOMREQUEST, "PUT");
         if ($data)
            curl_setopt($curl, CURLOPT_POSTFIELDS, $data);                              
         break;
      default:
         if ($data)
            $uri = sprintf("%s?%s", $uri, http_build_query($data));
   }
   // OPTIONS:
   curl_setopt($curl, CURLOPT_URL, $uri);
   curl_setopt($curl, CURLOPT_HTTPHEADER, array(
      'APIKEY: 111111111111111111111',
      'Content-Type: application/json',
   ));
   curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
   curl_setopt($curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
   // EXECUTE:
   $result = curl_exec($curl);
   if(!$result){die("Connection Failure");}
   curl_close($curl);
   return $result;
}

```

Está função é simples, usando uma instrução SWITCH para verificar se a chamada da API será por POST ou PUT, até mesmo GET ou DELETE, vou me aprofundar mais no caso de troca enquanto estamos realizando solicitações específicas.

Estou usando if dentro dos blocos de SWITCH para fornecer dados json em nossa chamada ou não .. $data = dados json. Para solicitar POST e PUT a instrução if não é realmente necessária, porque estamos usando apenas POST ou PUT como dados, mas é uma segurança para garantira que nossa função não seja interrompida

# Criando a chamada GET

A chamada mais simples é a GET, então vamos lá .. nessa nossa função pullAPI esperamos três parâmetros $param1, $uri, e a $data, precisamos fornecer esses três para todas as chamadas de API, então podemos definir o $data como false, pois não estamos transmitindo nenhum dado com a chamada GET, agora no arquivo index.php na raiz do projeto vamos fazer uma chamada passando os 3 parâmetros de uma API qualquer, usaremos a API da reqres.in como exemplo.

Primeiro faça a chamada do arquivo da função pullAPI




```

require_once('app/modules/reqres.api.php');

```

Depois vamos chamar o método GET.




```

$get_data = pullAPI('GET', 'https://reqres.in/api/users?page=2', false);
$get_users = json_decode($get_data, true);

// parametros de erros 
$errors = $get_users['get_users']['erros'];
// patametros de arrays usabeis no php
$data = $get_users['response']['data']['0'];

A função setada na variavel $get_data , pullAPI passa 3 parâmetros, qual o metodo = GET , a url 'https://reqres.in/api/users' e o data como não está passando nenhum dado, passamos 'false' como parâmetro.

Para testar o código de um print_r($get_users); para ver o retorno em tela.

Criando a chamada Post

A Solicitação POST requer dados, por isso temos que passar os 3 parâmetros ao final, como nesse método vamos enviar dados é obrigatório passar o parâmetro que será enviado, no local de $data que é o ultimo parâmetro vamos criar um array com os dados a ser enviados como POST.


```



array(
    'id' => '13',
    'first_name' => 'firstname',
    'last_name' => 'lastname',
    'email' => 'email@email.com.br',
    'avatar' => 'linkdoavatar.com.br/link.jpg'
);

podemos setar isso em uma variável $data_array , ficando o código assim, chamando a função com os 3 parâmetros e retornando o json.




```

 $data_array = array(
    'id' => '16',
    'first_name' => 'flavio',
    'last_name' => 'ribeiro',
    'email' => 'devflavioribeiro@gmail.com',
);
$make_call = pullAPI('POST', 'https://reqres.in/api/users', json_encode($data_array));
$response = json_decode($make_call, true);

ao rodar var_dump($response);
Retorna o json a ser enviado com método Post.

Criando a chamada PUT

A Solicitação de PUT é a mesma que a do Post, a diferença é que o PUT é uma envio mais específico, e usada quando desejamos enviar somente a informação a ser armazenada, podemos usar os mesmos parâmetros do Post.

Nesse caso agora vamos transformar nossa passagem de parâmetro personalizada para realização de um UPDATE.
Mais detalhado para depois jogar tudo dentro das funções corretamente, mas vamos passo a passo para aprender a linha de raciocínio ao desenvolver o código.

Com o PUT podemos usar a base da estrutura de array do POST, a diferença agora que vamos passar variáveis por parâmetro dentro do array.


```



$id = '6';
$email = 'devflavioribeiro@gmail.com';
$first_name = 'Flavio';
$last_name  = 'Ribeiro'; 
$avatar = 'http://flavioAPI.com.br/img.jpg';

Logo após criamos o array associativo para dar UPDATE:




```

$data_array =  array(
    'id' => $id,
    'email' => $email,
    'first_name' => $first_name,
    'last_name' => $last_name,
    'avatar' => $avatar
 );

Assim vamos usar a mesma chamada da função pullAPI passando novamente 3 parâmetros mas dessa vez com uma diferença, pois como é um UPDATE ele deve conter no URL uma concatenação de uma variável para definir qual o usuário que esta fazendo o update, então no codigo fica assim:


```



$update_plan = pullAPI('PUT', 'https://reqres.in/api/users/' . $id, json_encode($data_array));
$response = json_decode($update_plan, true);

Criando a chamada DELETE

Ultimo método é o DELETE, que é a solicitação de exclusão bem simples, nesse caso é necessário aplicar na URL qual o $id que vamos deletar, não sendo necessário passar ele por array, então o código fica assim:




```



$id = '3';
$delete_user = pullAPI('DELETE', 'https://reqres.in/api/users/' . $id, false);
$usuariodeletado = json_decode($delete_user, true);


if(isset($delete_user)){
    echo "O Usuário " . $usuariodeletado['data']['first_name'] . " Foi deletado" . "
";
}else {
    echo "Usuário não encontrado";
}

Então na variável $id podemos colocar o id do usuário que vai ser deletado, chamamos a classe , passamos os 3 parâmetros, como não estamos enviando dados, usamos o 'false' no ultimo parâmetro, e fazemos uma validação do $delete_user para saber qual o usuário que deletamos, usei somente o 'first_name' mas podemos usar toda as informações da lista do json.

Aqui foi uma breve explicação de como criar uma classe automatizada para consumir uma API cURL com os dados em Json usando PHP, aqui temos uma gama de modificações para fazer , podemos criar funções usando esse parâmetros para cada método, mas quis fazer de uma forma simples e rápida, com uma didática limpa, espero que tenham gostado.

Author
Flávio Ribeiro
Desenvolvedor Web

5 Tips for Landing Consistent Work as a Freelance Front-End Web Developer

Flávio Ribeiro — Wed, 27 Feb 2019 20:51:54 +0000

No alarm clock. No dress code. No inane watercooler gossip. No boss!

The freelance life is pretty, well, freeing. You get to choose the projects you work on, establish your own schedule, and set your own standards of excellence.

Creative careers of all sorts often include freelancing in some capacity. At some point in your career as a front end developer, either on the side or as your full-time pursuit, you’ll likely find yourself in search of freelance work.

As with any endeavor, there are upsides and downsides to self-employment (take a look at this Freelancing vs. Full Time post for a thorough rundown). But there’s one indisputable aspect to freelancing: you want to attract consistent work.

How exactly do you do that? Here are five best practices for situating yourself to attract regular work as a freelancer.

Maintain a Stellar Portfolio

As a freelancer, your portfolio is your number one selling tool. GitHub, Behance, or a beautiful personal website are all strong options for housing your portfolio. Use your collection of work as an opportunity to reflect your personal brand and to cleanly showcase your best stuff.

Not sure what to include? Remember that anyone viewing your portfolio will be making a snap impression, and you want them to get a feel for the spectrum of projects you’ve done, so feature a curated but wide range of work.

There’s no time like the present to start setting yourself up for freelance success. tweet

No professional projects to your name yet? If you have something stellar to show from a course, that’ll work, but be picky: you’re in constant competition against other, more experienced developers. It can also be helpful, once you’ve got the skills down, to offer to complete some work for free, or for cheap, for friends and acquaintances, in order to flex those freelance muscles and secure some strong work examples.

Leverage Twitter as a Networking Tool

Twitter can be an extremely powerful professional instrument if you use it to its fullest potential. A few tips:

Search relevant phrases and hashtags: Put Twitter’s search engine to work. Regularly search for the latest conversations around industry topics, companies you have your eye on, and developers you respect (you can follow them directly if they’re on Twitter, but searching for them surfaces all the content about them from other Twitter users globally). Drill down for the most targeted results using advanced filters like sentiment, location, and dates; access the advanced search tools by typing in a search string, then clicking Advanced Search on the results page. Search on relevant words and phrases, both with and without hashtags. You can even save searches in Twitter for quick access.
Join industry Twitter chats to connect with other developers and potential clients: Chiming in on Twitter chats lets you engage in real time with hyper-relevant contacts, those who offer the most bang for your networking buck. The Frontier Group, for example, hosts a monthly Friday #NewWebFrontier chat from 8 to 9 p.m. EST.
Follow lists and form your own: Twitter lists are an underutilized networking tool. As you discover useful or interesting accounts, categorize them into lists to keep track of who you’d like to reach out to or stay in touch with. Lists can be made private (but they’re public by default; make sure you toggle the setting to private), so feel free to label them as you see fit. Categories could include “new clients to pitch,” “useful connections of friends,” and the like. You can also follow other Twitter users’ public lists if you think they’re helpful.
Browse your followers’ followers (and the followers of people you’re following): The best way to find the most helpful people to follow on Twitter is to explore who’s following, and being followed by, users you already admire. As you find promising leads, add them to your lists!

Get Active on LinkedIn

When you’re searching for consistent freelance work, LinkedIn is your most valuable tool for rubbing virtual elbows with potential clients, and for impressing past and current clients so they’ll want to hire you again. A few helpful hints:

Keep your work history up to date: Just as you should always keep your resume current, you should also keep your LinkedIn profile current. And don’t forget to write a succinct, catchy summary of your background: it’s the first thing people see after your photo and thumbnail sketch of job titles.
Upload work examples: Let your work do the talking. Upload files or include links in your Summary or Projects sections that illustrate your experience. The more compelling your profile, the more likely someone is to reach out. Select a few top-notch pieces from your portfolio, and then link to the full site in your summary—don’t replicate your entire portfolio.
Utilize the site’s social networking component: Post interesting articles, and share, like, or comment on the articles posted by others. It’s a quick and easy way to form new connections, or keep old ones alive. You can even track how many views or likes these posts and shares get, to gauge how much traction your LinkedIn networking is gaining.
Join and participate in relevant groups: LinkedIn groups have amazing networking potential. Sharing a group membership with a key contact enables you to message each other even if you’re not officially “linked” on the site (don’t forget to configure your settings within the group to enable direct messaging). Search for groups that appeal to you, request membership or enlist directly (some are open, some require approval for entry), and then join the conversation to powwow with industry peers and promising leads.
Ask (politely) for recommendations: Advocate for yourself by tactfully requesting a recommendation from a former colleague, manager, or client. You can do so formally via LinkedIn, or through an email, phone call, or in-person conversation. You could also take the initiative and recognize a valued connection with a recommendation, tacitly requesting one in return.
Examine your connections’ connections: A warm introduction to a desired client from someone who knows both of you is far more likely to land you work than a cold call. Browse through the people connected to the people you’re connected to. You never know who you might meet.

Tap into Job Boards

Job listing hubs like Guru, Gun.io, Elance.com, Behance’s job search, Stack Overflow, GitHub Jobs, and the Jobs section on Craigslist can be reliable resources for finding steady freelance work. Be sure to present yourself professionally when you apply for gigs (no typos!), and apply only to jobs you are well-qualified for.

One major caveat: use job boards mainly as a complement to other tools for locking down freelance work. There’s a lot of chaff to wade through to get to the wheat, and you’re always more likely to find high-quality opportunities when they’re coming directly from people you know.

Be Amazing to Work With

Most important of all, once you’ve landed the work, deliver. The best business is return business. Repeat clients are more likely to increase your rate; to refer others to you; and to be enjoyable to work for, since you have a higher likelihood of establishing a rapport.

How to attract repeat clients? In addition to the hard skills, nurture your soft skills. That means being a strong communicator, being detail-oriented, and being adaptable and efficient. Always deliver your work on time and, of course, make sure that the finished product aligns closely with client expectations. You want to complete a project with the feeling that both you and the client would consider it ideal to work together again.

The Bottom Line

In 2014, 34% of the workforce freelances. That prevalence suggests that you’re more likely than not to be in search of work by contract at some point in your career, and more likely than not to find it when you want it.