Object Classe

Definição

Namespace:

System

Assemblies:

netstandard.dll, System.Runtime.dll

Origem:

Object.cs

Dá suporte a todas as classes na hierarquia de classes do .NET e fornece serviços de baixo nível para classes derivadas. Esta é a classe base final de todas as classes .NET; é a raiz da hierarquia de tipos.

public ref class System::Object

public class Object

type obj = class

Public Class Object

Exemplos

O exemplo a seguir define um tipo point derivado da Object classe e substitui muitos dos métodos virtuais da Object classe. Além disso, o exemplo mostra como chamar muitos dos métodos estáticos e de instância da Object classe.

using System;

// The Point class is derived from System.Object.
class Point
{
    public int x, y;

    public Point(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    public override bool Equals(object obj)
    {
        // If this and obj do not refer to the same type, then they are not equal.
        if (obj.GetType() != this.GetType()) return false;

        // Return true if  x and y fields match.
        var other = (Point) obj;
        return (this.x == other.x) && (this.y == other.y);
    }

    // Return the XOR of the x and y fields.
    public override int GetHashCode()
    {
        return x ^ y;
    }

    // Return the point's value as a string.
    public override String ToString()
    {
        return $"({x}, {y})";
    }

    // Return a copy of this point object by making a simple field copy.
    public Point Copy()
    {
        return (Point) this.MemberwiseClone();
    }
}

public sealed class App
{
    static void Main()
    {
        // Construct a Point object.
        var p1 = new Point(1,2);

        // Make another Point object that is a copy of the first.
        var p2 = p1.Copy();

        // Make another variable that references the first Point object.
        var p3 = p1;

        // The line below displays false because p1 and p2 refer to two different objects.
        Console.WriteLine(Object.ReferenceEquals(p1, p2));

        // The line below displays true because p1 and p2 refer to two different objects that have the same value.
        Console.WriteLine(Object.Equals(p1, p2));

        // The line below displays true because p1 and p3 refer to one object.
        Console.WriteLine(Object.ReferenceEquals(p1, p3));

        // The line below displays: p1's value is: (1, 2)
        Console.WriteLine($"p1's value is: {p1.ToString()}");
    }
}

// This code example produces the following output:
//
// False
// True
// True
// p1's value is: (1, 2)
//

open System

// The Point class is derived from System.Object.
type Point(x, y) =
    member _.X = x
    member _.Y = y
    override _.Equals obj =
        // If this and obj do not refer to the same type, then they are not equal.
        match obj with
        | :? Point as other ->
            // Return true if  x and y fields match.
            x = other.X &&  y = other.Y
        | _ -> 
            false

    // Return the XOR of the x and y fields.
    override _.GetHashCode() =
        x ^^^ y

    // Return the point's value as a string.
    override _.ToString() =
        $"({x}, {y})"

    // Return a copy of this point object by making a simple field copy.
    member this.Copy() =
        this.MemberwiseClone() :?> Point

// Construct a Point object.
let p1 = Point(1,2)

// Make another Point object that is a copy of the first.
let p2 = p1.Copy()

// Make another variable that references the first Point object.
let p3 = p1

// The line below displays false because p1 and p2 refer to two different objects.
printfn $"{Object.ReferenceEquals(p1, p2)}"

// The line below displays true because p1 and p2 refer to two different objects that have the same value.
printfn $"{Object.Equals(p1, p2)}"

// The line below displays true because p1 and p3 refer to one object.
printfn $"{Object.ReferenceEquals(p1, p3)}"

// The line below displays: p1's value is: (1, 2)
printfn $"p1's value is: {p1.ToString()}"
// This code example produces the following output:
//
// False
// True
// True
// p1's value is: (1, 2)
//

' The Point class is derived from System.Object.
Class Point
    Public x, y As Integer
    
    Public Sub New(ByVal x As Integer, ByVal y As Integer) 
        Me.x = x
        Me.y = y
    End Sub
    
    Public Overrides Function Equals(ByVal obj As Object) As Boolean 
        ' If Me and obj do not refer to the same type, then they are not equal.
        Dim objType As Type = obj.GetType()
        Dim meType  As Type = Me.GetType()
        If Not objType.Equals(meType) Then
            Return False
        End If 
        ' Return true if  x and y fields match.
        Dim other As Point = CType(obj, Point)
        Return Me.x = other.x AndAlso Me.y = other.y
    End Function 

    ' Return the XOR of the x and y fields.
    Public Overrides Function GetHashCode() As Integer 
        Return (x << 1) XOR y
    End Function 

