protected System.Xml.XmlReader()

Constructs a new instance of the System.Xml.XmlReader class.

public System.Void Close()

Changes the System.Xml.XmlReader.ReadState to System.Xml.ReadState.Closed.

This method releases any resources allocated by the current instance, changes the System.Xml.XmlReader.ReadState to System.Xml.ReadState.Closed, and calls the Close method of any underlying System.IO.Stream or System.IO.TextReader instance. This method must be overridden in order to provide the functionality described above, as there is no default implementation.

public System.String GetAttribute(System.String name)

Returns the value of the attribute with the specified qualified name.

Parameter name: A System.String specifying the qualified name of the attribute.

Returns: A System.String containing the value of the specified attribute, or null if the attribute is not found.

This method does not move the reader. This method must be overridden in order to provide the functionality described above, as there is no default implementation.

public System.String GetAttribute(System.String name, System.String namespaceURI)

Returns the value of the attribute with the specified local name and namespace URI.

Parameter name: A System.String specifying the local name of the attribute.

Parameter namespaceURI: A System.String specifying the namespace URI of the attribute.

Returns: A System.String containing the value of the specified attribute, or null if the attribute is not found.

This method does not move the reader. This method must be overridden in order to provide the functionality described above, as there is no default implementation.

public System.String GetAttribute(System.Int32 i)

Returns the value of the attribute with the specified index relative to the containing element.

Parameter i: A System.Int32 specifying the zero-based index of the attribute relative to the containing element.

Returns: A System.String containing the value of the specified attribute.

Throws: : i is less than 0, or greater than or equal to the System.Xml.XmlReader.AttributeCount of the containing element.

This method does not move the reader. This method must be overridden in order to provide the functionality described above, as there is no default implementation.

public static System.Boolean IsName(System.String str)

Determines whether the specified string is a valid XML name.

Parameter str: A System.String specifying the name to validate.

Returns: A System.Boolean where true indicates the name is valid; otherwise, false.

