Objetos (guia de programação C#)

Artigo
08/25/2010

Uma classe ou struct definição é como um esquema 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 eles 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 telefonar os métodos e acessar as propriedades públicas do objeto.Em uma linguagem orientada a objeto such sistema autônomo translation from VPE for Csharp, normal do programa consiste em vários objetos interagindo dinamicamente.

Observação:
S tipos tatic se comportam diferente que está descrito aqui.Para obter mais informações, consulte Classes estáticas e membros de classe estáticos (guia de programação C#).

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

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

Instâncias de classes criadas usando o operador new.No exemplo a seguir, Person é o tipo e person1 e person 2 são instâncias ou objetos desse 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 a 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}", person2.Name, person2.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 de todo o objeto.Também é podem criar instâncias de structs 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 a 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 a new struct object. Note that a 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 a 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 os dois p1 e p2 é alocado na pilha de thread. Se a memória é recuperada junto com o tipo ou método no qual é declarada.Esse é um motivo por que structs são copiados na atribuição.Por outro lado, a memória alocada para uma instância de classe é automaticamente recuperado (lixo coletado) o Common linguagem tempo de execução quando todas as referências ao objeto passaram fora do escopo.Não é possível destruir um objeto de classe como é possível em C++ deterministamente.Para obter mais informações sobre a coleta de lixo no .NET Framework, consulte Coleta de Lixo.

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

Objeto identidade vs.Valor de igualdade

Quando você compara dois objetos de igualdade, você primeiro 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 pretende 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 dois classe instâncias consulte no mesmo local na memória (o que significa que eles tenham o mesmo identidade), use o estático Equals método. (System.Object é implícito classe base 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 têm os mesmos valores, use o ValueType.Equals método. sistema autônomo todas sistema autônomo estruturas implicitamente herdam da System.ValueType, você chama 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.

The System.ValueType implementação do Equals usa a reflexão pois deve ser capaz de determinar quais os campos em qualquer estrutura. Ao criar suas próprias estruturas, substituir o Equals método para fornecer um algoritmo de igualdade eficiente é específico para seu tipo.