Objetos (Guia de Programação em C#)

Artigo
06/10/2015

Uma definição de classe ou de estrutura é como um modelo que especifica o que o tipo pode fazer. Um objeto é basicamente um bloco de memória que foi atribuído e configurado de acordo com o modelo. Um programa pode criar vários objetos da mesma classe. Os objetos são chamados também instâncias, e podem ser armazenados em uma variável chamada ou matriz ou na coleção. O código do cliente é o código que usa essas variáveis para chamar os métodos e para acessar as propriedades públicas do objeto. Em uma linguagem orientada a objeto como C#, um programa típico consiste em vários objetos que interagem dinamicamente.

Dica

Os tipos estáticos se comportam de maneira diferente do que é descrito aqui.Para obter mais informações, consulte Classes static e membros de classes static (Guia de Programação em C#).

Instâncias de Estrutura CONTRA. instâncias de classe

Porque as classes são tipos de referência, uma variável de um objeto da classe contém uma referência para o endereço do objeto na heap gerenciada. Se um segundo objeto do mesmo tipo é atribuído ao primeiro objeto, então ambas as variáveis referem-se ao objeto no endereço. Este ponto é abordado em detalhes posteriormente em este tópico.

As instâncias de classes são criadas usando operador new. Em o exemplo, Person é o tipo e person1 e person 2 são instâncias, ou objetos, do tipo.

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
    //Other properties, methods, events...
}

class Program
{
    static void Main()
    {
        Person person1 = new Person("Leopold", 6);
        Console.WriteLine("person1 Name = {0} Age = {1}", person1.Name, person1.Age);

        // Declare  new person, assign person1 to it.
        Person person2 = person1;

        //Change the name of person2, and person1 also changes.
        person2.Name = "Molly";
        person2.Age = 16;

        Console.WriteLine("person2 Name = {0} Age = {1}", person2.Name, person2.Age);
        Console.WriteLine("person1 Name = {0} Age = {1}", person1.Name, person1.Age);

        // Keep the console open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();

    }
}
/*
    Output:
    person1 Name = Leopold Age = 6
    person2 Name = Molly Age = 16
    person1 Name = Molly Age = 16
*/

Como as estruturas são tipos de valor, uma variável de um objeto de estrutura armazena uma cópia do objeto inteiro. Instâncias de estruturas também podem ser criadas usando o operador de new , mas isso não é necessária, como mostrado no exemplo o seguir:

public struct Person
{
    public string Name;
    public int Age;
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

public class Application
{
    static void Main()
    {
        // Create  struct instance and initialize by using "new".
        // Memory is allocated on thread stack.
        Person p1 = new Person("Alex", 9);
        Console.WriteLine("p1 Name = {0} Age = {1}", p1.Name, p1.Age);

        // Create  new struct object. Note that  struct can be initialized 
        // without using "new".
        Person p2 = p1;

        // Assign values to p2 members.
        p2.Name = "Spencer";
        p2.Age = 7;
        Console.WriteLine("p2 Name = {0} Age = {1}", p2.Name, p2.Age);

        // p1 values remain unchanged because p2 is  copy.
        Console.WriteLine("p1 Name = {0} Age = {1}", p1.Name, p1.Age);

        // Keep the console open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/*
  Output:
    p1 Name = Alex Age = 9
    p2 Name = Spencer Age = 7
    p1 Name = Alex Age = 9
*/

A memória para ambos p1 e p2 é atribuída na pilha de segmento. Essa memória é recuperada juntamente com o tipo ou o método no qual é declarada. Esta é uma motivo pelo qual as estruturas são copiados na atribuição. Por outro lado, a memória que é atribuída para uma instância da classe é recuperada automaticamente coletado como lixo () no common language runtime em que todas as referências para o objeto saíram de escopo. Não é possível destruir deterministically um objeto da classe como você pode em C++. Para obter mais informações sobre a coleta de lixo em .NET Framework, consulte Coleta de Lixo.

Dica

A alocação e a desalocação de memória no heap gerenciado são otimizadas para o common language runtime.Em a maioria dos casos não há uma diferença significativa em custo de atribuir uma instância de classe na heap contra alocar de uma instância de estrutura na pilha.

Identidade do objeto CONTRA. igualdade de valor

Quando você compara dois objetos para igualdade, primeiro você deve distinguir se você deseja saber se as duas variáveis representam o mesmo objeto na memória, ou se os valores de um ou mais de seus campos são equivalentes. Se você intençãp comparar valores, você deve considerar se os objetos são instâncias dos tipos de valor () ou estruturas de tipos de referência (classes, representantes, matrizes).

Para determinar se duas instâncias de classe referem-se ao mesmo local na memória (que significa que possui a mesma identidade), use o método estático de Equals . (Object é a classe base implícito para todos os tipos de valor e tipos de referência, incluindo estruturas definidos pelo usuário e classes.)
Para determinar se a instância coloca em duas instâncias de estrutura tem os mesmos valores, use o método de ValueType.Equals . Como todos os estruturas implicitamente herdam de ValueType, você chama o método diretamente no seu objeto conforme mostrado no exemplo o seguir:

// Person is defined in the previous example. 

//public struct Person 
//{ 
//    public string Name; 
//    public int Age; 
//    public Person(string name, int age) 
//    { 
//        Name = name; 
//        Age = age; 
//    } 
//}

Person p1 = new Person("Wallace", 75);
Person p2;
p2.Name = "Wallace";
p2.Age = 75;

if (p2.Equals(p1))
    Console.WriteLine("p2 and p1 have the same values.");

// Output: p2 and p1 have the same values.

A implementação de ValueType de Equals usa reflexão porque ele deve ser capaz determinar quais campos são em qualquer estrutura. A o criar seus próprios estruturas, substituir o método de Equals para fornecer um algoritmo eficiente de igualdade que é específico ao seu tipo.

Para determinar se os valores dos campos em duas instâncias de classe são iguais, você poderá usar o método de Equals ou o operador de ==. Em o entanto, use-as somente se a classe os substituiu ou tenha sobrecarregado para fornecer uma definição personalizado do que significa” a “igualdade para objetos do tipo. A classe também pode implementar a interface de IEquatable ou a interface de IEqualityComparer . Ambas as interfaces fornecem métodos que podem ser usados para testar a igualdade de valor. A o criar suas próprias classes que substituem Equals, certifique-se seguir as diretrizes declaradas em Como definir a igualdade de valor para um tipo (Guia de Programação em C#) e em Object.Equals(Object).