DEV Community: Higor Anjos

Introdução a Programação Orientada a Objetos com C#

Higor Anjos — Sun, 02 Feb 2025 00:37:28 +0000

A Programação Orientada a Objetos (POO) é um paradigma de programação amplamente utilizado para o desenvolvimento de sistemas robustos, organizados e reutilizáveis. Esse paradigma busca aproximar a modelagem do software com o mundo real, representando conceitos e comportamentos através de objetos.

A POO é baseada em quatro pilares fundamentais:

Abstração: Permite representar entidades do mundo real com seus atributos e comportamentos essenciais, omitindo detalhes desnecessários.
Encapsulamento: Garante a proteção dos dados, restringindo o acesso direto aos atributos e controlando as interações por meio de métodos.
Herança: Possibilita criar novas classes baseadas em classes já existentes, promovendo a reutilização de código e a organização hierárquica.
Polimorfismo: Permite que métodos com o mesmo nome se comportem de maneiras diferentes conforme o contexto.

Linguagens de programação como Java, C#, Python e C++ são fortemente orientadas a objetos, oferecendo recursos para implementar esses conceitos de forma eficiente. A POO também facilita a manutenção e escalabilidade de sistemas, tornando o código mais modular e flexível.

1.1 Classes

Uma classe é uma estrutura que define as características (atributos) e comportamentos (métodos) de um objeto. Ela funciona como um molde para criar objetos, especificando quais dados e funcionalidades estarão disponíveis. Por exemplo, a classe Person pode ter atributos como Name, Age e CPF, e métodos como Walk() e Talk().

public class Person {
    public string Name;
    public int Age;

    public void Walk() {
        Console.WriteLine(Name + " is walking.");
    }

    public void Talk() {
        Console.WriteLine(Name + " is talking.");
    }
}

1.2 Objetos

Um objeto é uma instância de uma classe, ou seja, é a materialização de uma classe na memória. Cada objeto pode ter valores diferentes para seus atributos, mas compartilha os mesmos métodos definidos pela classe.

Person person1 = new Person();
person1.Name = "Alice";
person1.Age = 30;

Person person2 = new Person();
person2.Name = "Bob";
person2.Age = 25;

Neste exemplo, person1 representa uma pessoa chamada Alice com 30 anos, enquanto person2 representa Bob com 25 anos. Ambos são objetos distintos da classe Person.

1.3 Instanciação de Objetos

Instanciar um objeto é criar uma instância de uma classe na memória usando o operador new em C#.

Exemplo:

Person person1 = new Person();

1.4 Comparação entre Objetos (Operador ==)

Ao comparar objetos em Programação Orientada a Objetos (POO), é importante entender como o operador == funciona.

Operador ==: O operador == compara se dois objetos referenciam o mesmo local na memória. Ou seja, mesmo que dois objetos tenham atributos com os mesmos valores, eles não serão considerados iguais se não apontarem para a mesma referência. Ele verifica diretamente se ambos apontam para o mesmo local na memória.

Exemplo:

using System;
public class Person {
    private int id;

    public Person(int id) => this.id = id;
}

public class Program {
    public static void Main() {
        var person1 = new Person(1);
        var person2 = new Person(1);
        var person3 = person1;

        Console.WriteLine(person1 == person2);  // False
        Console.WriteLine(person1 == person3);  // True
    }
}

Neste exemplo, mesmo que person1 e person2 sejam criados com o mesmo valor de id, a comparação retorna false porque ambos são objetos distintos na memória. Já person1 e person3 apontam para o mesmo local na memória, por isso a comparação retorna true.

1.5 Atributos

Atributos são variáveis declaradas dentro de uma classe que armazenam o estado de um objeto. Exemplo:

public class Person {
    public string Name;
    public int Age;
}

1.5.1 Operadores de Acesso (Getters e Setters)

Getters e Setters são métodos usados para acessar e modificar atributos privados de uma classe, respeitando o princípio de encapsulamento.

public class Person {
    private string name;

    public string Name {
        get { return name; }
        set { name = value; }
    }
}

1.5.2 Palavra-chave this

A palavra-chave this é usada para referenciar o objeto atual da classe, evitando ambiguidade entre atributos e parâmetros de métodos.

public Person(string name) {
    this.name = name;
}

1.6 Métodos

Métodos representam comportamentos ou ações que um objeto pode executar.

1.6.1 Construtores e Destrutor (Constructor and Destructor)

Construtores (Constructors): São métodos especiais utilizados para inicializar uma classe. O nome do construtor deve ser o mesmo da classe e não possui tipo de retorno. O construtor é chamado automaticamente no momento em que o objeto é instanciado.

public class Person {
    private int[] data;

    public Person() {
        data = new int[100];
        Console.WriteLine("Memory allocated.");
    }
}

Destrutor (Destructor/Finalizer): É um método especial usado para liberar recursos quando um objeto não é mais necessário. Em C#, o destrutor tem o mesmo nome da classe precedido pelo símbolo ~. O destrutor é chamado automaticamente pelo coletor de lixo (Garbage Collector).

public class Person {
    private int[] data;

    public Person() {
        data = new int[100];
        Console.WriteLine("Memory allocated.");
    }

    ~Person() {
        data = null;
        Console.WriteLine("Memory deallocated.");
    }
}

1.7 Modificadores de Acesso

Controlam a visibilidade de classes, atributos e métodos.

1.7.1 Público, Privado e Protegido (public, private, protected)

public (Público): Permite acesso irrestrito a partir de qualquer parte do código.

