Deep Copy and Object Cloning in C#

By the end of this page, you will understand the difference between shallow copy and deep copy in C#, why a simple copy is often not enough for reference types, and the most common ways developers duplicate objects safely. You will also see when manual copying is the best option and how to implement a practical deep copy method.

In C#, cloning an object means creating another object with the same data.

The important question is: what exactly gets copied?

There are two main kinds of copying:

• Shallow copy: copies the top-level fields only
• Deep copy: copies the object and also copies the nested objects inside it

This matters because many C# objects contain reference-type properties such as lists, arrays, or other custom objects.

If you make only a shallow copy, both objects may still point to the same nested data. That means changing a child object in the copy can also change the original.

Why this matters

In real programs, copying objects is common when you want to:

• edit data safely before saving
• keep an original version for comparison
• avoid accidental side effects
• create independent snapshots of state

Value types vs reference types

• Value types like int, double, and bool are copied by value
• Reference types like classes, arrays, and lists are copied by reference unless you explicitly duplicate them

For example:

int a = 5;
int b = a;
b = 10;

Changing b does not affect a.

But with objects:

Person p1 = new Person();
Person p2 = p1;

Now p1 and p2 refer to the same object in memory.

Important C# detail about ICloneable

C# has an ICloneable interface, but it is often avoided in modern code because it does not clearly say whether the clone is shallow or deep. That makes code harder to understand.

Because of that, many developers prefer one of these approaches:

• a copy constructor
• a clearly named method like DeepCopy()
• manual mapping to a new object
• serialization-based copying in limited scenarios

In practice, explicit copying is usually the safest and clearest approach.

Think of an object like a folder.

• A shallow copy gives you a new folder, but the papers inside are still the exact same papers shared with the original folder.
• A deep copy gives you a new folder and also photocopies every paper inside it, including papers inside smaller folders.

So if you write on a paper in the deep-copied folder, the original folder stays unchanged.

That is the key idea: with deep copying, you are not just copying the outside container. You are copying everything it owns that should be independent.

A common and clear way to support deep copying in C# is to write a method such as DeepCopy().

Example classes

public class Address
{
    public string City { get; set; }
    public string Street { get; set; }

    public Address DeepCopy()
    {
        return new Address
        {
            City = City,
            Street = Street
        };
    }
}

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public Address Address { get; set; }

    public Person DeepCopy()
    {
        return new Person
        {
            Name = Name,
            Age = Age,
            Address = Address?.DeepCopy()
        };
    }
}

Using the deep copy

var original = new Person
{
    Name = "Alice",
    Age = 30,
    Address = new Address
    {
        City = "London",
        Street = "Baker Street"
    }
};

var copy = original.DeepCopy();
copy.Name = "Bob";
copy.Address.City = "Paris";

Console.WriteLine(original.Name);         // Alice
Console.WriteLine(original.Address.City); // London
Console.WriteLine(copy.Name);             // Bob
Console.WriteLine(copy.Address.City);     // Paris

Why this works

• Name and Age are copied into a new Person
• Address is also copied into a new Address
• The new Person does not share nested mutable objects with the original

Copy constructor version

Another common pattern is a copy constructor.

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public Address Address { get; set; }

    public Person() { }

    public Person(Person other)
    {
        Name = other.Name;
        Age = other.Age;
        Address = other.Address == null
            ? null
            : new Address
            {
                City = other.Address.City,
                Street = other.Address.Street
            };
    }
}

Usage:

var copy = new Person(original);

This is very readable and makes the copying behavior explicit.

Consider this example:

public class Address
{
    public string City { get; set; }
}

public class Person
{
    public string Name { get; set; }
    public Address Address { get; set; }

    public Person DeepCopy()
    {
        return new Person
        {
            Name = Name,
            Address = Address == null ? null : new Address { City = Address.City }
        };
    }
}

var original = new Person
{
    Name = "Alice",
    Address = new Address { City = "London" }
};

var copy = original.DeepCopy();
copy.Name = "Bob";
copy.Address.City = "Paris";

Step-by-step

1. original is created.

   • original.Name is "Alice"
   • original.Address points to an Address object with City = "London"

2. original.DeepCopy() is called.

   • A new Person object is created
   • Name is copied as "Alice"
   • A new Address object is created
   • City is copied as "London"

3. copy.Name = "Bob";

   • Only the copied Person changes
   • original.Name remains "Alice"

4. copy.Address.City = "Paris";

   • Only the copied Address changes
   • original.Address.City remains "London"

Final state

Because both Person and its nested Address were recreated, the two objects are fully independent for those fields.

Deep copying is useful when you need a safe duplicate of an object graph.

Common scenarios

• Edit forms

  • Load a customer profile into a form
  • Let the user make changes
  • Cancel without changing the original object

• Undo/redo systems

  • Store snapshots of data before changes
  • Restore an earlier version later

• Configuration handling

  • Duplicate a base configuration
  • Adjust values for a specific environment without affecting the original

• Data transformation pipelines

  • Copy source data before normalizing or cleaning it
  • Preserve the original for logging or auditing

• Business rules and simulations

  • Clone an order, invoice, or game state
  • Test changes without modifying the real object

• API request processing

  • Create a working copy of incoming data before validation or enrichment

In all of these cases, the main goal is to avoid accidental shared state.

In real projects, developers usually avoid a generic magical cloning solution and use explicit copying instead.

