Objects - create instances of types

Article • 09/17/2021

A class or struct definition is like a blueprint that specifies what the type can do. An object
is basically a block of memory that has been allocated and configured according to the
blueprint. A program may create many objects of the same class. Objects are also called
instances, and they can be stored in either a named variable or in an array or collection.
Client code is the code that uses these variables to call the methods and access the public
properties of the object. In an object-oriented language such as C#, a typical program
consists of multiple objects interacting dynamically.

７ Note

Static types behave differently than what is described here. For more information, see
Static Classes and Static Class Members.

Struct Instances vs. Class Instances

Because classes are reference types, a variable of a class object holds a reference to the
address of the object on the managed heap. If a second variable of the same type is
assigned to the first variable, then both variables refer to the object at that address. This
point is discussed in more detail later in this article.

Instances of classes are created by using the new operator. In the following example,
Person is the type and person1 and person2 are instances, or objects, of that type.

using System;

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);
}
}
/*
Output:
person1 Name = Leopold Age = 6
person2 Name = Molly Age = 16
person1 Name = Molly Age = 16
*/

Because structs are value types, a variable of a struct object holds a copy of the entire
object. Instances of structs can also be created by using the new operator, but this isn't
required, as shown in the following example:

using System;

namespace 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);
}
}
/*
Output:
p1 Name = Alex Age = 9
p2 Name = Spencer Age = 7
p1 Name = Alex Age = 9
*/
}

The memory for both p1 and p2 is allocated on the thread stack. That memory is reclaimed
along with the type or method in which it's declared. This is one reason why structs are
copied on assignment. 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. It isn't possible to deterministically
destroy a class object like you can in C++. For more information about garbage collection
in .NET, see Garbage Collection.

７ Note

The allocation and deallocation of memory on the managed heap is highly optimized
in the common language runtime. 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.

Object Identity vs. Value Equality

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. If you're intending to compare values,
you must consider whether the objects are instances of value types (structs) or reference
types (classes, delegates, arrays).

To determine whether two class instances refer to the same location in memory
(which means that they have the same identity), use the static Object.Equals method.
(System.Object is the implicit base class for all value types and reference types,
including user-defined structs and classes.)

To determine whether the instance fields in two struct instances have the same values,
use the ValueType.Equals method. 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 = new Person("", 42);
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.

The System.ValueType implementation of Equals uses boxing and reflection in some

cases. For information about how to provide an efficient equality algorithm that is
specific to your type, see How to define value equality for a type. Records are
reference types that use value semantics for equality.

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. 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. The class might also implement the
IEquatable<T> interface or the IEqualityComparer<T> interface. Both interfaces
provide methods that can be used to test value equality. 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).

Related Sections
For more information:

Classes
Constructors
Finalizers
Events
object
Inheritance
class
Structure types
new Operator
Common Type System

６ Collaborate with us on
GitHub .NET feedback
.NET is an open source project. Select a
The source for this content can
link to provide feedback:
be found on GitHub, where you
can also create and review issues
and pull requests. For more  Open a documentation issue
information, see our contributor
guide.  Provide product feedback