This method uses the W3C XML 1.0 Recommendation (http://www.w3.org/TR/2000/REC-xml-20001006#NT-Name) to determine whether the name is valid.

public static System.Boolean IsNameToken(System.String str)

Determines whether the specified string is a valid XML name token (Nmtoken).

Parameter str: A System.String specifying the name to validate.

Returns: A System.Boolean where true indicates the name is valid; otherwise false.

This method uses the W3C XML 1.0 Recommendation (http://www.w3.org/TR/2000/REC-xml-20001006#NT-Nmtoken ) to determine whether the name token is valid.

public virtual System.Boolean IsStartElement(System.String localname, System.String ns)

Determines if a node containing content is an Element node with the specified local name and namespace URI.

Parameter localname: A System.String specifying the local name of an element.

Parameter ns: A System.String specifying the namespace URI associated with the element.

Returns: A System.Boolean where true indicates the node is an Element node with the specified local name and namespace URI; false otherwise.

Throws: : An error occurred while parsing the XML.

As described above. This method calls the System.Xml.XmlReader.MoveToContent method, which determines whether the current node can contain content and, if not, moves the reader to the next content node or the end of the input stream. When the reader is positioned on a content node, the node is checked to determine if it is an Element node with System.Xml.XmlReader.LocalName and System.Xml.XmlReader.NamespaceURI properties equal to localname and ns, respectively. Override this method to customize the behavior of this method in types derived from the System.Xml.XmlReader class. Use this method to determine whether the node returned by the System.Xml.XmlReader.MoveToContent method is an Element node with the specified local name and namespace URI.

public virtual System.Boolean IsStartElement(System.String name)

Determines if a node containing content is an Element node with the specified qualified name.

Parameter name: A System.String specifying the qualified name of an element.

Returns: A System.Boolean where true indicates the node is an Element node with the specified name; false otherwise.

Throws: : An error occurred while parsing the XML.

As described above. This method calls the System.Xml.XmlReader.MoveToContent method, which determines whether the current node can contain content and, if not, moves the reader to the next content node or the end of the input stream. When the reader is positioned on a content node, the node is checked to determine if it is an Element node with a System.Xml.XmlReader.Name property equal to name. Override this method to customize the behavior of this method in types derived from the System.Xml.XmlReader class. Use this method to determine whether the node returned by the System.Xml.XmlReader.MoveToContent method is an Element node with the specified name.

public virtual System.Boolean IsStartElement()

Determines if a node containing content is an Element node.

Returns: A System.Boolean where true indicates the node is an Element node; false otherwise.

Throws: : An error occurred while parsing the XML.

As described above. This method calls the System.Xml.XmlReader.MoveToContent method, which determines whether the current node can contain content and, if not, moves the reader to the next content node or the end of the input stream. When the reader is positioned on a content node, the node is checked to determine if it is an Element node. Override this method to customize the behavior of this method in types derived from the System.Xml.XmlReader class. Use this method to determine whether the node returned by the System.Xml.XmlReader.MoveToContent method is an Element node.

public System.String LookupNamespace(System.String prefix)

Resolves a namespace prefix in the scope of the current element.

Parameter prefix: A System.String specifying the prefix whose namespace URI is to be resolved. To return the default namespace, specify System.String.Empty.

Returns: A System.String containing the namespace URI to which the prefix maps. If prefix is not in System.Xml.XmlReader.NameTable or no matching namespace is found, null is returned.

As described above. This method must be overridden in order to provide the functionality described above, as there is no default implementation.

public System.Void MoveToAttribute(System.Int32 i)

Moves the position of the current instance to the attribute with the specified index relative to the containing element.

Parameter i: A System.Int32 specifying the zero-based index of the attribute relative to the containing element.

Throws: : i is less than 0 or greater than or equal to the System.Xml.XmlReader.AttributeCount of the containing element.

After calling this method, the System.Xml.XmlReader.Name, System.Xml.XmlReader.NamespaceURI, and System.Xml.XmlReader.Prefix properties reflect the properties of current attribute. This method must be overridden in order to provide the functionality described above, as there is no default implementation.

public System.Boolean MoveToAttribute(System.String name, System.String ns)

Moves the position of the current instance to the attribute with the specified local name and namespace URI.

Parameter name: A System.String specifying the local name of the attribute.

Parameter ns: A System.String specifying the namespace URI of the attribute.

Returns: A System.Boolean where true indicates the attribute was found; otherwise, false. If false, the position of the current instance does not change.

After calling this method, the System.Xml.XmlReader.Name, System.Xml.XmlReader.NamespaceURI, and System.Xml.XmlReader.Prefix properties reflect the properties of current attribute. This method must be overridden in order to provide the functionality described above, as there is no default implementation.

public System.Boolean MoveToAttribute(System.String name)

Moves the position of the current instance to the attribute with the specified qualified name.

Parameter name: A System.String specifying the qualified name of the attribute.

Returns: A System.Boolean where true indicates the attribute was found; otherwise, false. If false, the reader's position does not change.

After calling this method, the System.Xml.XmlReader.Name, System.Xml.XmlReader.NamespaceURI, and System.Xml.XmlReader.Prefix properties reflect the properties of current attribute. This method must be overridden in order to provide the functionality described above, as there is no default implementation.

public virtual System.Xml.XmlNodeType MoveToContent()

Determines whether the current node can contain content and, if not, moves the position of the current instance to the next content node or the end of the input stream.

Returns: The System.Xml.XmlNodeType of the content node, or System.Xml.XmlNodeType.None if the position of the reader has reached the end of the input stream.

Throws: : An error occurred while parsing the XML.

The following members of System.Xml.XmlNodeType can contain content: Attribute, CDATA, Element, EndElement, EntityReference, EndEntity, and Text. As described above. If the current node is an Attribute node, this method moves the position of the reader back to the Element node that owns the attribute. Override this method to customize the behavior of this method in types derived from the System.Xml.XmlReader class. Use this method to determine whether the current node can contain content and, if not, move the position of the reader to the next content node.

public System.Boolean MoveToElement()

Moves the position of the current instance to the node that contains the current Attribute node.

Returns: A System.Boolean where true indicates the position of the reader was moved; false indicates the reader was not positioned on an Attribute node and therefore the position of the reader was not moved.

The DocumentType, Element, and XmlDeclaration members of System.Xml.XmlNodeType can contain attributes. As described above. This method must be overridden in order to provide the functionality described above, as there is no default implementation.

public System.Boolean MoveToFirstAttribute()

Moves the position of the current instance to the first attribute associated with the current node.

Returns: A System.Boolean where true indicates the current node contains at least one attribute; otherwise, false.

If System.Xml.XmlReader.AttributeCount is non-zero, the position of the reader moves to the first attribute; otherwise, the position of the reader does not change. This method must be overridden in order to provide the functionality described above, as there is no default implementation.

public System.Boolean MoveToNextAttribute()

Moves the position of the current instance to the next attribute associated with the current node.

Returns: A System.Boolean where true indicates the position of the reader moved to the next attribute; false if there were no more attributes.

As described above. This method must be overridden in order to provide the functionality described above, as there is no default implementation.

public System.Boolean Read()

Moves the position of the current instance to the next node in the stream, exposing its properties.

Returns: A System.Boolean where true indicates the node was read successfully, and false indicates there were no more nodes to read.

Throws: : An error occurred while parsing the XML.

As described above. This method must be overridden in order to provide the functionality as described herein, as there is no default implementation. When a reader is first created and initialized, there is no information available. Calling this method is required to read the first node.

public System.Boolean ReadAttributeValue()

Parses an attribute value into one or more Text, EntityReference, and EndEntity nodes.

Returns: A System.Boolean where true indicates the attribute value was parsed, and false indicates the reader was not positioned on an attribute node or all the attribute values have been read.

To parse an EntityReference node, call the System.Xml.XmlReader.ResolveEntity method. After the node is parsed into child nodes, call the System.Xml.XmlReader.ReadAttributeValue method again to read the value of the entity. The System.Xml.XmlReader.Depth of an attribute value node is one plus the depth of the attribute node. When general entity references are stepped into or out of, the System.Xml.XmlReader.Depth increments or decrements by one, respectively. As described above. Implementations that cannot expand general entities should return general entities as a single empty (System.Xml.XmlReader.Value equals System.String.Empty) EntityReference node. Use this method after calling System.Xml.XmlReader.MoveToAttribute(System.String) to read through the Text , EntityReference, or EndEntity nodes that make up the attribute value. Call the System.Xml.XmlReader.ResolveEntity method to resolve the EntityReference nodes.

public virtual System.String ReadElementString(System.String localname, System.String ns)

Reads the contents of a text-only element with the specified local name and namespace URI.

Parameter localname: A System.String specifying the local name of an element.

Parameter ns: A System.String specifying the namespace URI associated with the element.

Returns: A System.String containing the contents of the element.

Throws: : The node is not an Element node, the System.Xml.XmlReader.LocalName property of the Element node does not equal localname, or the System.Xml.XmlReader.NamespaceURI property of the Element node does not equal ns, the element does not contain a simple text value, or an error occurred while parsing the XML.

As described above. This method calls the System.Xml.XmlReader.MoveToContent method. If the returned node is an Element node, this method compares the System.Xml.XmlReader.LocalName and System.Xml.XmlReader.NamespaceURI properties of the node to localname and ns, respectively. If they are equal, this method calls the System.Xml.XmlReader.ReadString method to read the contents of the element. Override this method to customize the behavior of this method in types derived from the System.Xml.XmlReader class. Use this method to read the contents of a text-only element with the specified local name and namespace URI.

public virtual System.String ReadElementString(System.String name)

Reads the contents of a text-only element with the specified qualified name.

Parameter name: A System.String specifying the qualified name of an element.

Returns: A System.String containing the contents of the element.

Throws: : The node is not an Element node, the System.Xml.XmlReader.Name property of the Element node does not equal name, the element does not contain a simple text value, or an error occurred while parsing the XML.

As described above. This method calls the System.Xml.XmlReader.MoveToContent method and, if the returned node is an Element node, compares the System.Xml.XmlReader.Name property of the node to name. If they are equal, this method calls the System.Xml.XmlReader.ReadString method to read the contents of the element. Override this method to customize the behavior of this method in types derived from the System.Xml.XmlReader class. Use this method to read the contents of a text-only element with the specified qualified name.

public virtual System.String ReadElementString()

Reads the contents of a text-only element.

Returns: A System.String containing the contents of the element.

Throws: : The node is not an Element node, the element does not contain a simple text value, or an error occurred while parsing the XML.

As described above. This method calls the System.Xml.XmlReader.MoveToContent method and, if the returned node is an Element node, calls the System.Xml.XmlReader.ReadString method to read the contents. Override this method to customize the behavior of this method in types derived from the System.Xml.XmlReader class. Use this method to read the contents of a text-only element.

public virtual System.Void ReadEndElement()

Reads an EndElement node and advances the reader to the next node.

Throws: : The node is not an EndElement node or an error occurred while parsing the XML.

As described above. This method calls the System.Xml.XmlReader.MoveToContent method, which determines whether the current node can contain content and, if not, moves the reader to the next content node or the end of the input stream. The node the reader ends up positioned on is checked to determine if it is an EndElement node. If so, the node is read and the reader is moved to the next node. Override this method to customize the behavior of this method in types derived from the System.Xml.XmlReader class. Use this method to read an EndElement node and advance the reader to the next node.

public System.String ReadInnerXml()

Reads the contents of the current node, including child nodes and markup.

Returns: A System.String containing the XML content, or System.String.Empty if the current node is neither an element nor attribute, or has no child nodes.

Throws: : The XML was not well-formed, or an error occurred while parsing the XML.

The current node and corresponding end node are not returned. If the current node is an element, after the call to this method, the reader is positioned after the corresponding end element. If the current node is an attribute, the position of the reader is not changed. For a comparison between this method and the System.Xml.XmlReader.ReadOuterXml method, see System.Xml.XmlTextReader.ReadInnerXml. This method must be overridden in order to provide the functionality described above, as there is no default implementation.

public System.String ReadOuterXml()

Reads the current node and its contents, including child nodes and markup.

Returns: A System.String containing the XML content, or System.String.Empty if the current node is neither an element nor attribute.

Throws: : The XML was not well-formed, or an error occurred while parsing the XML.

The current node and corresponding end node are returned. If the current node is an element, after the call to this method, the reader is positioned after the corresponding end element. If the current node is an attribute, the position of the reader is not changed. For a comparison between this method and the System.Xml.XmlReader.ReadOuterXml method, see System.Xml.XmlTextReader.ReadInnerXml. This method must be overridden in order to provide the functionality described above, as there is no default implementation.

public virtual System.Void ReadStartElement()

Reads an Element node and advances the reader to the next node.

Throws: : The node is not an Element node or an error occurred while parsing the XML.

As described above. This method calls the System.Xml.XmlReader.MoveToContent method, which determines whether the current node can contain content and, if not, moves the reader to the next content node or the end of the input stream. The node the reader ends up positioned on is checked to determine if it is an Element node. If so, the node is read and the reader is moved to the next node. Override this method to customize the behavior of this method in types derived from the System.Xml.XmlReader class. Use this method to read an Element node and advance the reader to the next node.

public virtual System.Void ReadStartElement(System.String name)

Reads an Element node with the specified qualified name and advances the reader to the next node.

Parameter name: A System.String specifying the qualified name of an element.

Throws: : The node is not an Element node, the System.Xml.XmlReader.Name property of the Element node does not equal name, or an error occurred while parsing the XML.

As described above. This method calls the System.Xml.XmlReader.MoveToContent method and, if the returned node is an Element node, compares the System.Xml.XmlReader.Name property of the node to name. If they are equal, this method calls the System.Xml.XmlReader.Read method to read the element and move to the next node. Override this method to customize the behavior of this method in types derived from the System.Xml.XmlReader class. Use this method to read an Element node with the specified qualified name, and advance the reader to the next node.

public virtual System.Void ReadStartElement(System.String localname, System.String ns)

Reads an Element node with the specified local name and namespace URI and advances the reader to the next node.

Parameter localname: A System.String specifying the local name of an element.

Parameter ns: A System.String specifying the namespace URI associated with the element.

Throws: : The node is not an Element node, the System.Xml.XmlReader.LocalName property of the Element node does not equal localname, the System.Xml.XmlReader.NamespaceURI property of the Element node does not equal ns, or an error occurred while parsing the XML.

As described above. This method calls the System.Xml.XmlReader.MoveToContent method. If the returned node is an Element node, this method compares the System.Xml.XmlReader.LocalName and System.Xml.XmlReader.NamespaceURI properties of the node to localname and ns, respectively. If they are equal, this method calls the System.Xml.XmlReader.Read method to read the element and move to the next node. Override this method to customize the behavior of this method in types derived from the System.Xml.XmlReader class. Use this method to read an Element node with the specified local name and namespace URI, and advance the reader to the next node.

public System.String ReadString()

Reads the contents of an element or text node as a string.

Returns: A System.String containing the contents of the Element or Text node, or System.String.Empty if the reader is positioned on any other type of node.

Throws: : An error occurred while parsing the XML.

If positioned on an Element node, this method concatenates all Text, SignificantWhitespace, Whitespace, and CDATA node types, and returns the concatenated data as the element content. If none of these node types exist, System.String.Empty is returned. Concatenation stops when any markup is encountered, which can occur in a mixed content model or when an element end tag is read. If positioned on an element Text node, this method performs the same concatenation from the Text node to the element end tag. If the reader is positioned on an attribute Text node, this method has the same functionality as if the reader were position on the element start tag. This method must be overridden in order to provide the functionality described above, as there is no default implementation.

public System.Void ResolveEntity()

Resolves the entity reference for EntityReference nodes.

Throws: : The reader is not positioned on a System.Xml.XmlNodeType.EntityReference node.

This method parses the entity reference into child nodes. When the parsing is finished a new System.Xml.XmlNodeType.EndEntity node is placed in the stream to close the EntityReference scope. To step into the entity after this method has been called, call the System.Xml.XmlReader.ReadAttributeValue method if the entity is part of an attribute value, or the System.Xml.XmlReader.Read method if the entity is part of element content. If this method is not called, the parser moves to the next node past the entity (child nodes are bypassed). This method must be overridden in order to provide the functionality as described in the Behaviors and Usage sections, as there is no default implementation. This method is required to throw an exception for implementations that do not support schema or DTD information. In this case, the System.Xml.XmlReader.CanResolveEntity property is required to return false. Use this method to resolve the entity reference for EntityReference nodes. Before calling this method, determine whether the reader can resolve an entity by checking the System.Xml.XmlReader.CanResolveEntity property.

public virtual System.Void Skip()

Skips over the current element and moves the position of the current instance to the next node in the stream.

Throws: : The XML was not well-formed, or an error occurred while parsing the XML.

If the reader is positioned on a non-empty Element node (System.Xml.XmlReader.IsEmptyElement equals false), the position of the reader is moved to the node following the corresponding EndElement node. The properties of the nodes that are skipped over are not exposed. If the reader is positioned on any other node type, the position of the reader is moved to the next node, in this case behaving like the System.Xml.XmlReader.Read method. This method calls the System.Xml.XmlReader.MoveToElement method before skipping to the next node. Override this method to customize the behavior of this method in types derived from the System.Xml.XmlReader class. Use this method to skip over the current node.

public virtual System.Boolean Equals(System.Object obj)

Determines whether the specified System.Object is equal to the current instance.

Parameter obj: The System.Object to compare with the current instance.

Returns: true if obj is equal to the current instance; otherwise, false.

The statements listed below are required to be true for all implementations of the System.Object.Equals(System.Object) method. In the list, x, y, and z represent non-null object references. See System.Object.GetHashCode for additional required behaviors pertaining to the System.Object.Equals(System.Object) method. Implementations of System.Object.Equals(System.Object) should not throw exceptions. The System.Object.Equals(System.Object) method tests for referential equality , which means that System.Object.Equals(System.Object) returns true if the specified instance of Object and the current instance are the same instance; otherwise, it returns false . An implementation of the System.Object.Equals(System.Object) method is shown in the following C# code: public virtual bool Equals(Object obj) { return this == obj; } For some kinds of objects, it is desirable to have System.Object.Equals(System.Object) test for value equality instead of referential equality. Such implementations of Equals return true if the two objects have the same "value", even if they are not the same instance. The definition of what constitutes an object's "value" is up to the implementer of the type, but it is typically some or all of the data stored in the instance variables of the object. For example, the value of a System.String is based on the characters of the string; the Equals method of the System.String class returns true for any two string instances that contain exactly the same characters in the same order. When the Equals method of a base class provides value equality, an override of Equals in a class derived from that base class should invoke the inherited implementation of Equals . It is recommended (but not required) that types overriding System.Object.Equals(System.Object) also override System.Object.GetHashCode. Hashtables cannot be relied on to work correctly if this recommendation is not followed. If your programming language supports operator overloading, and if you choose to overload the equality operator for a given type, that type should override the Equals method. Such implementations of the Equals method should return the same results as the equality operator. Following this guideline will help ensure that class library code using Equals (such as System.Collections.ArrayList and System.Collections.Hashtable ) behaves in a manner that is consistent with the way the equality operator is used by application code. If you are implementing a value type, you should follow these guidelines: For reference types, the guidelines are as follows: If you implement System.IComparable on a given type, you should override Equals on that type. The System.Object.Equals(System.Object) method is called by methods in collections classes that perform search operations, including the System.Array.IndexOf(System.Array,System.Object) method and the System.Collections.ArrayList.Contains(System.Object) method.

using System;
class MyClass {
   static void Main() {
      Object obj1 = new Object();
      Object obj2 = new Object();
      Console.WriteLine(obj1.Equals(obj2));
      obj1 = obj2; 
      Console.WriteLine(obj1.Equals(obj2)); 
   }
}

using System;
public class Point: object {
 int x, y;
 public override bool Equals(Object obj) {
 //Check for null and compare run-time types.
 if (obj == null || GetType() != obj.GetType()) return false;
 Point p = (Point)obj;
 return (x == p.x) && (y == p.y);
 }
 public override int GetHashCode() {
 return x ^ y;
 }
}

class Point3D: Point {
 int z;
 public override bool Equals(Object obj) {
 return base.Equals(obj) && z == ((Point3D)obj).z;
 }
 public override int GetHashCode() {
 return base.GetHashCode() ^ z;
 }
}

using System;
class Rectangle {
 Point a, b;
 public override bool Equals(Object obj) {
 if (obj == null || GetType() != obj.GetType()) return false;
 Rectangle r = (Rectangle)obj;
 //Use Equals to compare instance variables
 return a.Equals(r.a) && b.Equals(r.b);
 }
 public override int GetHashCode() {
 return a.GetHashCode() ^ b.GetHashCode();
 }
}

using System;
public struct Complex {
 double re, im;
 public override bool Equals(Object obj) {
 return obj is Complex && this == (Complex)obj;
 }
 public override int GetHashCode() {
 return re.GetHashCode() ^ im.GetHashCode();
 }
 public static bool operator ==(Complex x, Complex y) {
 return x.re == y.re && x.im == y.im;
 }
 public static bool operator !=(Complex x, Complex y) {
 return !(x == y);
 }
}

public static System.Boolean Equals(System.Object objA, System.Object objB)

Determines whether two object references are equal.

Parameter objA: First object to compare.

Parameter objB: Second object to compare.

Returns: true if one or more of the following statements is true: otherwise returns false.

This static method checks for null references before it calls objA.Equals(objB ) and returns false if either objA or objB is null. If the Equals(object obj) implementation throws an exception, this method throws an exception.

using System;

public class MyClass {
   public static void Main() {
   string s1 = "Tom";
   string s2 = "Carol";
   Console.WriteLine("Object.Equals(\"{0}\", \"{1}\") => {2}", 
      s1, s2, Object.Equals(s1, s2));

   s1 = "Tom";
   s2 = "Tom";
   Console.WriteLine("Object.Equals(\"{0}\", \"{1}\") => {2}", 
      s1, s2, Object.Equals(s1, s2));

   s1 = null;
   s2 = "Tom";
   Console.WriteLine("Object.Equals(null, \"{1}\") => {2}",
       s1, s2, Object.Equals(s1, s2));

   s1 = "Carol";
   s2 = null;
   Console.WriteLine("Object.Equals(\"{0}\", null) => {2}", 
       s1, s2, Object.Equals(s1, s2));

   s1 = null;
   s2 = null;
   Console.WriteLine("Object.Equals(null, null) => {2}", 
       s1, s2, Object.Equals(s1, s2));
   }
}
   

public System.Void Finalize()

Allows a System.Object to perform cleanup operations before the memory allocated for the System.Object is automatically reclaimed.

During execution, System.Object.Finalize is automatically called after an object becomes inaccessible, unless the object has been exempted from finalization by a call to System.GC.SuppressFinalize(System.Object). During shutdown of an application domain, System.Object.Finalize is automatically called on objects that are not exempt from finalization, even those that are still accessible. System.Object.Finalize is automatically called only once on a given instance, unless the object is re-registered using a mechanism such as System.GC.ReRegisterForFinalize(System.Object) and System.GC.SuppressFinalize(System.Object) has not been subsequently called. Conforming implementations of the CLI are required to make every effort to ensure that for every object that has not been exempted from finalization, the System.Object.Finalize method is called after the object becomes inaccessible. However, there may be some circumstances under which Finalize is not called. Conforming CLI implementations are required to explicitly specify the conditions under which Finalize is not guaranteed to be called. For example, Finalize might not be guaranteed to be called in the event of equipment failure, power failure, or other catastrophic system failures. In addition to System.GC.ReRegisterForFinalize(System.Object) and System.GC.SuppressFinalize(System.Object), conforming implementations of the CLI are allowed to provide other mechanisms that affect the behavior of System.Object.Finalize . Any mechanisms provided are required to be specified by the CLI implementation. The order in which the Finalize methods of two objects are run is unspecified, even if one object refers to the other. The thread on which Finalize is run is unspecified. Every implementation of System.Object.Finalize in a derived type is required to call its base type's implementation of Finalize . This is the only case in which application code calls System.Object.Finalize . The System.Object.Finalize implementation does nothing. A type should implement Finalize when it uses unmanaged resources such as file handles or database connections that must be released when the managed object that uses them is reclaimed. Because Finalize methods may be invoked in any order (including from multiple threads), synchronization may be necessary if the Finalize method may interact with other objects, whether accessible or not. Furthermore, since the order in which Finalize is called is unspecified, implementers of Finalize (or of destructors implemented through overriding Finalize) must take care to correctly handle references to other objects, as their Finalize method may already have been invoked. In general, referenced objects should not be considered valid during finalization. See the System.IDisposable interface for an alternate means of disposing of resources. For C# developers: Destructors are the C# mechanism for performing cleanup operations. Destructors provide appropriate safeguards, such as automatically calling the base type's destructor. In C# code, System.Object.Finalize cannot be called or overridden.

public virtual System.Int32 GetHashCode()

Generates a hash code for the current instance.

Returns: A System.Int32 containing the hash code for the current instance.

System.Object.GetHashCode serves as a hash function for a specific type. A hash function is used to quickly generate a number (a hash code) corresponding to the value of an object. Hash functions are used with hashtables. A good hash function algorithm rarely generates hash codes that collide. For more information about hash functions, see The Art of Computer Programming , Vol. 3, by Donald E. Knuth. All implementations of System.Object.GetHashCode are required to ensure that for any two object references x and y, if x.Equals(y) == true, then x.GetHashCode() == y.GetHashCode(). Hash codes generated by System.Object.GetHashCode need not be unique. Implementations of System.Object.GetHashCode are not permitted to throw exceptions. The System.Object.GetHashCode implementation attempts to produce a unique hash code for every object, but the hash codes generated by this method are not guaranteed to be unique. Therefore, System.Object.GetHashCode may generate the same hash code for two different instances. It is recommended (but not required) that types overriding System.Object.GetHashCode also override System.Object.Equals(System.Object) . Hashtables cannot be relied on to work correctly if this recommendation is not followed. Use this method to obtain the hash code of an object. Hash codes should not be persisted (i.e. in a database or file) as they are allowed to change from run to run.

using System;
public struct Int32 {
 int value;
 //other methods...

 public override int GetHashCode() {
 return value;
 }
}

using System;
public struct Point {
 int x;
 int y; 
 //other methods
 
 public override int GetHashCode() {
 return x ^ y;
 }
}

using System;
public class SomeType {
 public override int GetHashCode() {
 return 0;
 }
}

public class AnotherType {
 public override int GetHashCode() {
 return 1;
 }
}

public class LastType {
 public override int GetHashCode() {
 return 2;
 }
}
public class MyClass {
 SomeType a = new SomeType();
 AnotherType b = new AnotherType();
 LastType c = new LastType();

 public override int GetHashCode () {
 return a.GetHashCode() ^ b.GetHashCode() ^ c.GetHashCode();
 }
}

using System;
public struct Int64 {
 long value;
 //other methods...

 public override int GetHashCode() {
 return ((int)value ^ (int)(value >> 32));
 }
}

public System.Type GetType()

Gets the type of the current instance.

Returns: The instance of System.Type that represents the run-time type (the exact type) of the current instance.

For two objects x and y that have identical run-time types, System.Object.ReferenceEquals(System.Object,System.Object)(x.GetType(),y.GetType()) returns true .

using System;
public class MyBaseClass: Object {
}
public class MyDerivedClass: MyBaseClass {
}
public class Test {
   public static void Main() {
   MyBaseClass myBase = new MyBaseClass();
   MyDerivedClass myDerived = new MyDerivedClass();

   object o = myDerived;
   MyBaseClass b = myDerived;

   Console.WriteLine("mybase: Type is {0}", myBase.GetType());
   Console.WriteLine("myDerived: Type is {0}", myDerived.GetType());
   Console.WriteLine("object o = myDerived: Type is {0}", o.GetType());
   Console.WriteLine("MyBaseClass b = myDerived: Type is {0}", b.GetType());
   }
}

protected System.Object MemberwiseClone()

Creates a shallow copy of the current instance.

Returns: A shallow copy of the current instance. The run-time type (the exact type) of the returned object is the same as the run-time type of the object that was copied.

System.Object.MemberwiseClone creates a new instance of the same type as the current instance and then copies each of the object's non-static fields in a manner that depends on whether the field is a value type or a reference type. If the field is a value type, a bit-by-bit copy of all the field's bits is performed. If the field is a reference type, only the reference is copied. The algorithm for performing a shallow copy is as follows (in pseudo-code): for each instance field f in this instance if (f is a value type) bitwise copy the field if (f is a reference type) copy the reference end for loop This mechanism is referred to as a shallow copy because it copies rather than clones the non-static fields. Because System.Object.MemberwiseClone implements the above algorithm, for any object, a, the following statements are required to be true: System.Object.MemberwiseClone does not call any of the type's constructors. If System.Object.Equals(System.Object) has been overridden, a.MemberwiseClone().Equals(a) might return false . For an alternate copying mechanism, see System.ICloneable . System.Object.MemberwiseClone is protected (rather than public) to ensure that from verifiable code it is only possible to clone objects of the same class as the one performing the operation (or one of its subclasses). Although cloning an object does not directly open security holes, it does allow an object to be created without running any of its constructors. Since these constructors may establish important invariants, objects created by cloning may not have these invariants established, and this may lead to incorrect program behavior. For example, a constructor might add the new object to a linked list of all objects of this class, and cloning the object would not add the new object to that list -- thus operations that relied on the list to locate all instances would fail to notice the cloned object. By making the method protected, only objects of the same class (or a subclass) can produce a clone and implementers of those classes are (presumably) aware of the appropriate invariants and can arrange for them to be true without necessarily calling a constructor.

using System;
class MyBaseClass {
   public static string CompanyName = "My Company";
   public int age;
   public string name;
}

class MyDerivedClass: MyBaseClass {

   static void Main() {
   
   //Create an instance of MyDerivedClass
   //and assign values to its fields.
   MyDerivedClass m1 = new MyDerivedClass();
   m1.age = 42;
   m1.name = "Sam";

   //Do a shallow copy of m1
   //and assign it to m2.
   MyDerivedClass m2 = (MyDerivedClass) m1.MemberwiseClone();
   }
}

+---------------+

|     42        |                           m1 

+---------------+

|     +---------|-----------------> "Sam" 

+---------------+                    /|\ 

                                      | 

+---------------+                     | 

|     42        |                     |      m2 

+---------------+                     | 

|      +--------|---------------------| 

+---------------+

public static System.Boolean ReferenceEquals(System.Object objA, System.Object objB)

Determines whether two object references are identical.

Parameter objA: First object to compare.

Parameter objB: Second object to compare.

Returns: True if a and b refer to the same object or are both null references; otherwise, false.

This static method provides a way to compare two objects for reference equality. It does not call any user-defined code, including overrides of System.Object.Equals(System.Object) .

using System;
class MyClass {
   static void Main() {
   object o = null;
   object p = null;
   object q = new Object();
   Console.WriteLine(Object.ReferenceEquals(o, p));
   p = q;
   Console.WriteLine(Object.ReferenceEquals(p, q));
   Console.WriteLine(Object.ReferenceEquals(o, p));
   }
}
   

public virtual System.String ToString()

Creates and returns a System.String representation of the current instance.

Returns: A System.String representation of the current instance.

System.Object.ToString returns a string whose content is intended to be understood by humans. Where the object contains culture-sensitive data, the string representation returned by System.Object.ToString takes into account the current system culture. For example, for an instance of the System.Double class whose value is zero, the implementation of System.Double.ToString might return "0.00" or "0,00" depending on the current UI culture. Although there are no exact requirements for the format of the returned string, it should as much as possible reflect the value of the object as perceived by the user. System.Object.ToString is equivalent to calling System.Object.GetType to obtain the System.Type object for the current instance and then returning the result of calling the System.Object.ToString implementation for that type. The value returned includes the full name of the type. It is recommended, but not required, that System.Object.ToString be overridden in a derived class to return values that are meaningful for that type. For example, the base data types, such as System.Int32, implement System.Object.ToString so that it returns the string form of the value the object represents. Subclasses that require more control over the formatting of strings than System.Object.ToString provides should implement System.IFormattable, whose System.Object.ToString method uses the culture of the current thread.

using System;

class MyClass {
   static void Main() {
      object o = new object();
      Console.WriteLine (o.ToString());
   }
}