    ' Return the point's value as a string.
    Public Overrides Function ToString() As String 
        Return $"({x}, {y})"
    End Function

    ' Return a copy of this point object by making a simple field copy.
    Public Function Copy() As Point 
        Return CType(Me.MemberwiseClone(), Point)
    End Function
End Class  

NotInheritable Public Class App
    Shared Sub Main() 
        ' Construct a Point object.
        Dim p1 As New Point(1, 2)
        
        ' Make another Point object that is a copy of the first.
        Dim p2 As Point = p1.Copy()
        
        ' Make another variable that references the first Point object.
        Dim p3 As Point = p1
        
        ' The line below displays false because p1 and p2 refer to two different objects.
        Console.WriteLine([Object].ReferenceEquals(p1, p2))

        ' The line below displays true because p1 and p2 refer to two different objects 
        ' that have the same value.
        Console.WriteLine([Object].Equals(p1, p2))

        ' The line below displays true because p1 and p3 refer to one object.
        Console.WriteLine([Object].ReferenceEquals(p1, p3))
        
        ' The line below displays: p1's value is: (1, 2)
        Console.WriteLine($"p1's value is: {p1.ToString()}")
    
    End Sub
End Class
' This example produces the following output:
'
' False
' True
' True
' p1's value is: (1, 2)
'

Comentários

A Object classe é a classe base final de todas as classes .NET; ela é a raiz da hierarquia de tipos.

Como todas as classes no .NET são derivadas de Object, todos os métodos definidos na classe Object estão disponíveis em todos os objetos no sistema. Classes derivadas podem e substituem alguns desses métodos, incluindo:

• Equals: dá suporte a comparações entre objetos.
• Finalize: executa operações de limpeza antes que um objeto seja recuperado automaticamente.
• GetHashCode: gera um número correspondente ao valor do objeto para dar suporte ao uso de uma tabela de hash.
• ToString: fabrica uma cadeia de caracteres de texto legível por humanos que descreve uma instância da classe.

As linguagens normalmente não exigem que uma classe declare herança de Object, porque a herança está implícita.

Considerações sobre desempenho

Se você estiver projetando uma classe, como uma coleção, que deve lidar com qualquer tipo de objeto, você pode criar membros de classe que aceitam instâncias da Object classe. No entanto, o processo de isolar e soltar um tipo carrega um custo de desempenho. Se você souber que sua nova classe lidará frequentemente com determinados tipos de valor, poderá usar uma das duas táticas para minimizar o custo do isolamento.

• Crie um método geral que aceite um Object tipo e um conjunto de sobrecargas de método específicas de tipo que aceitem cada tipo de valor que você espera que sua classe manipule com frequência. Se existir um método específico de tipo que aceite o tipo de parâmetro de chamada, nenhum isolamento ocorrerá e o método específico do tipo será invocado. Se não houver nenhum argumento de método que corresponda ao tipo de parâmetro de chamada, o parâmetro será colocado em caixa e o método geral será invocado.
• Crie seu tipo e os membros de forma a usar genéricos. O common language runtime cria um tipo genérico fechado quando você cria uma instância de sua classe e especifica um argumento de tipo genérico. O método genérico é específico de tipo e pode ser invocado sem isolar o parâmetro de chamada.

Embora às vezes seja necessário desenvolver classes de uso geral que aceitam e retornam Object tipos, você também pode melhorar o desempenho fornecendo uma classe específica de tipo para lidar com um tipo usado com frequência. Por exemplo, fornecer uma classe específica para definir e obter valores booleanos elimina o custo de encaixotamento e desempacotamento de valores booleanos.

Construtores

Nome	Description
Object()	Inicializa uma nova instância da classe Object.

Métodos

Nome	Description
Equals(Object, Object)	Determina se as instâncias de objeto especificadas são consideradas iguais.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual.
Finalize()	Permite que um objeto tente liberar recursos e executar outras operações de limpeza antes de ser recuperado pela coleta de lixo.
GetHashCode()	Serve como a função de hash padrão.
GetType()	Obtém o Type da instância atual.
MemberwiseClone()	Cria uma cópia superficial do Objectatual.
ReferenceEquals(Object, Object)	Determina se as instâncias especificadas Object são a mesma instância.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual.

Acesso thread-safe

Membros estáticos públicos (Shared no Visual Basic) desse tipo são thread safe. Não há garantia de que os membros da instância sejam thread-safe.