Array of custom structs doesn't keep its values, why?

Question

I'm new to C#, and I created a struct (MyMeshFace) and initialized an array consisting of some 40.000 of those structs, like so:

MyMeshFace[] m_meshFaces = new MyMeshFace[mesh.Faces.Count]; // ~40.000 faces

I then populate the array with data in a for-loop, debugging it all with breakpoints so that I can see with my own eyes that field objects are instantiated with empty values (i.e. edge = new Line(); etc) and after this initialization, seeing also that values are properly assigned to fields and object fields (like Line.From = Point; & Line.To = AnotherPoint; etc).

Problem: But, when I run through this list of m_meshFaces a second time, this time calling a function embedded in the struct in order to make the struct update its internal data, then the objects (Lines) no longer has any values! The Line objects in the structs really are instantiated, and thus they're valid objects and so they don't throw exceptions when accessed, but their values (X,Y,X) are zeroed (although I could via breakpoints see that the Lines were originally assigned with values in the first loop when they were initialized). And I have no idea why this is happening.

The code is straightforward:

public struct MyMeshFace
{
    public Line edgeAB;
    public Line edgeBC;
    ...
    public int facesABC[];
    public Point3d[] pointsABC;
    ...
    public void Init(Mesh m, int index)
    {
        edgeAB = new Line();
        edgeBC = new Line();
        ...
    }
    public void SetFaceData(Mesh m)
    {
        // UPDATE 3: Face corner indexes (to points) from mesh:
        var face = m.Faces[faceIndex];
        facesABC[xA] = face.A;
        facesABC[xB] = face.B;

        pointsABC[xA] = m.Vertices[facesABC[0]];
        pointsABC[xB] = m.Vertices[facesABC[1]];
        ...
        edgeAB.From = pointsABC[xA];
        edgeAB.To = pointsABC[xB];
        ...
    }
    public bool DoSomething()
    {
        if (edgeAB.From.X == 0 && edgeAB.From.Y == 0 && edgeAB.From.Z == 0)
           return false;   /* Fail ! */
        // 
        // Execution never makes it here :(
        // 
        return true;
    }
        ...
}

Main method (Update 2: Added call to Init and SetFaceData)

public void Main()
{   
    MyMeshFace[] m_meshFaces = new MyMeshFace[m_mesh.Faces.Count];
    for (var f = 0; f < m_meshFaces.GetLength(0); f++)
    {
        var face = m_meshFaces[f];
        face.Init(m_mesh, f);
        face.SetFaceData(m_mesh);
    }

    for (var x = 0; x < m_meshFaces.GetLength(0); x++)
    {
        var face = m_meshFaces[x];
        if (face.DoSomething())
            Print("Did something!");  # <-- This never happens
    }
}

I tried reading on Microsofts pages about structs, but no clue there. What am I doing wrong?

---

Edit FIX: This code works, according to anwers below:

public void Main()
{   
    MyMeshFace[] m_meshFaces = new MyMeshFace[m_mesh.Faces.Count];
    for (var f = 0; f < m_meshFaces.GetLength(0); f++)
    {
        // var face = m_meshFaces[f];       // <-- No no!
        // face.Init(m_mesh, f);            // <-- No no!
        // face.SetFaceData(m_mesh);        // <-- No no!

        m_meshFaces[f].Init(m_mesh, f);     // <-- OK! 
        m_meshFaces[f].SetFaceData(m_mesh); // <-- OK
    }

    for (var x = 0; x < m_meshFaces.GetLength(0); x++)
    {
        if (m_meshFaces[x].DoSomething())
            Print("Did something!");  // OK!
    }
}

// Rolf

Answer 1

When you do var face = m_meshFaces[f]; in your code (added comments to hightlight):

public void Main()
{   
    MyMeshFace[] m_meshFaces = new MyMeshFace[m_mesh.Faces.Count];
    for (var f = 0; f < m_faceInfo.GetLength(0); f++)
    {
        var face = m_meshFaces[f]; // <---
        face.Init(m_mesh, f);
        face.SetFaceData(m_mesh);
    }

    for (var x = 0; x < m_meshFaces.GetLength(0); x++)
    {
        var face = m_meshFaces[x]; // <---
        if (face.DoSomething())
            Print("Did something!");  # <-- This never happens
    }
}

You get a COPY of the struct.

Then you modify the copy, and never replace the original with the copy.

On the second loop, you take a A NEW COPY of the struct.

---

As per solutions, you may replace the original with the copy by doing m_meshFaces[f] = face; Or you may try working with the struct in the array directly:

m_meshFaces[f].Init(m_mesh, f);
m_meshFaces[f].SetFaceData(m_mesh);

---

This is explained on Microsoft Documentation:

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.

-- Structs (C# Programming Guide)

Answer 2

There seems to be a misconception in your part about how structs are handled when assigned to a variable. structs are value types, so when you assign var something = struct, the variable doesn't receive a reference to the struct's object, unlike a class (reference type); instead, it receives a copy of the value that the struct represents.

With that in mind, assignments like var face = m_mesh.Faces[f]; will not work the way you seem to be expecting them to. Your handling of face on the first for-loop will not affect the original m_mesh.Faces[f], unless you reassign face back to m_mesh.Faces[f] after it's modified.

---

Try the following code:

public void Main()
{   
    MyMeshFace[] m_meshFaces = new MyMeshFace[m_mesh.Faces.Count];
    for (var f = 0; f < m_faceInfo.GetLength(0); f++)
    {
        var face = m_mesh.Faces[f];
        face.Init(m_mesh, f);
        face.SetFaceData(m_mesh);
        m_mesh.Faces[f] = face; //<<<-----
    }

    for (var x = 0; x < m_meshFaces.GetLength(0); x++)
    {
        var face = m_meshFaces[x];
        if (face.DoSomething())
            Print("Did something!");
        m_meshFaces[x] = face; //<<<-----
    }
}

---

Update: Corrections to a typo in the OP made this section obsolete. It will be kept for future reference only.

Additionally: You also seem to have a misconception about array initialization and/or structs' default value.

Value types, incl. structs, cannot be null; they are always initialized to a default value. Since you are not populating the m_meshFaces array with any custom data, your command MyMeshFace[] m_meshFaces = new MyMeshFace[m_mesh.Faces.Count]; makes the array be only populated by default MyMeshFace structs. This is because array initialization new array[amount] only reserves the memory slots for a certain quantity (amount) of objects. It's not copying the original m_mesh.Faces collection; it's creating new Face objects entirely, all with default internal values.

The important thing about this is that if Line is also a struct (also initialized to defaults, which are probably 0), then...

if (edgeAB.From.X == 0 && edgeAB.From.Y == 0 && edgeAB.From.Z == 0)
           return false;   /* Fail ! */

...will always fail; as the From values are all always default, which is probably 0 on all, X & Y & Z.