Membros em C#: Explorando Tipos e Estruturas 

No C#, cada entidade, seja um namespace, uma classe, struct, enumeração, interface, array ou delegado, possui membros que definem sua funcionalidade. Neste artigo, vamos explorar como os membros de diferentes tipos de entidades funcionam e como eles podem ser acessados e herdados em diferentes contextos.

O que São Membros em C#?

Os membros são partes funcionais de uma entidade, que podem incluir métodos, propriedades, campos, constantes, eventos e operadores. No caso das classes e structs, também incluem construtores e finalizadores. Os membros de uma entidade podem ser acessados por meio de um nome qualificado, que envolve o nome da entidade seguido de um ponto e o nome do membro.

class Carro
{
    public string Modelo;

    public void ExibirModelo()
    {
        Console.WriteLine(Modelo);
    }
}

class Programa
{
    static void Main(string[] args)
    {
        Carro carro = new Carro();
        carro.Modelo = "Sedan";
        carro.ExibirModelo(); // Acessa o método e campo da classe Carro
    }
}

Membros de Namespaces

Namespaces são contêineres que agrupam tipos e são sempre públicos. Não é possível declarar namespaces privados ou protegidos, e qualquer tipo ou namespace dentro de um namespace pode ser acessado publicamente.

namespace Automoveis
{
    class Carro
    {
        public string Modelo;
    }
}

class Programa
{
    static void Main(string[] args)
    {
        Automoveis.Carro carro = new Automoveis.Carro();
        carro.Modelo = "SUV";
    }
}

Membros de Structs

Os structs herdam membros de System.ValueType e object. Além dos membros declarados no próprio struct, eles herdam métodos como Equals(), GetHashCode(), e ToString().

struct Ponto
{
    public int X;
    public int Y;
}

class Programa
{
    static void Main(string[] args)
    {
        Ponto p = new Ponto();
        p.X = 10;
        p.Y = 20;
        Console.WriteLine(p.ToString()); // Herança de object
    }
}

Membros de Enumerações

As enumerações são compostas por constantes e herdam membros de System.Enum, System.ValueType e object. Isso permite que você use métodos como ToString() para obter o nome da constante associada ao valor da enumeração.

enum DiasDaSemana { Domingo, Segunda, Terça }

class Programa
{
    static void Main(string[] args)
    {
        DiasDaSemana hoje = DiasDaSemana.Segunda;
        Console.WriteLine(hoje.ToString()); // Exibe "Segunda"
    }
}

Membros de Classes

As classes herdam membros de suas classes base, exceto construtores e finalizadores. Isso significa que os membros da classe base ficam acessíveis para a classe derivada, mesmo que não sejam diretamente visíveis por causa da acessibilidade.

class Veiculo
{
    public string Marca;
    public void MostrarMarca() => Console.WriteLine(Marca);
}

class Carro : Veiculo
{
    public string Modelo;
    public void MostrarModelo() => Console.WriteLine(Modelo);
}

class Programa
{
    static void Main(string[] args)
    {
        Carro carro = new Carro();
        carro.Marca = "Toyota";
        carro.Modelo = "Corolla";
        carro.MostrarMarca(); // Herança de Veiculo
        carro.MostrarModelo(); // Membro de Carro
    }
}

Membros de Interfaces

As interfaces contêm membros que são implementados pelas classes ou structs que as utilizam. Esses membros são herdados das interfaces base e são acessíveis às implementações, independentemente da acessibilidade do membro.

interface IVeiculo
{
    void Mover();
}

class Carro : IVeiculo
{
    public void Mover() => Console.WriteLine("O carro está se movendo.");
}

class Programa
{
    static void Main(string[] args)
    {
        IVeiculo veiculo = new Carro();
        veiculo.Mover(); // Implementação da interface
    }
}

Membros de Arrays

Arrays herdam membros da classe System.Array, permitindo a utilização de métodos e propriedades como Length e GetValue().

class Programa
{
    static void Main(string[] args)
    {
        int[] numeros = {1, 2, 3, 4};
        Console.WriteLine(numeros.Length); // Retorna o número de elementos
    }
}

Membros de Delegates

Os delegados herdam membros de System.Delegate e possuem um método Invoke, que pode ser usado para executar o delegado.

delegate void Saudacao(string nome);

class Programa
{
    static void Main(string[] args)
    {
        Saudacao saudacao = (nome) => Console.WriteLine($"Olá, {nome}");
        saudacao.Invoke("Carlos"); // Executa o delegado
    }
}

Conclusão

Os membros de diferentes entidades em C# desempenham um papel importante na definição do comportamento e da funcionalidade dos programas. Entender como esses membros funcionam em diferentes contextos, como classes, structs, enums e interfaces, permite um uso mais eficiente das linguagens de programação orientada a objetos.