Entrar Ainda não tem acesso?
1
resposta

[Projeto] Faça como eu fiz: gestão de serviços

Referente ao curso Praticando C#: orientação a objetos com herança, no capítulo Herança vs. Composição e atividade Faça como eu fiz: gestão de serviços

por christopher motta vasques
| 61.5k xp | 60 posts

Resolução:
IServico.cs

namespace PraticandoC_05.GestaoDeServicos09
{
    internal interface IServico
    {
        void ExecutarServico();
    }
}

Funcionario.cs

namespace PraticandoC_05.GestaoDeServicos09
{
    internal class Funcionario 
    {
        public Funcionario(string? nome, string? departamento)
        {
            Nome = nome;
            Departamento = departamento;
        }

        public string? Nome { get; }
        public string? Departamento { get; }
    }
}

Consultoria.cs

namespace PraticandoC_05.GestaoDeServicos09
{
    internal class Consultoria : IServico
    {
        public Consultoria(string tarefa, Funcionario consultor)
        {
            Tarefa = tarefa;
            Consultor = consultor;
        }

        public string Tarefa { get; }
        public Funcionario Consultor { get; }
        public void ExecutarServico()
        {
            Console.WriteLine($"Executando serviço de consultoria: {Tarefa}");
            Console.WriteLine($"Responsável: {Consultor.Nome} - Departamento: {Consultor.Departamento}\n");
        }
    }
}

Manutencao.cs

namespace PraticandoC_05.GestaoDeServicos09
{
    internal class Manutencao : IServico
    {
        public string Tarefa { get; }
        public Funcionario Tecnico { get; }
        public Manutencao(string tarefa, Funcionario tecnico)
        {
            Tarefa = tarefa;
            Tecnico = tecnico;
        }

        public void ExecutarServico()
        {
            Console.WriteLine($"Executando serviço de manutenção: {Tarefa}");
            Console.WriteLine($"Responsável: {Tecnico.Nome} - Departamento: {Tecnico.Departamento}\n");
        }
    }
}

Program.cs

using PraticandoC_05.GestaoDeServicos09;
using Func = PraticandoC_05.GestaoDeServicos09.Funcionario;

Func tecnico = new Func("João", "TI");
IServico s1 = new Manutencao("Atualização de servidor", tecnico);

Func consultor = new Func("Marina", "Consultoria");
Consultoria s2 = new Consultoria("Planejamento estratégico", consultor);

s1.ExecutarServico();
s2.ExecutarServico();
1 resposta
por Evandro Santana Amadio
| 1349.3k xp | 3119 posts
Process Improvement Analyst

Olá, Christopher. Como vai?

Sensacional! Parabéns pela resolução da atividade. O seu código para o sistema de gestão de serviços ficou simplesmente perfeito e demonstra que você absorveu o feedback do exercício anterior com maestria.

Ao contrário do desafio de pagamentos, aqui você aplicou a Composição e a Programação Orientada a Interfaces de forma impecável logo de primeira. Vamos analisar o porquê de o seu design de software estar excelente e totalmente alinhado com os padrões de arquitetura de mercado:

Os Grandes Acertos da sua Arquitetura

1. Relação Correta de Composição ("Tem um")

Repare nas suas declarações: as classes Consultoria e Manutencao não herdam de Funcionario. Elas apenas recebem uma instância de Funcionario através do construtor (Consultor e Tecnico).

Isso reflete o mundo real com precisão: um serviço de manutenção não é um funcionário; ele é uma entidade de negócio que tem um funcionário associado como responsável pela execução da tarefa.

2. Uso Poderoso de Contratos com IServico

Ao implementar a interface IServico, você garantiu que qualquer tipo de serviço criado no seu sistema seja obrigado a expor o método ExecutarServico(). No seu Program.cs, você já começou a colher os frutos dessa flexibilidade ao declarar a variável s1 utilizando o tipo da interface:

IServico s1 = new Manutencao("Atualização de servidor", tecnico);

Dica de Ouro: Elevando o Polimorfismo com Coleções

Como o seu código agora está padronizado sob a interface IServico, você pode dar um passo adiante e descobrir o real poder do Polimorfismo: gerenciar múltiplos serviços de forma genérica usando listas.

Imagine que em uma grande empresa existem dezenas de manutenções e consultorias acontecendo ao mesmo tempo. Em vez de chamar .ExecutarServico() linha por linha para cada variável, você pode agrupar tudo em uma única coleção e dispará-los de uma vez só.

Veja como o seu Program.cs poderia ser evoluído utilizando um laço de repetição:

using PraticandoC_05.GestaoDeServicos09;

// 1. Criação dos colaboradores
Funcionario joao = new Funcionario("João", "TI");
Funcionario marina = new Funcionario("Marina", "Consultoria");

// 2. Criamos uma lista genérica que aceita QUALQUER coisa que implemente IServico
List<IServico> listaDeServicos = new List<IServico>
{
    new Manutencao("Atualização de servidor", joao),
    new Consultoria("Planejamento estratégico", marina),
    new Manutencao("Troca de switches de rede", joao) // Nova manutenção adicionada facilmente!
};

Console.WriteLine("--- PROCESSANDO FILA DE SERVIÇOS --- \n");

// 3. O laço percorre a lista e executa o método correto de cada classe de forma polimórfica
foreach (IServico servico in listaDeServicos)
{
    servico.ExecutarServico();
}

Ao fazer isso, o seu código fica pronto para lidar com volumes massivos de dados. Se amanhã o curso pedir para você criar um novo tipo de serviço (como Auditoria : IServico), bastará instanciá-lo e jogá-lo dentro da mesma lista. O loop foreach continuará funcionando perfeitamente sem que você precise alterar uma única linha dele.

Parabéns pela evolução nítida no design das suas classes e pelo excelente uso dos apelidos de namespace (using Func = ...) no código. Continue com esse ritmo fantástico!

Espero que possa ter lhe ajudado!

Tópicos relacionados

Mostrar mais tópicos Mostrar menos tópicos

Conteúdos Alura com o tema

Trilhas por carreira

Carreiras de IA

Carreiras de Dados

Carreiras de Cyber

Carreiras de DevOps & Cloud

Carreiras de UX & UI

Carreiras de Mobile & Front-End

Carreiras de Back-End

Carreiras de Negócios

Cursos universitários FIAP

Graduação | Pós-graduação | MBA