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.
Diogo
Posts relacionados
Assine o boletim informativo
* Você receberá as últimas notícias e atualizações sobre suas celebridades favoritas!