Entendendo e utilizando construtores de classes em C# (CSharp)

1º O papel do construtor padrão

Cada classe em C# é fornecida com um construtor padrão gratuito, que pode ser redefinido se for necessário. Por definição, um construtor padrão nunca aceita argumentos. Além de alocar o novo objeto na memoria, o construtor padrão garante que todos os dados de campos configurados, para um calor padrão adequado. Se não estiver satisfeito com estas atribuições padrão, pode redefinir o construtor padrão de acordo com suas necessidades. Para ilustrar veja a classe abaixo:

class Carro
{
    public string Nome;
    public int VelocidadeCorrente;

    public Carro()
    {
        Nome = "GOLF GTI 1.8";
        VelocidadeCorrente = "60";
    }
}

Neste caso estamos forçando todos os objetos Carro a começar sua vida com o nome “GOLF GTI 1.8”, com a velocidade corrente de 60 km. Assim consegue criar um objeto Carro configurado para os seguintes valores padrão:

static void Main(string[] args)
{
    // Chamando o construtor padrao
    Carro CarroA = new Carro();

    // Imprimi a velocidade corrente de 60 km/h
    Console.Write(CarroA.VelocidadeCorrente);
}

2º Definindo construtores padrão

Tipicamente as classes definem construtores adicionais além do padrão. Ao fazer isso, você oferece ao usuário do objeto uma maneira simples e consistente para inicializar o estado de um objeto diretamente no momento da criação. Considere a seguinte atualização da classe “Carro” que agora ira suportar um total de três construtores de classe:

class Carro
{
    public string Nome;
    public int VelocidadeCorrente;

    // Construtor padrao personalizado
    public Carro()
    {
        Nome = "GOLF GTI 1.8";
        VelocidadeCorrente = "60";
    }

    // Aqui a VelocidadeCorrente recebera por padrao (zero)
    public Carro(string vNome)
    {
        Nome = vNome;
    }

    // Deixar que o chamandor configure o 'estado' completo do objeto Carro
    public Carro(string vNome, string vVelocidadeCorrente)
    {
        Nome = vNome;
        VelocidadeCorrente = vVelocidadeCorrente;
    }
}