Common patterns

Copy constructors

These are popular when the class is small or medium-sized.

var copiedUser = new User(existingUser);

This is clear and easy to maintain.

Named methods like DeepCopy()

These make intent obvious.

var snapshot = order.DeepCopy();

This is often better than Clone() because the name tells readers what kind of copy they are getting.

Mapping to a new object

In services and APIs, developers often map one object to another instead of cloning directly.

var dto = new UserDto
{
    Name = user.Name,
    Email = user.Email
};

This is especially common when converting between domain models, DTOs, and view models.

Guard clauses for null nested objects

When deep copying, nested objects may be null.

Address = other.Address?.DeepCopy();

This prevents NullReferenceException.

Cloning collections carefully

If a class has a list of child objects, developers usually create a new list and deep copy each item.

Items = other.Items?.Select(item => item.DeepCopy()).ToList();

This avoids sharing the same list or the same child objects.

Immutability as an alternative

Some codebases reduce cloning needs by using immutable objects. If objects cannot change, sharing them becomes safer.

That said, many business applications still use mutable classes, so explicit deep copying remains important.

1. Confusing assignment with copying

This does not clone the object:

var copy = original;

It only creates another reference to the same object.

Fix

Create a new object and copy the data.

2. Using MemberwiseClone() and assuming it is deep

MemberwiseClone() creates a shallow copy.

public Person ShallowCopy()
{
    return (Person)this.MemberwiseClone();
}

If Person contains an Address, both copies still share the same Address object.

Fix

After MemberwiseClone(), manually clone nested reference properties, or skip it and write a full deep copy method.

3. Copying the object but not the child objects

Broken example:

public Person DeepCopy()
{
    return new Person
    {
        Name = Name,
        Address = Address
    };
}

This still shares the same Address reference.

Fix

public Person DeepCopy()
{
    return new Person
    {
        Name = Name,
        Address = Address?.DeepCopy()
    };
}

4. Forgetting to copy collections properly

Broken example:

public class Order
{
    public List<OrderItem> Items { get; set; }

    public Order DeepCopy()
    {
        return new Order
        {
            Items = Items
        };
    }
}

Now both orders use the same list.

Fix

public Order DeepCopy()
{
    return new Order
    {
        Items = Items?.Select(item => item.DeepCopy()).ToList()
    };
}

5. Relying on ICloneable without defining behavior

ICloneable.Clone() does not promise whether the result is shallow or deep.

Fix

Use a method name that makes behavior clear, such as:

• DeepCopy()
• ShallowCopy()
• CopyFrom()

6. Forgetting new properties later

A manual copy method can become outdated if the class changes.

Fix

• update copy logic whenever the class changes
• keep copy methods close to the class definition
• add tests that verify independence between original and copy

Common ways to duplicate objects in C#

MemberwiseClone() vs manual deep copy

Copy constructor vs DeepCopy() method

In most codebases, the best choice is whichever is most explicit and easiest to maintain.

Quick reference

Assignment is not cloning

var copy = original;

Both variables point to the same object.

Shallow copy

var copy = (MyClass)this.MemberwiseClone();

• creates a new top-level object
• nested reference objects are still shared

Deep copy pattern

public MyClass DeepCopy()
{
    return new MyClass
    {
        Name = Name,
        Child = Child?.DeepCopy()
    };
}

Copy collections safely

Items = Items?.Select(x => x.DeepCopy()).ToList();

Prefer explicit names

Use names like:

• DeepCopy()
• ShallowCopy()
• copy constructor: new MyClass(other)

Avoid ambiguity

Be careful with:

• ICloneable
• MemberwiseClone() used alone

Rule of thumb

• If the class contains only value types and immutable values, copying is simpler.
• If the class contains mutable reference types, deep copy nested objects too.

Edge case

If your object graph contains cycles or shared references, a simple recursive deep copy may need extra logic to avoid infinite loops or duplicating shared nodes incorrectly.

What is the difference between shallow copy and deep copy in C#?

A shallow copy duplicates the outer object only. A deep copy duplicates the outer object and its nested reference objects too.

Does MemberwiseClone() do a deep copy?

No. MemberwiseClone() creates a shallow copy.

Is ICloneable recommended in C#?

Usually not for new code, because it does not clearly define whether Clone() returns a shallow or deep copy.

What is the safest way to deep copy an object in C#?

The safest common approach is to write an explicit DeepCopy() method or a copy constructor that copies all nested mutable objects.

Do I need deep copy for strings?

No in most cases. string is immutable in C#, so sharing the same string value is safe.

How do I deep copy a list of objects in C#?

Create a new list and deep copy each item:

var copied = originalList.Select(x => x.DeepCopy()).ToList();

Why did changing my copied object also change the original?

Because the copy likely reused the same nested reference objects, so both objects were still sharing internal state.

Related concepts

• Reference types — Important because classes are usually copied by reference, not duplicated automatically.
• Value types — Useful for understanding why int behaves differently from custom class instances.
• Mutable vs immutable objects — Immutability can reduce the need for cloning.
• Copy constructors — A common explicit pattern for duplicating objects.
• MemberwiseClone() — Relevant because it performs shallow copying.
• Collections in C# — Lists and arrays often need special handling during deep copy.
• Null handling — Deep copy methods often need null-safe logic for nested properties.
• Object mapping — Many real applications map to new objects instead of cloning existing ones.