Object-Klasse
Unterstützt sämtliche Klassen in der Hierarchie von .NET Framework-Klassen und stellt abgeleiteten Klassen Low-Level-Dienste zur Verfügung. Dies ist die allen Klassen von .NET Framework übergeordnete Basisklasse und stellt den Stamm der Typhierarchie dar.
Namespace: System
Assembly: mscorlib (in mscorlib.dll)
Syntax
'Declaration
<SerializableAttribute> _
<ComVisibleAttribute(True)> _
<ClassInterfaceAttribute(ClassInterfaceType.AutoDual)> _
Public Class Object
'Usage
Dim instance As Object
[SerializableAttribute]
[ComVisibleAttribute(true)]
[ClassInterfaceAttribute(ClassInterfaceType.AutoDual)]
public class Object
[SerializableAttribute]
[ComVisibleAttribute(true)]
[ClassInterfaceAttribute(ClassInterfaceType::AutoDual)]
public ref class Object
/** @attribute SerializableAttribute() */
/** @attribute ComVisibleAttribute(true) */
/** @attribute ClassInterfaceAttribute(ClassInterfaceType.AutoDual) */
public class Object
SerializableAttribute
ComVisibleAttribute(true)
ClassInterfaceAttribute(ClassInterfaceType.AutoDual)
public class Object
Hinweise
Programmiersprachen benötigen i. d. R. keine Klasse zur Deklaration der Vererbung von Object, da die Vererbung implizit ist.
Da alle Klassen in .NET Framework von Object abgeleitet sind, steht jede in der Object-Klasse definierte Methode in allen Objekten im System zur Verfügung. Abgeleitete Klassen besitzen und nutzen die Möglichkeit, einige dieser Methoden zu überschreiben. Dazu gehören folgende Methoden:
Equals – Unterstützt Vergleiche zwischen Objekten.
Finalize – Führt vor der automatischen Freigabe eines Objekts Bereinigungsaktionen durch.
GetHashCode – Generiert zur Unterstützung einer Hashtabelle eine Zahl, die dem Wert des Objekts entspricht.
ToString – Stellt eine lesbare Zeichenfolge her, die eine Instanz der Klasse beschreibt.
Leistungsaspekte
Wenn Sie eine Klasse (z. B. eine Auflistung) entwerfen, die jeden Objekttyp behandeln muss, können Sie Klassenmember erstellen, die Instanzen der Object-Klasse akzeptieren. Das Boxing und Unboxing von Typen ist jedoch leistungsintensiv. Wenn Sie wissen, dass die neue Klasse häufig bestimmte Werttypen behandeln wird, können Sie eines von zwei Verfahren zur Minimierung des Kostenaufwands für Boxing anwenden.
Das eine Verfahren besteht darin, eine allgemeine Methode zu erstellen, die einen Object-Typ akzeptiert, sowie eine Menge von typabhängigen Methodenüberladungen, die jeden Wert akzeptieren, den die Klasse häufig behandeln soll. Wenn eine typabhängige Methode vorhanden ist, die den aufrufenden Parametertyp akzeptiert, entfällt das Boxing, und die typabhängige Methode wird aufgerufen. Wenn es in der Methode kein Argument gibt, das mit dem aufrufenden Parametertyp übereinstimmt, wird der Parameter geschachtelt, und die allgemeine Methode wird aufgerufen. Diese Vorgehensweise liefert Methoden, die CLS-kompatibel sind.
Das andere Verfahren besteht darin, die Klasse und ihre Methoden so zu entwerfen, dass Generika verwendet werden können. Wenn Sie eine Instanz der Klasse erstellen und ein Argument von generischem Typ angeben, erstellt die Common Language Runtime einen geschlossenen generischen Typ. Die generische Methode ist typabhängig und kann aufgerufen werden, ohne den aufrufenden Parameter mittels Boxing zu verpacken. Diese Vorgehensweise liefert Methoden, die in .NET Framework, Version 2.0, nicht CLS-kompatibel sind.
Beispiel
Das folgende Beispiel definiert einen Punkttyp, der von der Object-Klasse abgeleitet ist, und überschreibt viele der virtuellen Methoden der Object-Klasse. Außerdem wird anhand des Beispiels veranschaulicht, wie viele der statischen Methoden und Instanzenmethoden der Object-Klasse aufgerufen werden.
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.
Point 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 String.Format("({0}, {1})", 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.
Point p1 = new Point(1,2);
// Make another Point object that is a copy of the first.
Point p2 = p1.Copy();
// Make another variable that references the first Point object.
Point 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: {0}", p1.ToString());
}
}
// This code produces the following output.
//
// False
// True
// True
// p1's value is: (1, 2)
using namespace System;
// The Point class is derived from System.Object.
ref class Point
{
public:
int x;
public:
int y;
public:
Point(int x, int y)
{
this->x = x;
this->y = y;
}
public:
virtual bool Equals(Object^ obj) override
{
// 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.
Point^ other = (Point^) obj;
return (this->x == other->x) && (this->y == other->y);
}
// Return the XOR of the x and y fields.
public:
virtual int GetHashCode() override
{
return x ^ y;
}
// Return the point's value as a string.
public:
virtual String^ ToString() override
{
return String::Format("({0}, {1})", x, y);
}
// Return a copy of this point object by making a simple
// field copy.
public:
Point^ Copy()
{
return (Point^) this->MemberwiseClone();
}
};
int main()
{
// Construct a Point object.
Point^ p1 = gcnew Point(1, 2);
// Make another Point object that is a copy of the first.
Point^ p2 = p1->Copy();
// Make another variable that references the first
// Point object.
Point^ 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: {0}", p1->ToString());
}
// This code produces the following output.
//
// False
// True
// True
// p1's value is: (1, 2)
Vererbungshierarchie
System.Object
Abgeleitete Klassen
Threadsicherheit
Öffentliche statische (Shared in Visual Basic) Member dieses Typs sind bei Verwendung in mehreren Threads sicher. Bei Instanz-Membern ist die Threadsicherheit nicht gewährleistet.
Plattformen
Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.
Versionsinformationen
.NET Framework
Unterstützt in: 2.0, 1.1, 1.0
.NET Compact Framework
Unterstützt in: 2.0, 1.0