Tenha em mente que o que diferencia um construtor do outro (aos olhos do compilador C#) é o numero e o tipo de argumentos do construtor. Portanto, o tipo “Carro” sobrecarregou o construtor para fornecer diversas maneiras de criar o objeto no momento da declaração. Seja qual for o caso, agora pode criar objetos “Carro” utilizando qualquer um dos construtores públicos. Por exemplo:

// Criar um carro Escort XR3
static void Main(string[] args)
{
    Carro CarroA = new Carro("ESCORT XR3");
}

// Criar um carro Escort XR3 com velocidade corrente de 90 km/h
static void Main(string[] args)
{
    Carro CarroA = new Carro("ESCORT XR3", "90");
}

3º Recusando o construtor padrão

No entanto, assim que define um construtor personalizado, o construtor padrão é silenciosamente removido da classe e não esta mais disponível! Pense desta forma: se não definir um construtor personalizado, o compilador C# fornecera um padrão para permitir que o usuário do objeto aloque uma instancia de seu tipo com dados de campo para valores padrão corretos. Entretanto quando define um construtor exclusivo, o compilador supõe que lidou com as coisas a sua maneira.

Portanto, se deseja permitir que o usuário do objeto, crie uma instancia de seu tipo com o construtor padrão, bem como seu construtor personalizado, você deve, explicitamente, redefinir o construtor padrão. Para isso, compreenda que uma grande maioria dos casos, a implementação do construtor padrão de uma classe é intencionalmente vazia, já que tudo o que precisa é a capacidade é criar um objeto com valores padrão. Considere a seguinte atualização da classe “Carro”:

class Carro
{
    public int Intencidade;

    public void Aceleracao()
    {
        for (int i = 0; i <= Intencidade; i++)
        {
            Console.Write("Yahoooooo Haaaaaewwwwww");
        }
    }

    // Recusar o construtor padrao
    public Carro()
    {

    }

    // Nosso construtor padrao agora!
    public Carro(int vIntencidade)
    {
        this.Intencidade = vIntencidade;
    }
}

Bom, finalizando esse foi mais um post sobre Construtores de Classe em C# (Csharp), espero que tenham gostado, pois lendo ele parece ser uma coisa ate simples, mas no dia-a-dia de um desenvolvedor de sistemas, nos deparamos como modificar um objeto a nosso favor em fim.

Ate à próxima!

Trabalhando com Listas (Coleções Genéricas)

Ola, Amigos.

Iniciaremos este tutorial falando sobre classe List<T> do namespace System.Collection.Generics ou também podemos falar objetos do tipo genérico.  O List<T> exige que especifique um único valor que descreva o tipo de item sobre o qual List<T> devera trabalhar ou armazenar. Portando se desejar criar três objetos List<T> para conter inteiros e os objetos SportCar() e Person(), terá que escrever o seguinte:

static void Main()
{
    List<int> MyInt = new List<int>();
    List<SportCar> MyCars = new List<SportCar>();           
    List<Person> MyPeople = new List<Person>();
}

Bom, no exemplo acima vemos como declarar um objeto do tipo List<T> e especificar o tipo que iremos objeto que este ira armazenar, podemos dizer que a classe List<T> é uma classe que pode armazenar vários tipos de objetos instanciados na memoria. Vejamos o exemplo abaixo:

private void addSportCarInList()
{
    SportCar MyCar = new SportCar();
   
    MyCar.returnModel = "Mazda";
    MyCar.returnColor = "White";
    MyCar.returnMaxSpeed = 210;

    List<SportCar> MyCars = List<SportCar>();
    MyCars.Add(MyCar);
}

No exemplo acima, nos criamos um objeto do tipo SportCar() e atribuímos as propriedades da classe que são: Modelo, Cor e Velocidade máxima, o valores que desejamos. Após isso criamos um objeto do tipo List<T> onde <T> nesta questão é do tipo SportCar ou seja <SportCar>.

No código acima nos podemos falar que o objeto List<SportCar> contem dentro de si uma instancia só do tipo SportCar, resumindo dentro de nossa Lista temos uma instancia de uma objeto Carro esportivo podemos comprovar isso pelo código abaixo:

MessageBox.Show("Total de carros em minha lista {0}", MyCars.Count);

No exemplo abaixo iremos adicionar vários carros em nossa lista de carros consequentemente no mundo POO (programação orientada a objeto) para cada carro iremos criar uma instancia. Vejamos no Exemplo:

private void addFiveSportCarInList()
{
    // Car 1
    SportCar MyCar1 = new SportCar();

    MyCar1.returnModel = "Mazda";
    MyCar1.returnColor = "White";
    MyCar1.returnMaxSpeed = 210;

    // Car 2
    SportCar MyCar2 = new SportCar();

    MyCar2.returnModel = "Subaru";
    MyCar2.returnColor = "Red";
    MyCar2.returnMaxSpeed = 180;

    // Car 3
    SportCar MyCar3 = new SportCar();

    MyCar3.returnModel = "Volvo";
    MyCar3.returnColor = "Green";
    MyCar3.returnMaxSpeed = 200;
   
    // Car 4
    SportCar MyCar4 = new SportCar();

    MyCar4.returnModel = "Volkswagen";
    MyCar4.returnColor = "Black";
    MyCar4.returnMaxSpeed = 240;
   
    // Car 5
    SportCar MyCar5 = new SportCar();

    MyCar5.returnModel = "Ferrari";
    MyCar5.returnColor = "Silver";
    MyCar5.returnMaxSpeed = 210;

    List<SportCar> MyCars = List<SportCar>();
    MyCars.Add(MyCar);

    MessageBox.Show("Total de carros em minha lista {0}", MyCars.Count);
}

Também podemos acessar métodos e propriedades do objeto SportCar() armazenado dentro de nossa lista, podemos fazer isso percorrendo nossa List<SportCar>, através de uma laço de repetição for, while, do while etc. visto que é uma lista ou também coleção de objetos. Vejamos o exemplo abaixo:

int i = 0;
for (i = 0; i <= MyCars.Count - 1; i++)
{
    MessageBox.Show("Carro número {0} sua marca é: {1}", i.ToString(), MyCars[i].returnModel.ToString());
}

 
No código acima fazemos um laço de repetição “for” para contar nossa lista de carros e exibir o modelo de cada um deles, no caso acima igualamos nossa variável “i” igual a zero só que para uma lista a qual estamos trabalhando ou um Array (vetor) a quantidade de objetos dentro sempre se inicia em um e não em zero, é por esse motivo que colocamos no meio de laço “for”

i <= MyCars.Count - 1

O total de itens da nossa lista menos um, isso por que nosso contador “i” é iniciado em zero.  Vale apena lembrar que a ordem em que instanciamos os objetos do mesmo tipo é a mesma ordem que esta armazenado dentro do objeto List<SportCar>.

Podemos dizer então que no caso acima em que adicionamos cinco carros em nossa lista o primeiro que instanciamos a marca dele é Mazda, pois é esse é o primeiro da nossa lista, como no exemplo do laço podemos perceber que o nome do primeiro carro que aparece no laço é o da marca Mazda, e assim por diante, como na ordem de instanciação.

Podemos também remover objetos desta lista usando o método Remove de nossa lista criada.
Vejamos no exemplo:

int i = 0;
for (i = 0; i <= MyCars.Count - 1; i++)
{
    if (MyCars[i].returnModel == "Volvo")
    {
        SportCar MyCarRemove = MyCars[i];
        MyCars.Remove(MyCarRemove);

        MessageBox.Show("Carro removido da lista");
    }   
}

No código acima nos removemos de nossa lista de carros, o carro de marca “Volvo” podemos perceber que nos criamos um objeto, mas não instanciamos um novo usando a sintaxe new e assim criamos uma variável do tipo SportCar e igualamos essa variável a um carro que estava dentro de nossa lista, esta ai o motivo por que não precisamos instanciar e sim só referenciamos a um que já estava lá dentro na nossa lista e depois passamos a variável ou objeto do tipo SportCar para a lista através do método remove, e esse método é o que ira remover o carro da marca Volvo da nossa lista.

Para limpar uma lista com vários objetos dentro podemos usar o método Clear, podemos limpar a lista como no exemplo abaixo:

MyCars.Clear();

O método acima limpa todas as instancias de objetos que a lista aceita que por ventura esteja carregada. Como vimos à coleção de genéricos do framework dot net permite dar soluções para eventuais problemas de desenvolvimento de softwares de nosso dia-a-dia. Além disso, os tipos genéricos geralmente excluem a necessidade de construir tipos de coleção personalizados.

Podemos utilizar List<T> em inumeráveis situações no desenvolvimento de software seja desktop ou web uma situação ótima para citar a inclusão de uma Lista seria implementar um carrinho de compras para um sistema de e-commerce.

Espero que tenham gostado deste post, pois em minhas horas de desenvolvimento de software sempre estou utilizando generics, collections entre estes a classe List<T>, sempre para guardar objetos fortemente tipados do projeto em que estou trabalhando.

Até o próximo post.