Objekte (C#-Programmierhandbuch)Objects (C# Programming Guide)

Die Definition einer Klasse oder Struktur ist mit einem Entwurf vergleichbar, der angibt, was der Typ machen kann.A class or struct definition is like a blueprint that specifies what the type can do. Ein Objekt ist im Grunde ein Speicherblock, der nach Plan zugewiesen und konfiguriert wurde.An object is basically a block of memory that has been allocated and configured according to the blueprint. Ein Programm kann viele Objekte der selben Klasse erstellen.A program may create many objects of the same class. Objekte werden auch Instanzen genannt, und sie können entweder in einer benannten Variable, einem Array oder in einer Auflistung gespeichert werden.Objects are also called instances, and they can be stored in either a named variable or in an array or collection. Der Client-Code ist der Code, der diese Variablen verwendet, um die Methoden aufzurufen und um auf die öffentlichen Eigenschaften des Objekts zuzugreifen.Client code is the code that uses these variables to call the methods and access the public properties of the object. In einer objektorientierten Programmiersprache wie C# besteht ein typisches Programm aus mehreren Objekten, die dynamisch interagieren.In an object-oriented language such as C#, a typical program consists of multiple objects interacting dynamically.

Hinweis

Statische Typen verhalten sich anders, als die hier beschriebenen.Static types behave differently than what is described here. Weitere Informationen finden Sie unter Statische Klassen und statische Klassenmember.For more information, see Static Classes and Static Class Members.

Strukturinstanzen im Vergleich zu KlasseninstanzenStruct Instances vs. Class Instances

Da Klassen Verweistypen sind, enthält eine Variable eines Klassenobjekts einen Verweis auf die Adresse des Objekts auf dem verwalteten Heap.Because classes are reference types, a variable of a class object holds a reference to the address of the object on the managed heap. Wenn dem ersten Objekt ein zweites Objekt desselben Typs zugewiesen wird, verweisen beide Variablen auf das Objekt in dieser Adresse.If a second object of the same type is assigned to the first object, then both variables refer to the object at that address. Dieser Punkt wird in diesem Thema an späterer Stelle ausführlicher behandelt.This point is discussed in more detail later in this topic.

Instanzen von Klassen werden mit dem new-Operator erstellt.Instances of classes are created by using the new operator. Im folgenden Beispiel ist Person der Typ und person1 und person 2 sind Instanzen oder Objekte des Typs.In the following example, Person is the type and person1 and person 2 are instances, or objects, of that type.

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
    //Other properties, methods, events...
}

class Program
{
    static void Main()
    {
        Person person1 = new Person("Leopold", 6);
        Console.WriteLine("person1 Name = {0} Age = {1}", person1.Name, person1.Age);

        // Declare  new person, assign person1 to it.
        Person person2 = person1;

        //Change the name of person2, and person1 also changes.
        person2.Name = "Molly";
        person2.Age = 16;

        Console.WriteLine("person2 Name = {0} Age = {1}", person2.Name, person2.Age);
        Console.WriteLine("person1 Name = {0} Age = {1}", person1.Name, person1.Age);

        // Keep the console open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();

    }
}
/*
    Output:
    person1 Name = Leopold Age = 6
    person2 Name = Molly Age = 16
    person1 Name = Molly Age = 16
*/

Da Strukturen Werttypen sind, enthält eine Variable eines Strukturobjekts eine Kopie des gesamten Objekts.Because structs are value types, a variable of a struct object holds a copy of the entire object. Instanzen von Strukturen können auch mithilfe des new-Operators erstellt werden; dies ist jedoch nicht erforderlich, wie im folgenden Beispiel gezeigt wird:Instances of structs can also be created by using the new operator, but this is not required, as shown in the following example:

public struct Person
{
    public string Name;
    public int Age;
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

public class Application
{
    static void Main()
    {
        // Create  struct instance and initialize by using "new".
        // Memory is allocated on thread stack.
        Person p1 = new Person("Alex", 9);
        Console.WriteLine("p1 Name = {0} Age = {1}", p1.Name, p1.Age);

        // Create  new struct object. Note that  struct can be initialized
        // without using "new".
        Person p2 = p1;

        // Assign values to p2 members.
        p2.Name = "Spencer";
        p2.Age = 7;
        Console.WriteLine("p2 Name = {0} Age = {1}", p2.Name, p2.Age);

        // p1 values remain unchanged because p2 is  copy.
        Console.WriteLine("p1 Name = {0} Age = {1}", p1.Name, p1.Age);

        // Keep the console open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/*
  Output:
    p1 Name = Alex Age = 9
    p2 Name = Spencer Age = 7
    p1 Name = Alex Age = 9
*/

Der Speicher für p1 und p2 ist dem Stapel des Threads zugeordnet.The memory for both p1 and p2 is allocated on the thread stack. Der Speicher wird zusammen mit dem Typ oder der Methode freigegeben, in dem bzw. in der er deklariert wird.That memory is reclaimed along with the type or method in which it is declared. Dies ist ein Grund, weshalb Strukturen bei Zuweisung kopiert werden.This is one reason why structs are copied on assignment. Im Gegensatz dazu wird der Speicher, der für eine Klasseninstanz zugeordnet ist, automatisch von der Common Language Runtime freigegeben (von Garbage Collection bereinigt), wenn alle Verweise auf das Objekt außerhalb des Gültigkeitsbereichs liegen.By contrast, the memory that is allocated for a class instance is automatically reclaimed (garbage collected) by the common language runtime when all references to the object have gone out of scope. Es ist nicht möglich, ein Klassenobjekt deterministisch wie in C++ zu zerstören.It is not possible to deterministically destroy a class object like you can in C++. Weitere Informationen zur Garbage Collection im .NET Framework.NET Framework finden Sie unter Garbage Collection.For more information about garbage collection in the .NET Framework.NET Framework, see Garbage Collection.

Hinweis

Die Belegung und Freigabe von Arbeitsspeicher auf dem verwalteten Heap ist in der Common Language Runtime stark optimiert.The allocation and deallocation of memory on the managed heap is highly optimized in the common language runtime. In den meisten Fällen besteht kein wesentlicher Unterschied zwischen den Leistungskosten beim Zuweisen einer Klasseninstanz auf dem Heap im Vergleich zum Zuweisen einer Strukturinstanz im Stapel.In most cases there is no significant difference in the performance cost of allocating a class instance on the heap versus allocating a struct instance on the stack.

Objektidentität im Vergleich zur WertgleichheitObject Identity vs. Value Equality

Wenn Sie zwei Objekte auf Gleichheit vergleichen, müssen Sie zuerst unterscheiden, ob Sie wissen möchten, ob die zwei Variablen das gleiche Objekt im Speicher darstellen, oder ob die Werte von einem oder mehreren Feldern gleich sind.When you compare two objects for equality, you must first distinguish whether you want to know whether the two variables represent the same object in memory, or whether the values of one or more of their fields are equivalent. Wenn Sie planen, Werte zu vergleichen, müssen Sie berücksichtigen, ob die Objekte Instanzen von Werttypen (Strukturen) oder Referenztypen (Klassen, Delegate, Arrays) sind.If you are intending to compare values, you must consider whether the objects are instances of value types (structs) or reference types (classes, delegates, arrays).

  • Verwenden Sie die statische Methode Equals, um zu bestimmen, ob zwei Klasseninstanzen auf den gleichen Speicherort im Arbeitsspeicher verweisen (d.h., sie haben die gleiche Identität).To determine whether two class instances refer to the same location in memory (which means that they have the same identity), use the static Equals method. (System.Object ist die implizite Basisklasse für alle Wert- und Referenztypen, einschließlich benutzerdefinierter Strukturen und Klassen.)(System.Object is the implicit base class for all value types and reference types, including user-defined structs and classes.)

  • Verwenden Sie die Methode ValueType.Equals, um zu bestimmen, ob die Instanzfelder in zwei Strukturinstanzen die gleichen Werte haben.To determine whether the instance fields in two struct instances have the same values, use the ValueType.Equals method. Da alle Strukturen implizit von System.ValueType erben, rufen Sie die Methode direkt an Ihrem Objekt auf, wie im folgenden Beispiel gezeigt wird:Because all structs implicitly inherit from System.ValueType, you call the method directly on your object as shown in the following example:

// Person is defined in the previous example.

//public struct Person
//{
//    public string Name;
//    public int Age;
//    public Person(string name, int age)
//    {
//        Name = name;
//        Age = age;
//    }
//}

Person p1 = new Person("Wallace", 75);
Person p2;
p2.Name = "Wallace";
p2.Age = 75;

if (p2.Equals(p1))
    Console.WriteLine("p2 and p1 have the same values.");

// Output: p2 and p1 have the same values.

Die Implementierung System.ValueType von Equals verwendet Reflektion, da sie bestimmen muss, was die Felder in jeder Struktur sind.The System.ValueType implementation of Equals uses reflection because it must be able to determine what the fields are in any struct. Wenn Sie eigene Strukturen erstellen, überschreiben Sie die Methode Equals, um einen effizienten Gleichheitsalgorithmus bereitzustellen, der spezifisch für Ihren Typ ist.When creating your own structs, override the Equals method to provide an efficient equality algorithm that is specific to your type.

  • Sie können möglicherweise die Methode Equals oder den ==-Operator verwenden, um zu bestimmen, ob die Werte des Felds in zwei Klasseninstanzen gleich sind.To determine whether the values of the fields in two class instances are equal, you might be able to use the Equals method or the == operator. Verwenden Sie sie jedoch nur, wenn die Klasse die Werte überschrieben oder überladen hat, um eine benutzerdefinierte Definition von „Gleichheit“ für Objekte dieses Typs bereitzustellen.However, only use them if the class has overridden or overloaded them to provide a custom definition of what "equality" means for objects of that type. Die Klasse kann auch die Schnittstelle IEquatable<T> oder die Schnittstelle IEqualityComparer<T> implementieren.The class might also implement the IEquatable<T> interface or the IEqualityComparer<T> interface. Beide Schnittstellen bieten Methoden, die zum Testen der Wertgleichheit verwendet werden können.Both interfaces provide methods that can be used to test value equality. Wenn Sie Ihre eigenen Klassen entwickeln, die Equals überschreiben, achten Sie darauf, die Richtlinien zu befolgen, die in Vorgehensweise: Definieren von Wertgleichheit für einen Typ und Object.Equals(Object) aufgeführt sind.When designing your own classes that override Equals, make sure to follow the guidelines stated in How to: Define Value Equality for a Type and Object.Equals(Object).

Weitere Informationen finden Sie unter: For more information:

Siehe auchSee Also

C#-ProgrammierhandbuchC# Programming Guide
objectobject
VererbungInheritance
classclass
structstruct
new-Operatornew Operator
Allgemeines TypsystemCommon Type System