public class Person {
    public string Name;
}

Person person = new Person();
person.Name = "Alice"; // Acesso permitido

private (Privado): Restringe o acesso apenas à própria classe.

public class Person {
    private int age;

    public void SetAge(int value) {
        age = value;
    }

    public int GetAge() {
        return age;
    }
}

Person person = new Person();
person.SetAge(30); // Acesso permitido
person.age = 30; // ERRO: 'age' é privado

protected (Protegido): Permite o acesso dentro da própria classe e de subclasses. (Essa técnica utiliza herança, que será abordada em detalhes mais adiante.)

public class Person {
    protected string Address;
}

public class Employee : Person {
    public void SetAddress(string address) {
        Address = address; // Acesso permitido na subclasse
    }
}

Employee employee = new Employee();
employee.SetAddress("123 Main St"); // Acesso indireto permitido
employee.Address = "123 Main St"; // ERRO: 'Address' é protegido

2. PILARES DA PROGRAMAÇÃO ORIENTADA A OBJETOS

Agora que já temos familiaridade com as ferramentas, vamos explorar os pilares que fortalecem a Programação Orientada a Objetos (POO) e entender como utilizá-los dentro de sua filosofia e paradigma.

2.1 Encapsulamento

O encapsulamento consiste em ocultar os detalhes internos de uma classe e expor apenas o necessário por meio de interfaces bem definidas. Esse conceito impede o acesso direto aos atributos de um objeto, permitindo que os dados sejam manipulados de forma segura e controlada.

Exemplo:

public class Person {
    private string name;
    private int age;

    public string GetName() {
        return name;
    }

    public void SetName(string newName) {
        if (!string.IsNullOrEmpty(newName)) {
            name = newName;
        }
    }
}

Neste exemplo, os atributos name e age estão protegidos e só podem ser acessados ou modificados através dos métodos GetName() e SetName().

2.2 Herança

A herança permite criar novas classes baseadas em classes existentes, facilitando a reutilização de código e a organização hierárquica.

Exemplo:

public class Person {
    public string Name;
    public int Age;
}

public class Student : Person {
    public string School;
}

Aqui, a classe Student herda atributos da classe Person e adiciona o atributo School.

2.2.1 Reutilização de Código e Acesso à Superclasse com base

A palavra-chave base permite acessar membros da classe base dentro da classe derivada, promovendo a reutilização de código. Em vez de replicar lógica ou inicialização da superclasse, utilizamos base para invocar diretamente os métodos ou construtores já definidos. Em C#, o base é usado para chamar métodos, construtores ou acessar membros da classe pai (superclasse). Esse conceito pode variar de acordo com a linguagem de programação. Por exemplo, linguagens como Java utilizam a palavra-chave super, enquanto em Python o método equivalente é super(). Independentemente da linguagem, o paradigma de Programação Orientada a Objetos (POO) sempre fornece uma maneira de reutilizar código e acessar a funcionalidade da superclasse.

Exemplo em C#:

public class Person {
    public Person(string name) {
        Console.WriteLine("Person: " + name);
    }
}

public class Student : Person {
    public Student(string name) : base(name) {
        Console.WriteLine("Student: " + name);
    }
}

2.2.2 Classes Abstratas

Classes abstratas servem como base para outras classes e não podem ser instanciadas. Elas são úteis quando você deseja definir um contrato (métodos que devem ser implementados pelas subclasses) e também compartilhar um comportamento comum entre elas.

Exemplo:

public abstract class Person {
    public string Name { get; set; }

    public void Greet() {
        Console.WriteLine($"Hello, my name is {Name}.");
    }

    public abstract void Introduce();
}

public class Student : Person {
    public override void Introduce() {
        Console.WriteLine("I am a student.");
    }
}

public class Teacher : Person {
    public override void Introduce() {
        Console.WriteLine("I am a teacher.");
    }
}

// Uso:
Student student = new Student { Name = "Alice" };
student.Greet(); // Comportamento comum
student.Introduce(); // Comportamento específico

Teacher teacher = new Teacher { Name = "Mr. Smith" };
teacher.Greet(); // Comportamento comum
teacher.Introduce(); // Comportamento específico

Neste exemplo, a classe abstrata Person fornece um método comum, Greet(), que pode ser usado por todas as subclasses. As subclasses, como Student e Teacher, implementam o método abstrato Introduce() de maneiras específicas.

2.2.3 Interfaces

