Creating a shallow copy of structures in C#

Question

I tried to search for my answer and found them in regards to C and not C# so thought of posting it.

My question might be trivial here.

As per my understanding (in simple terms)

After Copying has completed

Shallow Copy -> main and copied object (reference or value type) should point to the same object in memory

DeepCopy -> main and copied object (reference or value type) should point to different objects in memory

Going ahead with this, I have a structure in C# and trying to make a shallow copy of the same. I tried using "MemberwiseClone" method but I guess it works only for reference types. For value types i think "MemberwiseClone" method will box it into an object and unbox it into a different memory address in the stack.

What i have tried is as below.

My question is how (if at all possible) can I create a shallow copy of a simple structure?

I hope my fundamentals are correct here and not talking rubbish. Please correct me if I am wrong in any of the statements I have made.

Regards,

Samar

struct MyStruct : ICloneable
{
    public int MyProperty { get; set; }

    public object Clone()
    {
        return this.MemberwiseClone();//boxing into object
    }
}


    private void btnChkStr_Click(object sender, EventArgs e)
    {
        MyStruct struct1 = new MyStruct();
        struct1.MyProperty = 1;

        //MyStruct struct2 = struct1; //This will create a deep copy
        MyStruct struct2 = (MyStruct)(struct1.Clone());//unboxing into structure hence allocating a different memory address
        struct2.MyProperty = 2;

        MessageBox.Show(struct1.MyProperty.ToString()); //still showing 1
    }

[Structs](http://msdn.microsoft.com/library/saxz13w4.aspx): "Structs are copied on assignment. When a struct is assigned to a new variable, all the data is copied, and any modification to the new copy does not change the data for the original copy. This is important to remember when working with collections of value types such as `Dictionary`." -- You can't have a shallow copy of a struct. — Corak, Aug 02 '13 at 09:10
Trying to have a shallow copy of a "mutable" value type is wrong — doctorlove, Aug 02 '13 at 09:12
@musefan actually I do not have any reason for doing this. Just curious I guess. Sorry if I am creating any nuisance here. — samar, Aug 02 '13 at 09:22
I think the best you could do if you wanted a reference is to either use a pointer, or pass the struct by `ref` as a method parameter — musefan, Aug 02 '13 at 09:25

Kai Hartmann · Accepted Answer · 2019-12-09T23:27:07.870

Your expectation of what a deep copy vs a shallow copy does is not correct. A shallow copy copies all value types, and just the references of reference types. A deep copy copies all value types and all reference types.

So your struct already performs a shallow copy when doing:

MyStruct struct2 = struct1;

This code example (console application) shows, that changing a value of the object in the second struct changes also the value of the object in the first struct, because the object has just been copied by reference:

class Program
{
    static void Main(string[] args)
    {
        Test t1 = new Test();
        t1.i = 1;
        t1.o = new Klasse();
        t1.o.i = 1;

        Test t2 = t1;
        t2.i = 2;
        t2.o.i = 2;

        Console.WriteLine(t1.i.ToString());
        Console.WriteLine(t1.o.i.ToString());
        Console.WriteLine(t2.i.ToString());
        Console.WriteLine(t2.o.i.ToString());
        Console.Read();
    }
}

struct Test
{
    public int i;
    public Klasse o;
}

class Klasse
{
    public int i = 0;
}

So what you are trying to say is, with regards to value types, shallow copy and deep copy is the same thing? — samar, Aug 02 '13 at 09:52

ChaseMedallion · Answer 2 · 2013-08-02T09:38:16.393

Your definition of a shallow copy can be achieved by explicitly boxing a struct. However, because the struct is boxed it's not easy to access it's properties!

void Main()
{
    object o1 = new M { A = 1 };
    object o2 = o1;

    // o2.A = 100 (this can also be done using dynamic)
    var prop = typeof(M).GetProperty("A");
    prop.SetValue(o2, 100);

    // prints 100, since both point to the same instance
    Console.WriteLine(((M)o1).A);
}

public struct M {
    public int A { get; set; }
}

In general, though assigning a struct to a new variable (or calling MemberwiseClone()), will copy all fields of the struct.

It's also worth noting that your definitions of deep and shallow copy are different than what is normally used. In general:

Shallow copy: a new instance of the object is created, so all of its members are copied by reference (e. g. a.X and shallowCopyOfA.X would still reference the same object). Members that are value types (e. g. structs, & primitives) are copied by value.

Deep copy: a new instance of the object is created, and all members are also deeply copied.

`No overload for method 'SetValue' takes 2 arguments`, you can however use `prop.SetValue(o2, 100, null)` — musefan, Aug 02 '13 at 09:36
@musefan [The overload used](http://msdn.microsoft.com/en-us/library/hh194291.aspx) is new in the .NET 4.5 framework. If you don't have it, use `.SetValue(o2, 100, null)`, like you say (.NET 4.0 and earlier). — Jeppe Stig Nielsen, Aug 02 '13 at 09:51

Jeppe Stig Nielsen · Answer 3 · 2013-08-02T09:43:56.377

Not sure what you require of your "copy". As mentioned elsewhere, structs are already copied by value when assigned or passed to a method. So maybe you need nothing extra?

Maybe this is simply what you want (not sure if it's useful for anything!):

struct MyStruct : ICloneable
{
    public int MyProperty { get; set; }

    public MyStruct Clone()
    {
        return this;
    }
    object ICloneable.Clone()
    {
        return Clone();
    }
}

A word of warning: Your MyStruct is a so-called mutable struct because the set accessor of the auto-property is public. Many people consider mutable structs "evil" because the combination of value type semantics and mutability can lead to surprising behavior.

EDIT: If you want copy-by-reference semantics, why do you use a struct in the first place, rather than a class? A struct is not a reference to a location of the object, like a class is. As others have given examples of, boxing the MyStruct into an object variable will make that object be a reference to a box containing the MyStruct value. The reference to the box can be copied by reference.

You can create a class that contains just one instance field of type MyStruct. Then this class will be a "wrapping" of your struct into a reference type, and you can copy instances of such a class by usual reference type semantics (copy the reference, the object itself is not copied).

@musefan Maybe you're right. I tried to add some more info to my answer, but I feel my answer is becoming even more confusing than the question. — Jeppe Stig Nielsen, Aug 02 '13 at 09:44

score 0 · Answer 4 · answered Aug 02 '13 at 09:24

0

It is impossible to make such a shallow copy of a struct.

Consider using classes instead.

answered Aug 02 '13 at 09:24

lightbricko

2,649
15
21

Creating a shallow copy of structures in C#

4 Answers4