Object Třída

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

Zdroj:

Object.cs

Podporuje všechny třídy v hierarchii tříd .NET a poskytuje služby nízké úrovně odvozeným třídám. Toto je konečná základní třída všech tříd .NET; je kořenem hierarchie typů.

public ref class System::Object

public class Object

type obj = class

Public Class Object

Příklady

Následující příklad definuje typ point odvozený z Object třídy a přepíše mnoho virtuálních metod Object třídy. Kromě toho příklad ukazuje, jak volat mnoho statických a instance metod Object třídy.

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)
'

Poznámky

Třída Object je nejvyšší základní třídou všech tříd .NET; je kořenem hierarchie typů.

Vzhledem k tomu, že všechny třídy v .NET jsou odvozeny od Object, každá metoda definovaná ve Object třídě je k dispozici ve všech objektech v systému. Odvozené třídy mohou a také přepisují některé z těchto metod, včetně:

• Equals: Podporuje porovnání mezi objekty.
• Finalize: Provádí operace čištění před automatickým uvolněním objektu.
• GetHashCode: Vygeneruje číslo odpovídající hodnotě objektu pro podporu použití hashovací tabulky.
• ToString: Vyrábí textový řetězec čitelný člověkem, který popisuje instanci třídy.

Jazyky obvykle nevyžadují, aby třída deklarovala dědičnost z Object, protože dědičnost je implicitní.

Důležité informace o výkonu

Pokud navrhujete třídu, například kolekci, která musí zpracovávat jakýkoli typ objektu, můžete vytvořit členy třídy, které přijímají instance Object třídy. Proces balení a rozbalení typu ale nese náklady na výkon. Pokud víte, že vaše nová třída bude často zpracovávat určité typy hodnot, můžete použít jednu ze dvou taktik k minimalizaci nákladů na boxování.

• Vytvořte obecnou metodu, která přijímá typ Object a sadu přetížení metod specifických pro daný typ, které přijímají jednotlivé typy hodnot, s nimiž vaše třída pravděpodobně bude často pracovat. Pokud existuje metoda specifická pro typ typu, která přijímá typ volajícího parametru, nedojde k žádnému boxování a vyvolá se metoda specifická pro typ. Pokud neexistuje žádný argument metody, který odpovídá typu volaného parametru, parametr je zabalen a obecná metoda je vyvolána.
• Navrhněte typ a jeho členy tak, aby používaly obecné typy. Když vytvoříte instanci třídy a zadáte argument obecného typu, modul CLR (Common Language Runtime) vytvoří uzavřený obecný typ. Obecná metoda je specifická pro typ a lze ji použít bez boxování parametru volání.

I když je někdy nutné vyvíjet třídy pro obecné účely, které přijímají a vracejí Object typy, můžete zvýšit výkon také poskytnutím třídy specifické pro typ pro zpracování často používaného typu. Například poskytnutí třídy, která je specifická pro nastavení a získání logických hodnot, eliminuje náklady na boxování a rozbalení logických hodnot.

Konstruktory

Name	Description
Object()	Inicializuje novou instanci Object třídy.

Metody

Name	Description
Equals(Object, Object)	Určuje, zda jsou zadané instance objektů považovány za stejné.
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu.
Finalize()	Umožňuje objektu pokusit se uvolnit prostředky a provést další operace čištění před uvolněním paměti.
GetHashCode()	Slouží jako výchozí funkce hash.
GetType()	Získá Type aktuální instance.
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object.
ReferenceEquals(Object, Object)	Určuje, zda jsou zadané Object instance stejné instance.
ToString()	Vrátí řetězec, který představuje aktuální objekt.

Bezpečný přístup z více vláken

Veřejné statické členy tohoto typu (Shared v jazyce Visual Basic) jsou bezpečné pro přístup z více vláken. U členů instance není zaručeno, že budou bezpečné pro přístup z více vláken.