Interfaces definem contratos que as classes devem implementar. Diferentemente das classes abstratas, as interfaces não podem conter implementações de métodos (exceto em algumas linguagens que permitem métodos com implementação padrão, como as interfaces no C# 8.0 e posteriores). Interfaces são úteis quando você deseja garantir que diferentes classes sigam um mesmo conjunto de regras, mas não compartilhem comportamento.

Exemplo:

public interface IPerson {
    void Introduce();
}

public class Employee : IPerson {
    public void Introduce() {
        Console.WriteLine("I am an employee.");
    }
}

public class Manager : IPerson {
    public void Introduce() {
        Console.WriteLine("I am a manager.");
    }
}

// Uso:
IPerson employee = new Employee();
employee.Introduce(); // Saída: I am an employee.

IPerson manager = new Manager();
manager.Introduce(); // Saída: I am a manager.

Neste exemplo, tanto Employee quanto Manager implementam a interface IPerson e fornecem suas próprias versões do método Introduce. Isso permite que objetos diferentes sejam tratados de forma uniforme quando acessados por meio da interface.

2.3 Polimorfismo

O polimorfismo permite que objetos de diferentes classes respondam de maneira distinta a uma mesma chamada de método.

Exemplo:

public class Person {
    public virtual void Introduce() {
        Console.WriteLine("I am a person.");
    }
}

public class Student : Person {
    public override void Introduce() {
        Console.WriteLine("I am a student.");
    }
}

public class Employee : Person {
    public override void Introduce() {
        Console.WriteLine("I am an employee.");
    }
}

2.3.1 Sobrescrita de Métodos (Overriding)

Permite redefinir um método da classe base em uma classe derivada, adaptando seu comportamento.

Exemplo:

public class Person {
    public virtual void Introduce() {
        Console.WriteLine("Hello, I am a person.");
    }
}

public class Student : Person {
    public override void Introduce() {
        Console.WriteLine("Hello, I am a student.");
    }
}

public class Employee : Person {
    public override void Introduce() {
        Console.WriteLine("Hello, I am an employee.");
    }
}

Exemplo de uso:

Person person = new Person();
person.Introduce();  // Saída: Hello, I am a person.

Person student = new Student();
student.Introduce();  // Saída: Hello, I am a student.

Person employee = new Employee();
employee.Introduce();  // Saída: Hello, I am an employee.

3. RELACIONAMENTO ENTRE CLASSES

Os relacionamentos entre classes são fundamentais para modelar interações e dependências entre objetos em sistemas orientados a objetos. Vamos explorar os principais tipos de relacionamentos: associação, agregação e dependência.

3.1 Associação Unidirecional

A associação unidirecional ocorre quando uma classe conhece outra, mas essa relação não é recíproca.

Exemplo:

public class Person {
    public string Name;
}

public class Car {
    public string Model;
    public Person Owner;
}

// Uso
Person person = new Person { Name = "Alice" };
Car car = new Car { Model = "Sedan", Owner = person };

Nesse exemplo, um objeto Car está associado a um objeto Person como seu proprietário.

3.2 Associação Bidirecional

A associação bidirecional ocorre quando ambas as classes conhecem e acessam os dados uma da outra, permitindo interação mútua.

Na associação bidirecional, ambas as classes conhecem a existência uma da outra.

Exemplo:

public class Person {
    public string Name;
    public Car Car;
}

public class Car {
    public string Model;
    public Person Owner;
}

Person person = new Person() { Name = "Alice" };
Car car = new Car() { Model = "Sedan", Owner = person };
person.Car = car;

Aqui, tanto a Person conhece seu Car quanto o Car conhece seu Owner.

3.3 Agregação

A agregação representa uma relação onde uma classe contém outra, mas ambas podem existir independentemente. A classe "todo" tem uma referência para a classe "parte", porém a destruição do objeto "todo" não afeta a existência do objeto "parte".

Exemplo:

public class Person {
    public string Name;
}

public class Department {
    public string Name;
    public List<Person> Employees = new List<Person>();
}

Person person = new Person() { Name = "Alice" };
Department dept = new Department() { Name = "IT" };
dept.Employees.Add(person);

Neste exemplo, o Department contém uma lista de Person como empregados. Se o objeto Department for destruído, o objeto Person ainda existirá independentemente.

3.4 Composição

A composição representa um relacionamento "todo/parte" mais restrito, onde a parte não pode existir sem o todo. Se o objeto "todo" for destruído, todas as suas partes também serão destruídas. Essa relação é frequentemente implementada com objetos sendo criados e gerenciados exclusivamente pelo "todo".

Exemplo:

public class Person {
    public string Name;
}

public class House {
    private List<Person> residents = new List<Person>();

    public House() {
        residents.Add(new Person() { Name = "Alice" });
        residents.Add(new Person() { Name = "Bob" });
    }

    public void ListResidents() {
        foreach (var resident in residents) {
            Console.WriteLine(resident.Name);
        }
    }
}

House house = new House();
house.ListResidents(); // Outputs: Alice, Bob

Neste exemplo, os objetos Person são criados dentro do objeto House. Se o objeto House for destruído, os objetos Person associados também serão destruídos, já que não existem fora do contexto da House.

4. CONCEITOS COMPLEMENTARES

Além dos pilares e relacionamentos, existem conceitos avançados que enriquecem a Programação Orientada a Objetos (POO).

4.1 Herança Múltipla (via Interfaces)

C# não permite herança múltipla de classes para evitar conflitos e ambiguidade. No entanto, é possível implementar múltiplas interfaces, permitindo que uma classe combine contratos de diferentes fontes.

A herança múltipla via interfaces é útil para atribuir diferentes responsabilidades a uma classe, permitindo maior flexibilidade e modularidade no design de software, sem criar dependências fortes entre os componentes.

Exemplo: Uma Pessoa com Duas Responsabilidades

No exemplo abaixo, a classe Person implementa duas interfaces: IWorker e IStudent, que representam contratos para diferentes responsabilidades.

public interface IWorker {
    void Work();
}

public interface IStudent {
    void Study();
}

public class Person : IWorker, IStudent {
    public void Work() {
        Console.WriteLine("Working...");
    }

    public void Study() {
        Console.WriteLine("Studying...");
    }
}

// Uso:
Person person = new Person();
person.Work(); // Saída: Working...
person.Study(); // Saída: Studying...

4.2 Métodos e Classes Genéricas

Métodos e classes genéricas permitem criar estruturas de código que funcionam com qualquer tipo de dado, promovendo reutilização e flexibilidade dos tipos. Esses conceitos são amplamente usados em bibliotecas e frameworks para lidar com diferentes tipos de dados de maneira uniforme, além de incentivar o princípio DRY (Don't Repeat Yourself), pois evitam a duplicação de lógica para diversos tipos.

Exemplo de Classe Genérica

public class Box<T> {
    public T Content;
}

// Uso:
Box<int> intBox = new Box<int>();
intBox.Content = 10;

Box<string> stringBox = new Box<string>();
stringBox.Content = "Hello";

Console.WriteLine(intBox.Content);    // Saída: 10
Console.WriteLine(stringBox.Content); // Saída: Hello

Exemplo de Método Genérico

public class Utils {
    public static void Display<T>(T item) {
        Console.WriteLine(item);
    }
}

// Uso:
Utils.Display<int>(42);        // Saída: 42
Utils.Display<string>("Text"); // Saída: Text
Utils.Display<double>(3.14);   // Saída: 3.14

Ao adotar classes e métodos genéricas, o código se torna mais modular e seguro em tempo de compilação. Isso contribui para o desenvolvimento de aplicações orientadas a objetos mais robustas, que lidam de forma eficiente com diversos tipos de dados em cenários variados.

4.3 Tratamento de Exceções em POO

O tratamento de exceções é uma técnica essencial em Programação Orientada a Objetos (POO) para capturar e lidar com erros durante a execução do programa, evitando falhas inesperadas e proporcionando uma experiência mais robusta para o usuário. No entanto, é importante ressaltar que exceções têm um custo computacional elevado e não devem ser usadas como fluxo de controle normal (conforme recomendado pela documentação da Microsoft).

Estrutura do Tratamento de Exceções

Em linguagens como C#, o tratamento de exceções é implementado com as palavras-chave try, catch e finally:

try: Define um bloco de código onde podem ocorrer exceções.
catch: Captura e trata exceções específicas ou gerais que ocorram no bloco try.
finally: (Opcional) Executa um bloco de código, independentemente de ter ocorrido ou não uma exceção. Usado frequentemente para liberar recursos.

Exemplo Básico

try {
    int result = 10 / 0; // Lança uma exceção DivideByZeroException
} catch (DivideByZeroException ex) {
    Console.WriteLine("Error: " + ex.Message);
} finally {
    Console.WriteLine("Operation finished.");
}

Exemplo Avançado com Várias Exceções

try {
    string input = null;
    Console.WriteLine(input.Length); // Lança NullReferenceException
} catch (NullReferenceException ex) {
    Console.WriteLine("Null reference error: " + ex.Message);
} catch (Exception ex) {
    Console.WriteLine("General error: " + ex.Message);
} finally {
    Console.WriteLine("Cleanup complete.");
}

Custo Computacional e Boas Práticas

Use exceções para condições verdadeiramente excepcionais: Exceções devem indicar problemas imprevistos ou cenários raros. Evite usá-las como parte do fluxo normal do programa.
Não use exceções para controle de fluxo: Além de prejudicar a legibilidade do código, lançar e capturar exceções repetidamente pode ocasionar alto consumo de recursos e impactos significativos no desempenho.
Capture exceções específicas: Sempre que possível, use exceções específicas em vez de capturar exceções genéricas (Exception). Dessa forma, o tratamento fica mais claro e eficiente.
Trate corretamente os recursos no bloco finally: Liberar conexões, fechar arquivos ou desfazer transações de forma adequada evita vazamento de recursos.

Benefícios do Tratamento de Exceções

Robustez: Reduz a probabilidade de o programa falhar inesperadamente.
Manutenção: Facilita a identificação e correção de erros.
Controle: Permite responder adequadamente a diferentes tipos de erros em tempo de execução.

O tratamento de exceções, embora indispensável, deve ser usado com parcimônia. A regra geral é não lançar exceções se for possível lidar com o cenário através de validações ou verificações prévias. Em um contexto de aplicações de alto desempenho — como em ASP.NET Core — o uso abusivo de exceções pode acarretar alto custo e diminuição de escalabilidade, conforme destacado nas boas práticas de desenvolvimento da Microsoft.

4.4 Reflexão (Reflection) – Inspeção e Manipulação em Tempo de Execução

Reflexão (Reflection) é um mecanismo poderoso que permite inspecionar, criar e modificar instâncias de classes em tempo de execução, bem como acessar e invocar seus membros (propriedades, métodos, construtores, etc.). É amplamente usada em cenários onde o código precisa ser dinâmico, como em frameworks, bibliotecas de serialização ou ferramentas de análise e geração de código.

Pontos Importantes

Flexibilidade: Permite descobrir tipos e membros em tempo de execução, criando soluções mais genéricas ou plugáveis.
Alto Custo: Reflexão pode ser mais lenta e complexa, exigindo cuidado com a performance.
Risco de Segurança: O acesso a detalhes internos pode expor áreas sensíveis do código se não houver controle adequado.
Uso Restrito: Geralmente, use apenas quando a flexibilidade dinâmica é essencial e não há alternativa mais simples.

Exemplo: Inspeção e Manipulação com Reflection

using System;
using System.Reflection;

public class Person {
    public string Name { get; set; }
    public int Age { get; set; }

    public void Speak() {
        Console.WriteLine($"Hello, my name is {Name}.");
    }
}

class Program {
    static void Main() {
        // Obtendo o tipo da classe Person
        Type type = typeof(Person);
        Console.WriteLine("Class: " + type.Name);

        // Listando propriedades da classe
        foreach (PropertyInfo prop in type.GetProperties()) {
            Console.WriteLine("Property: " + prop.Name);
        }

        // Criando uma instância da classe Person dinamicamente
        object obj = Activator.CreateInstance(type);

        // Definindo valor na propriedade 'Name'
        PropertyInfo nameProp = type.GetProperty("Name");
        nameProp.SetValue(obj, "Alice");
        Console.WriteLine("Name set via Reflection: " + nameProp.GetValue(obj));

        // Invocando o método 'Speak' dinamicamente
        MethodInfo method = type.GetMethod("Speak");
        method.Invoke(obj, null);
    }
}

Saída:

Class: Person
Property: Name
Property: Age
Name set via Reflection: Alice
Hello, my name is Alice.

Observação

Embora extremamente poderosa, a Reflexão deve ser usada apenas quando realmente necessária, pois pode prejudicar a legibilidade e o desempenho do seu código. Em cenários comuns, a abordagem mais simples e estatística é preferível.

4.5 Sobrecarga de Operadores (Operator Overloading)

Sobrecarga de operadores permite redefinir o comportamento de operadores para que funcionem com tipos definidos pelo usuário. Isso é útil para tornar objetos de classes personalizadas mais intuitivos de usar em operações comuns, como comparação ou soma.

Exemplo: Comparação de Objetos `Person`

public class Person {
    public string Name;
    public int Age;

    public static bool operator ==(Person p1, Person p2) {
        if (ReferenceEquals(p1, null) || ReferenceEquals(p2, null)) {
            return ReferenceEquals(p1, p2);
        }
        return p1.Name == p2.Name && p1.Age == p2.Age;
    }

    public static bool operator !=(Person p1, Person p2) {
        return !(p1 == p2);
    }

    public override bool Equals(object obj) {
        if (obj is Person other) {
            return this == other;
        }
        return false;
    }

    public override int GetHashCode() {
        return HashCode.Combine(Name, Age);
    }
}

// Uso:
Person person1 = new Person { Name = "Alice", Age = 30 };
Person person2 = new Person { Name = "Alice", Age = 30 };
Person person3 = new Person { Name = "Bob", Age = 25 };

Console.WriteLine(person1 == person2); // Saída: True
Console.WriteLine(person1 != person3); // Saída: True

Observação

Antes do surgimento do tipo record em C#, essa era a forma mais comum de criar Value Objects, garantindo a imutabilidade e a igualdade baseada no valor das propriedades.

| Sobrecarga de operadores é uma técnica poderosa, mas deve ser usada com cautela para evitar confusão ou comportamento inesperado.

4.6 Delegates e Eventos (Implementando o Padrão Observer)

O padrão Observer (também conhecido como Publish/Subscribe) é uma forma de organizar a comunicação entre objetos de modo que, quando um objeto (o Sujeito ou Publisher) muda de estado ou tem informações importantes, ele notifique automaticamente outros objetos interessados (os Observadores ou Subscribers).

No C#, delegates e eventos oferecem uma forma simples de implementar esse padrão:

Delegates são tipos que armazenam referências a métodos, permitindo passar métodos como parâmetros e executá-los dinamicamente.
Eventos, baseados em delegates, encapsulam esse comportamento e seguem o modelo de publicação/assinatura, onde vários Observers podem se inscrever (assinar) para receber atualizações de um Subject.

Exemplo de Implementação do Padrão Observer

using System;

// Delegate que define a "assinatura" do método que receberá a notificação
public delegate void Notify(string message);

// Sujeito (Publisher)
public class Subject {
    // Evento baseado no delegate Notify
    public event Notify OnNotify;

    public void NotifyObservers(string message) {
        Console.WriteLine($"Subject: Notificando observadores com a mensagem '{message}'...");

        // Invoca todos os métodos inscritos
        OnNotify?.Invoke(message);
    }
}

// Observador (Subscriber)
public class Observer {
    private readonly string _name;

    public Observer(string name) {
        _name = name;
    }

    // Método que será chamado quando ocorrer uma notificação
    public void Update(string message) {
        Console.WriteLine($"Observer {_name}: Recebeu a mensagem '{message}'");
    }
}

class Program {
    static void Main() {
        // Criação do Sujeito
        Subject subject = new Subject();

        // Criação dos Observadores
        Observer observerA = new Observer("A");
        Observer observerB = new Observer("B");

        // Inscrição (Subscribe) dos observadores no evento do sujeito
        subject.OnNotify += observerA.Update;
        subject.OnNotify += observerB.Update;

        // Dispara a notificação
        subject.NotifyObservers("Olá, Observadores!");
    }
}

Saída esperada:

Subject: Notificando observadores com a mensagem 'Olá, Observadores!'...
Observer A: Recebeu a mensagem 'Olá, Observadores!'
Observer B: Recebeu a mensagem 'Olá, Observadores!'

Como Funciona

Delegate Notify Define o contrato (assinatura do método) que os observadores devem ter para serem notificados.
Classe Subject
- Possui um evento OnNotify baseado no delegate.
- Fornece o método NotifyObservers que dispara o evento para todos os inscritos.
Classe Observer
- Possui um método Update compatível com o delegate, para ser chamado quando o evento for disparado.
Inscrição (+=) Os observadores se registram no evento do sujeito, indicando que desejam receber atualizações.

Vantagens do Padrão Observer

Desacoplamento: O Subject não precisa conhecer detalhes dos Observers, apenas o delegate que eles implementam.
Extensibilidade: Facilita a adição de novos Observers sem mudar o código do Subject.
Organização: Mantém a comunicação entre objetos de forma clara e centralizada.

Observação

Existem várias maneiras de implementar o Observer Pattern. Além de delegates e eventos, é possível usar bibliotecas reativas (como o Reactive Extensions, Rx.NET) ou mesmo outros padrões de mensageria para propagar notificações de forma assíncrona ou distribuída. O essencial é manter o princípio: quando o Publisher muda, ele aciona seus Subscribers de maneira desacoplada.

Versão: 1.3.1

Como Gerenciar Processos no Windows Usando PowerShell

Higor Anjos — Sun, 26 Jan 2025 02:25:09 +0000

O PowerShell é uma ferramenta poderosa para gerenciar processos no Windows. Abaixo, explico como identificar, monitorar e controlar processos utilizando comandos simples.

Passo 1: Listar Processos Ativos

Para visualizar todos os processos em execução no sistema:

Get-Process

Este comando exibe informações como o nome do processo, ID (PID), consumo de CPU e memória.

Passo 2: Filtrar Processos Específicos

Para localizar um processo específico, como o Microsoft Edge:

Get-Process -Name msedge

Ou filtrar pelo ID do processo:

Get-Process -Id <PID>

Substitua <PID> pelo ID do processo desejado.

Passo 3: Parar (Encerrar) um Processo

Se você deseja encerrar um processo que está consumindo muitos recursos:

Pelo nome:

  Stop-Process -Name msedge -Force

Pelo ID:

  Stop-Process -Id <PID> -Force

Use o parâmetro -Force para garantir que o processo seja finalizado imediatamente.

Passo 4: Iniciar um Processo

Para iniciar um programa ou processo:

Start-Process "notepad.exe"

Substitua "notepad.exe" pelo nome do programa desejado.

Passo 5: Monitorar os Maiores Consumidores de CPU e Memória

Para identificar os processos que mais consomem CPU:

Get-Process | Sort-Object CPU -Descending | Select-Object -First 10

Para identificar os maiores consumidores de memória:

Get-Process | Sort-Object WS -Descending | Select-Object -First 10

Passo 6: Obter Detalhes Avançados de um Processo

Para ver mais informações sobre um processo:

Get-Process -Name msedge | Format-List *

Isso exibe detalhes completos, como tempo de execução, threads e muito mais.

Passo 7: Criar Scripts de Monitoramento

Você pode automatizar a verificação de processos criando scripts. Por exemplo, salve este comando em um arquivo .ps1 para monitorar os 5 processos mais pesados:

Get-Process | Sort-Object CPU -Descending | Select-Object -First 5 | Out-File "C:\temp\processos_pesados.txt"

Cuidados Importantes

Evite encerrar processos essenciais para o sistema, como svchost, explorer, ou outros relacionados ao Windows.
Sempre confirme que o processo não é crítico antes de interrompê-lo.

Understanding Semantic Versioning

Higor Anjos — Sat, 18 Jan 2025 23:39:50 +0000

Semantic Versioning (or SemVer) is a standard set of rules used to track software versions during development. This standard provides a clear and consistent way to communicate changes made to a project, allowing developers and users to easily understand the impact of each update.

If you've ever installed packages, frameworks, or software, you've likely seen numbers like 1.2.3 or 2.0.0. These sequences make it easier to understand the type of update made—whether it's a new feature, a bug fix, or a critical change.

Semantic Versioning Format

SemVer follows the format:

MAJOR.MINOR.PATCH

MAJOR Version

The first number represents significant changes to the software that break backward compatibility. This could include removing or altering features, requiring users to adapt.

Example: Updating from 1.4.2 to 2.0.0 indicates major and potentially incompatible changes.

MINOR Version

The second number is updated when new features or improvements are added without breaking compatibility with previous versions.

Example: Updating from 1.4.2 to 1.5.0 shows that new features were added without affecting existing code.

PATCH Version

The third number is used to indicate bug fixes or minor adjustments that don't alter the software's behavior or features.

Example: Updating from 1.4.2 to 1.4.3 reflects a bug fix without structural changes.

Software Release Lifecycle

Alpha

The Alpha version is the first functional version of the software, used internally by developers for initial testing and concept validation. It is unstable and generally unavailable to the public.

Beta

The Beta version is more complete and available for testing by a larger audience to identify bugs and gather feedback. Although functional, it may still contain instabilities.

Release Candidate (RC)

The Release Candidate version is considered stable and close to the final release. If no critical issues are found, it becomes the official software version.

Practical Example

Bug Fix:

Current version: 1.0.0
New version: 1.0.1 (PATCH)

Example: A bug in an endpoint was fixed without affecting compatibility.

New Feature:

Current version: 1.0.1
New version: 1.1.0 (MINOR)

Example: A new endpoint was added to manage user permissions.

Breaking Change:

Current version: 1.1.0
New version: 2.0.0 (MAJOR)

Example: The authentication model was completely refactored, requiring adjustments in systems that consume the API.

Implementing SemVer with GitHub Releases

Create a Tag

To mark a specific version in the repository:

git tag -a v1.0.0 -m "First stable version"
git push origin v1.0.0

Create a Pre-Release

To create a testing version before the official release:

git tag -a v1.1.0-beta -m "Beta version for testing"
git push origin v1.1.0-beta

View Version History

To list all tagged versions:

git tag

Essential Tips and Rules

Use the MAJOR.MINOR.PATCH format consistently.
Never modify a version that has already been released.
Identify pre-release versions with suffixes like -alpha, -beta, or -rc.

Document changes using a file like CHANGELOG.md.

A standard CHANGELOG.md format:

# Changelog

## [1.1.0] - 2025-01-20  
### Added  
- New section on CI/CD tool integration.  
- More detailed examples using GitHub Actions.  

## [1.0.0] - 2025-01-18  
### Release  
- Initial content on Semantic Versioning.

With Semantic Versioning, you can communicate changes clearly and effectively, making the development process more organized and predictable.

Version: 1.1.0

Versionamento Semântico (SemVer): Um Guia Prático

Higor Anjos — Sat, 18 Jan 2025 23:16:48 +0000

O Versionamento Semântico (ou SemVer) é um padrão de regras utilizado para acompanhar versões de softwares durante seu desenvolvimento. O termo SemVer vem de Semantic Versioning, que significa Versionamento Semântico. Esse padrão fornece uma forma clara e consistente de comunicação sobre as mudanças realizadas no projeto, permitindo que desenvolvedores e usuários entendam facilmente o impacto de cada atualização.

Se você já instalou pacotes, frameworks ou softwares, certamente percebeu números como 1.2.3 ou 2.0.0. Essas sequências facilitam a compreensão do tipo de atualização feita, seja uma nova funcionalidade, uma correção de bug ou uma mudança crítica.

Formato do Versionamento Semântico

O SemVer segue o formato:

MAJOR.MINOR.PATCH

MAJOR (Versão Principal)

O primeiro número representa mudanças significativas no software que quebram a compatibilidade com versões anteriores. Isso pode incluir remoções ou alterações de funcionalidades, exigindo adaptações por parte dos usuários.

Exemplo: Atualizar de 1.4.2 para 2.0.0 indica mudanças importantes e potencialmente incompatíveis.

MINOR (Versão Menor)

O segundo número é atualizado quando novas funcionalidades ou melhorias são adicionadas sem afetar a compatibilidade com versões anteriores.

Exemplo: Atualizar de 1.4.2 para 1.5.0 mostra que novos recursos foram incluídos sem impacto no código existente.

PATCH (Correção de Erros)

O terceiro número é usado para indicar correções de bugs ou ajustes menores que não alteram o comportamento ou funcionalidades do software.

Exemplo: Atualizar de 1.4.2 para 1.4.3 reflete a correção de um problema sem mudanças estruturais.

Ciclo de Vida de Lançamento de um Software

Alpha

A versão Alpha é a primeira versão funcional do software, usada internamente pelos desenvolvedores para testes iniciais e validação de conceitos. É instável e geralmente indisponível para o público.

Beta

A versão Beta é mais completa e é disponibilizada para testes por um público maior, com o objetivo de identificar erros e coletar feedback. Embora funcional, ainda pode conter instabilidades.

Release Candidate (RC)

A versão Release Candidate é considerada estável e próxima da final. Se nenhum problema crítico for encontrado, ela se torna a versão oficial do software.

Exemplo Prático

Correção de Bug:

Versão atual: 1.0.0
Nova versão: 1.0.1 (PATCH)

Exemplo: Um erro em um endpoint foi corrigido sem afetar a compatibilidade.

Nova Funcionalidade:

Versão atual: 1.0.1
Nova versão: 1.1.0 (MINOR)

Exemplo: Um novo endpoint foi adicionado para gerenciar permissões de usuários.

Mudança Incompatível:

| Versão atual: 1.1.0
| Nova versão: 2.0.0 (MAJOR)

Exemplo: O modelo de autenticação foi completamente refatorado, exigindo ajustes nos sistemas que consomem a API.

Implementando SemVer com GitHub Releases

Criar uma Tag

Para marcar uma versão específica no repositório:

git tag -a v1.0.0 -m "Primeira versão estável"
git push origin v1.0.0

Criar uma Pré-Lançamento

Para criar uma versão de testes antes do lançamento oficial:

git tag -a v1.1.0-beta -m "Versão beta para testes"
git push origin v1.1.0-beta

Visualizar Histórico de Versões

Para listar todas as versões marcadas:

git tag

Dicas e Regras Essenciais

Use o formato MAJOR.MINOR.PATCH de maneira consistente.
Nunca altere uma versão já publicada.
Identifique versões de pré-lançamento com sufixos como -alpha, -beta ou -rc.

Documente as mudanças usando um arquivo como CHANGELOG.md.

Um CHANGELOG.md com formato padrão:

# Changelog

## [1.1.0] - 2025-01-20
### Adicionado
- Nova seção sobre integração com ferramentas CI/CD.
- Exemplos mais detalhados de uso com GitHub Actions.

## [1.0.0] - 2025-01-18
### Lançamento
- Conteúdo inicial sobre Versionamento Semântico.

Com o Versionamento Semântico, você pode comunicar mudanças de forma clara e eficaz, tornando o processo de desenvolvimento mais organizado e previsível.

Versão: 1.1.0

Padrão Give-When-Then: Organizando Testes com Clareza

Higor Anjos — Mon, 15 May 2023 12:24:41 +0000

O padrão Give-When-Then, também conhecido como Dado-Quando-Então, é uma abordagem comumente utilizada em testes unitários para organizar o código do teste de forma clara e concisa. Esse padrão divide o teste em três seções distintas, cada uma delas desempenhando um papel importante na estruturação e legibilidade do teste.

Give (Dado)

Na seção "Give" (Dado), preparamos o ambiente de teste e definimos o estado inicial necessário para o teste. Aqui, configuramos as condições iniciais, instanciamos objetos, fornecemos entradas e criamos qualquer outro contexto necessário para a execução do teste.

When (Quando)

Na seção "When" (Quando), executamos a ação ou o comportamento específico que está sendo testado. Essa etapa envolve a chamada de um método ou a execução de uma operação específica do sistema que desejamos testar. É importante manter essa etapa focada e direcionada ao objetivo do teste, evitando a realização de ações desnecessárias ou não relacionadas.

Then (Então)

Na seção "Then" (Então), verificamos se o resultado da ação realizada corresponde ao resultado esperado. Aqui, comparamos o valor retornado, o estado atual dos objetos ou qualquer outro aspecto relevante do sistema ou método em teste com o comportamento desejado. Essa verificação é feita utilizando asserções ou afirmações, garantindo que o teste valide corretamente o comportamento esperado.

Exemplo:

using Xunit;
using FluentAssertions;

public class CalculatorTests
{
    private Calculator calculator;

    public CalculatorTests()
    {
        calculator = new Calculator();
    }

    [Fact]
    public void GiveTwoNumbers_WhenCalled_ThenShouldReturnSumOfNumbers()
    {
        // Give
        int x = 5;
        int y = 3;

        // When
        int result = calculator.Add(x, y);

        // Then
        result.Should().Be(8);
    }
}

No exemplo acima, estamos testando o método Add de uma calculadora. Através do uso do padrão Give-When-Then, conseguimos estruturar o teste de forma clara:

Na seção "Give", definimos os valores x e y como 5 e 3, respectivamente.
Na seção "When", chamamos o método Add da calculadora, passando os valores x e y como argumentos.
Na seção "Then", verificamos se o resultado retornado pelo método Add é igual a 8, utilizando a asserção result.Should().Be(8).

A utilização do padrão Give-When-Then proporciona uma estrutura clara para os testes, facilitando a leitura e entendimento das diferentes etapas envolvidas. Além disso, ajuda a manter o foco do teste em cada ação específica, tornando-o mais legível e fácil de dar manutenção. Ao aplicar esse padrão, é possível obter testes mais claros, confiáveis e de fácil compreensão para toda a equipe de desenvolvimento.

DEV Community: Higor Anjos

Introdução a Programação Orientada a Objetos com C#

1.1 Classes

1.2 Objetos

1.3 Instanciação de Objetos

1.4 Comparação entre Objetos (Operador ==)

1.5 Atributos

1.5.1 Operadores de Acesso (Getters e Setters)

1.5.2 Palavra-chave this

1.6 Métodos

1.6.1 Construtores e Destrutor (Constructor and Destructor)

1.7 Modificadores de Acesso

1.7.1 Público, Privado e Protegido (public, private, protected)

2. PILARES DA PROGRAMAÇÃO ORIENTADA A OBJETOS

2.1 Encapsulamento

2.2 Herança

2.2.1 Reutilização de Código e Acesso à Superclasse com base

2.2.2 Classes Abstratas

2.2.3 Interfaces

2.3 Polimorfismo

2.3.1 Sobrescrita de Métodos (Overriding)

3. RELACIONAMENTO ENTRE CLASSES

3.1 Associação Unidirecional

3.2 Associação Bidirecional

3.3 Agregação

3.4 Composição

4. CONCEITOS COMPLEMENTARES

4.1 Herança Múltipla (via Interfaces)

Exemplo: Uma Pessoa com Duas Responsabilidades

4.2 Métodos e Classes Genéricas

Exemplo de Classe Genérica

Exemplo de Método Genérico

4.3 Tratamento de Exceções em POO

Estrutura do Tratamento de Exceções

Exemplo Básico

Exemplo Avançado com Várias Exceções

Custo Computacional e Boas Práticas

Benefícios do Tratamento de Exceções

4.4 Reflexão (Reflection) – Inspeção e Manipulação em Tempo de Execução

Pontos Importantes

Exemplo: Inspeção e Manipulação com Reflection

4.5 Sobrecarga de Operadores (Operator Overloading)

Exemplo: Comparação de Objetos Person

4.6 Delegates e Eventos (Implementando o Padrão Observer)

Exemplo de Implementação do Padrão Observer

Como Funciona

Vantagens do Padrão Observer

Como Gerenciar Processos no Windows Usando PowerShell

Passo 1: Listar Processos Ativos

Passo 2: Filtrar Processos Específicos

Passo 3: Parar (Encerrar) um Processo

Passo 4: Iniciar um Processo

Passo 5: Monitorar os Maiores Consumidores de CPU e Memória

Passo 6: Obter Detalhes Avançados de um Processo

Passo 7: Criar Scripts de Monitoramento

Cuidados Importantes

Understanding Semantic Versioning

Semantic Versioning Format

MAJOR Version

MINOR Version

PATCH Version

Software Release Lifecycle

Alpha

Beta

Release Candidate (RC)

Practical Example

Implementing SemVer with GitHub Releases

Create a Tag

Create a Pre-Release

View Version History

Essential Tips and Rules

Versionamento Semântico (SemVer): Um Guia Prático

Formato do Versionamento Semântico

MAJOR (Versão Principal)

MINOR (Versão Menor)

PATCH (Correção de Erros)

Ciclo de Vida de Lançamento de um Software

Alpha

Beta

Release Candidate (RC)

Exemplo: Comparação de Objetos `Person`