.NET Framework Class Library Object Class Supports all classes in the .NET Framework class hierarchy and provides low-level services to derived classes. This is the ultimate base class of all classes in the .NET Framework; it is the root of the type hierarchy.
Inheritance Hierarchy
System..::.Object All classes, structures, enumerations, and delegates.
Namespace:
System
Assembly:
mscorlib (in mscorlib.dll)
Syntax
<SerializableAttribute> _
<ClassInterfaceAttribute(ClassInterfaceType.AutoDual)> _
<ComVisibleAttribute(True)> _
Public Class Object
[SerializableAttribute]
[ClassInterfaceAttribute(ClassInterfaceType.AutoDual)]
[ComVisibleAttribute(true)]
public class Object
[SerializableAttribute]
[ClassInterfaceAttribute(ClassInterfaceType::AutoDual)]
[ComVisibleAttribute(true)]
public ref class Object
[<SerializableAttribute>]
[<ClassInterfaceAttribute(ClassInterfaceType.AutoDual)>]
[<ComVisibleAttribute(true)>]
type Object = class end
The Object type exposes the following members.
Remarks
Languages typically do not require a class to declare inheritance from Object because the inheritance is implicit. Because all classes in the .NET Framework are derived from Object, every method defined in the Object class is available in all objects in the system. Derived classes can and do override some of these methods, including:
Equals - Supports comparisons between objects.
Finalize - Performs cleanup operations before an object is automatically reclaimed.
GetHashCode - Generates a number corresponding to the value of the object to support the use of a hash table.
ToString - Manufactures a human-readable text string that describes an instance of the class.
Performance ConsiderationsIf you are designing a class, such as a collection, that must handle any type of object, you can create class members that accept instances of the Object class. However, the process of boxing and unboxing a type carries a performance cost. If you know your new class will frequently handle certain value types you can use one of two tactics to minimize the cost of boxing. One tactic is to create a general method that accepts an Object type, and a set of type-specific method overloads that accept each value type you expect your class to frequently handle. If a type-specific method exists that accepts the calling parameter type, no boxing occurs and the type-specific method is invoked. If there is no method argument that matches the calling parameter type, the parameter is boxed and the general method is invoked. The other tactic is to design your class and its methods to use generics. The common language runtime creates a closed generic type when you create an instance of your class and specify a generic type argument. The generic method is type-specific and can be invoked without boxing the calling parameter.
Although it is sometimes necessary to develop general purpose classes that accept and return Object types, you can improve performance by also providing a type-specific class to handle a frequently used type. For example, providing a class that is specific to setting and getting Boolean values eliminates the cost of boxing and unboxing Boolean values.
Examples
The following example defines a Point type derived from the Object class and overrides many of the virtual methods of the Object class. In addition, the example shows how to call many of the static and instance methods of the Object class.
' 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 XOr y
End Function
' Return the point's value as a string.
Public Overrides Function ToString() As String
Return String.Format("({0}, {1})", 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: {0}", p1.ToString())
End Sub
End Class
' This example produces the following output:
'
' False
' True
' True
' p1's value is: (1, 2)
'
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 example 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)
Version Information
.NET FrameworkSupported in: 4, 3.5, 3.0, 2.0, 1.1, 1.0 .NET Framework Client ProfileSupported in: 4, 3.5 SP1 Portable Class LibrarySupported in: Portable Class Library
Platforms
Windows 7, Windows Vista SP1 or later, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (Server Core Role not supported), Windows Server 2008 R2 (Server Core Role not supported), Windows Server 2003 SP2
The .NET Framework does not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.
Thread Safety
Public static (Shared in Visual Basic) members of this type are thread safe. Instance members are not guaranteed to be thread-safe.
See Also
|
Biblioteca de clases de .NET Framework Object (Clase) Admite todas las clases de la jerarquía de clases de .NET Framework y proporciona servicios de bajo nivel a las clases derivadas. Se trata de la clase base fundamental de todas las clases de .NET Framework; es la raíz de la jerarquía de tipos.
Jerarquía de herencia
System..::.Object Todas las clases, estructuras, enumeraciones y delegados.
Espacio de nombres:
System
Ensamblado:
mscorlib (en mscorlib.dll)
Sintaxis
<SerializableAttribute> _
<ClassInterfaceAttribute(ClassInterfaceType.AutoDual)> _
<ComVisibleAttribute(True)> _
Public Class Object
[SerializableAttribute]
[ClassInterfaceAttribute(ClassInterfaceType.AutoDual)]
[ComVisibleAttribute(true)]
public class Object
[SerializableAttribute]
[ClassInterfaceAttribute(ClassInterfaceType::AutoDual)]
[ComVisibleAttribute(true)]
public ref class Object
[<SerializableAttribute>]
[<ClassInterfaceAttribute(ClassInterfaceType.AutoDual)>]
[<ComVisibleAttribute(true)>]
type Object = class end
El tipo Object expone los siguientes miembros.
Comentarios
Normalmente, los lenguajes no precisan una clase para declarar la herencia de Object porque está implícita. Dado que todas las clases de .NET Framework se derivan de Object, todos los métodos definidos en la clase Object están disponibles en todos los objetos del sistema. Las clases derivadas pueden reemplazar, y de hecho reemplazan, algunos de estos métodos, entre los que se incluyen los siguientes:
Equals: admite comparaciones entre objetos.
Finalize: realiza operaciones de limpieza antes de que un objeto sea reclamado automáticamente.
GetHashCode: genera un número que se corresponde con el valor del objeto que admite el uso de una tabla hash.
ToString: crea una cadena de texto legible para el usuario que describe una instancia de la clase.
Consideraciones sobre el rendimientoSi está diseñando una clase, como una colección, que deba controlar cualquier tipo de objeto, puede crear miembros de clase que acepten instancias de la clase Object. Sin embargo, el proceso de aplicar las conversiones boxing y unboxing a un tipo implica una reducción del rendimiento. Si sabe que la nueva clase controlará con frecuencia ciertos tipos de valor, hay dos procedimientos para minimizar el costo de aplicar la conversión boxing. Uno de los procedimientos es crear un método general que acepte un tipo Object, y un conjunto de sobrecargas de método específicas del tipo que acepten cada uno de los tipos de valor que se espera que la clase controle con frecuencia. Si existe un método específico de tipos que acepte el tipo de parámetro de la llamada, no se produce ninguna conversión boxing y se llama al método específico de tipos. Si no hay ningún argumento de método que coincida con el tipo de parámetro de la llamada, el parámetro se somete a la conversión boxing y se llama al método general. El otro procedimiento es diseñar la clase y sus métodos para que utilicen genéricos. Common Language Runtime crea un tipo genérico cerrado cuando se crea una instancia de la clase y se especifica un argumento de tipo genérico. El método genérico es específico del tipo y se puede invocar sin aplicar la conversión boxing al parámetro de llamada.
Aunque a veces resulta necesario desarrollar clases de propósito general que acepten y devuelvan tipos Object, es posible mejorar el rendimiento proporcionando también una clase específica del tipo para controlar un tipo de uso frecuente. Por ejemplo, si se proporciona una clase específica para establecer y obtener valores booleanos, se elimina el costo de aplicar conversiones boxing y unboxing a los valores booleanos.
Ejemplos
En el ejemplo siguiente se define un tipo Point derivado de la clase Object y se reemplazan muchos de los métodos virtuales de la clase Object. Además, en el ejemplo se muestra cómo se llama a muchos de los métodos estáticos y de instancia de la clase Object.
' 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 XOr y
End Function
' Return the point's value as a string.
Public Overrides Function ToString() As String
Return String.Format("({0}, {1})", 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: {0}", p1.ToString())
End Sub
End Class
' This example produces the following output:
'
' False
' True
' True
' p1's value is: (1, 2)
'
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 example 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)
Información de versión
.NET FrameworkCompatible con: 4, 3.5, 3.0, 2.0, 1.1, 1.0 .NET Framework Client ProfileCompatible con: 4, 3.5 SP1 Compatible con:
Plataformas
Windows 7, Windows Vista SP1 o posterior, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (no se admite Server Core), Windows Server 2008 R2 (se admite Server Core con SP1 o posterior), Windows Server 2003 SP2
.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.
Seguridad para subprocesos
Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. Sin embargo, no se garantiza que los miembros de instancia sean seguros para la ejecución de subprocesos.
Vea también
|