Em C#, um member é um elemento fundamental dentro de uma classe ou struct, representando dados ou funcionalidades. Esses members são essenciais para definir o comportamento e as características de um objeto. Vamos explorar os diferentes tipos de members e como eles são utilizados no desenvolvimento C#.
Tipos de Member em C#
Existem diversos tipos de members em C#, cada um com sua função específica:
- Fields (Campos): Variáveis que armazenam dados diretamente dentro da classe ou struct.
- Properties (Propriedades): Permitem ler, escrever ou calcular valores de campos, funcionando como intermediários entre os campos e o código externo.
- Methods (Métodos): Blocos de código que executam ações específicas.
- Constructors (Construtores): Métodos especiais que inicializam um objeto quando ele é criado.
- Finalizers (Finalizadores): Métodos que executam tarefas de limpeza antes que um objeto seja descartado.
- Events (Eventos): Mecanismos que permitem a uma classe ou objeto notificar outros objetos sobre ocorrências específicas.
- Indexers (Indexadores): Permitem que objetos sejam indexados como arrays.
- Nested Types (Tipos Aninhados): Classes ou structs definidos dentro de outra classe ou struct.
- Constants (Constantes): Valores que não podem ser alterados após a compilação.
- Operators (Operadores): Símbolos que executam operações em um ou mais operandos.
Exemplo Prático de Members em C#
Para ilustrar o uso de diferentes tipos de members, vamos criar uma classe simples chamada Car:
using System;
class Car
{
// **1. Field (campo)**
private string model;
// **2. Property (propriedade)**
public string Model
{
get { return model; }
set { model = value; }
}
// **3. Constructor (construtor)**
public Car(string model)
{
this.model = model;
}
// **4. Method (método)**
public void Honk()
{
Console.WriteLine("Beep Beep!");
}
// **5. Event (evento)**
public event Action OnStart;
public void Start()
{
Console.WriteLine("Mashina ishga tushdi!");
OnStart?.Invoke(); // Evento chamado
}
// **6. Indexer (indexador)**
private int[] speeds = new int[5];
public int this[int index]
{
get { return speeds[index]; }
set { speeds[index] = value; }
}
}
class Program
{
static void Main()
{
// Criação do objeto
Car myCar = new Car("Tesla");
// Utilização da propriedade
Console.WriteLine("Model: " + myCar.Model);
// Chamada do método
myCar.Honk();
// Adição de evento
myCar.OnStart += () => Console.WriteLine("Event: Mashina harakatga tayyor!");
myCar.Start();
// Acesso ao array via indexador
myCar[0] = 100;
Console.WriteLine("Birinchi tezlik: " + myCar[0]);
}
}
Neste exemplo, a classe Car demonstra o uso de um campo (model), uma propriedade (Model), um construtor, um método (Honk), um evento (OnStart) e um indexador.
O resultado deste código será:
Model: Tesla
Beep Beep!
Mashina ishga tushdi!
Event: Mashina harakatga tayyor!
Birinchi tezlik: 100
Fields em C#: Variáveis Dentro de Classes
Um field, ou campo, é uma variável declarada diretamente dentro de uma classe ou struct. Os fields são members do tipo em que são declarados e servem para armazenar dados que são parte do estado do objeto. Eles podem ser de qualquer tipo de dado suportado pelo C#, desde tipos primitivos como int e string até tipos complexos como outras classes ou structs.
Exemplo de Field com Validação
Para demonstrar o uso de um field, considere o exemplo de uma classe CalendarEntry que valida a data inserida:
using System;
public class CalendarEntry
{
private DateTime _date; // Campo privado
public DateTime Date // Propriedade com validação
{
get => _date;
set
{
if (value.Year > 1900 && value.Year <= DateTime.Today.Year)
_date = value;
else
throw new ArgumentOutOfRangeException(nameof(Date));
}
}
public void SetDate(string dateString) => Date = Convert.ToDateTime(dateString);
}
class Program
{
static void Main()
{
CalendarEntry entry = new CalendarEntry();
entry.SetDate("2000-05-15");
Console.WriteLine("Belgilangan sana: " + entry.Date.ToString("yyyy-MM-dd"));
}
}
Neste exemplo, o field _date é privado e a propriedade Date fornece uma maneira controlada de acessar e modificar o valor do field, incluindo validação.
O resultado deste código será:
Belgilangan sana: 2000-05-15
Properties em C#: Acesso Controlado a Dados
Uma property (propriedade) é um member que permite ler, escrever ou calcular o valor de um field. As properties se comportam como campos públicos, mas na realidade são implementadas com métodos especiais chamados accessors (acessadores). Esses accessors são get (para leitura) e set (para escrita), permitindo um controle mais granular sobre como os dados são acessados e modificados.
Exemplo de Property Simples
Considere o exemplo de uma classe Person com um field público FirstName:
using System;
public class Person
{
public string? FirstName; // Campo público
}
class Program
{
static void Main()
{
Person person = new Person();
person.FirstName = "Ali";
Console.WriteLine("Ism: " + person.FirstName);
}
}
Neste caso, FirstName é um campo público, o que significa que pode ser acessado e modificado diretamente. As properties oferecem uma alternativa mais controlada, permitindo adicionar lógica de validação ou outros comportamentos ao acessar ou modificar o valor.
O resultado deste código será:
Ism: Ali
Os members são componentes cruciais na programação C#, permitindo encapsular dados e comportamentos dentro de classes e structs. Compreender os diferentes tipos de members e como utilizá-los é fundamental para criar código robusto e bem estruturado. Para mais informações sobre desenvolvimento e tecnologia, confira novidades em tecnologia.
Este conteúdo foi auxiliado por Inteligência Artificiado, mas escrito e revisado por um humano.
Via Dev.to