Objects (C# Programming Guide)

Artigo
08/04/2011

Uma definição de classe ou estrutura é como um plano que especifica o tipo pode ser feito. Um objeto é basicamente um bloco de memória que foi alocado e configurado de acordo com o esquema. Um programa pode criar muitos objetos da mesma classe. Objetos também são chamados de instâncias e podem ser armazenados em uma variável nomeada ou em uma matriz ou coleção. Código do cliente é o código que usa essas variáveis para chamar os métodos e as propriedades públicas do objeto de acesso. Uma linguagem orientada a objeto como, por exemplo, C#, um programa típico consiste em vários objetos interagir dinamicamente.

Observação
Tipos estáticos se comportam de forma diferente da que está descrito aqui. Para obter mais informações, consulte Static Classes and Static Class Members (C# Programming Guide).

Instâncias de struct vs.Instâncias da classe

Como as classes são tipos de referência, uma variável de um objeto de classe contém uma referência para o endereço do objeto no heap gerenciado. Se um segundo objeto do mesmo tipo é atribuído ao primeiro objeto, ambas variáveis referem-se ao objeto nesse endereço. Esse ponto é discutido em mais detalhes posteriormente neste tópico.

Instâncias de classes são criadas usando o novo operador. No exemplo a seguir, 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 estruturas são tipos de valor, uma variável de um objeto de struct mantém uma cópia do objeto inteiro. Instâncias de estruturas também podem ser criadas usando o new operador, mas isso não é necessária, conforme mostrado no exemplo a 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 está alocado na pilha de thread. Esta memória é recuperada junto com o tipo ou método no qual é declarada. Isso é o motivo por que as estruturas são copiadas na atribuição. Por outro lado, a memória alocada para uma instância de classe é automaticamente recuperado (lixo coletado) pelo common language runtime quando todas as referências ao objeto tem saído do escopo. Não é possível determinista destruir um objeto de classe, como é possível em C++. Para obter mais informações sobre a coleta de lixo na .NET Framework, consulte Coleta de Lixo.

Observação
A alocação e desalocação de memória no heap gerenciado é altamente otimizada no common language runtime. Na maioria dos casos, não há nenhuma diferença significativa no desempenho de custo de uma instância de classe no heap versus alocar uma instância struct na pilha de alocação.

Objeto identidade vs.Igualdade de valor

Quando você compara dois objetos de 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 dos seus campos são equivalentes. Se você está pretendendo comparar valores, você deve considerar se os objetos são instâncias de tipos de valor (structs) ou tipos de referência (classes, delegados, matrizes).

Para determinar se duas instâncias da classe referência no mesmo local na memória (que significa que eles tenham o mesmo identidade), use estática Equals método. (System.Object é a classe base implícita para todos os tipos de valor e tipos de referência, incluindo as estruturas definidas pelo usuário e classes.)
Para determinar se os campos de instância em duas instâncias de struct possuem os mesmos valores, use o ValueType.Equals método. Porque todas as estruturas implicitamente herdam de System.ValueType, chame o método diretamente no seu objeto, conforme mostrado no exemplo a seguir:

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.

O System.ValueType a implementação de Equals usa a reflexão porque ele deve ser capaz de determinar quais são os campos em struct. Ao criar suas próprias estruturas, substituir o Equals método para fornecer um algoritmo eficiente de igualdade, que é específico para o seu tipo.

Para determinar se os valores dos campos em duas instâncias da classe são iguais, você poderá usar o Equals método ou a operador = =. No entanto, só usá-los se a classe tiver substituído ou sobrecarregado-los para fornecer uma definição personalizada de igualdade"que" meios para objetos desse tipo. A classe também pode implementar a IEquatable<T> interface ou o IEqualityComparer<T> interface. Ambas as interfaces fornecem métodos que podem ser usados para testar a igualdade do valor. Quando criar suas próprias classes que substituição Equals, certifique-se de seguir as diretrizes indicadas na How to: Definir o Valor de igualdade para um Tipo (guia de programação C#) e Object.Equals(Object).