Why is Linq Select making my new object a reference to the object I copied its constructor arguments from?

I'm making a video game using Unity & C#. In the initialization function for one of the enemies, it uses C# Coroutines to

1. Make its outlines transparent
2. Wait for the loading animation to finish
3. Return the outlines to their original color.

This was my first attempt:

           IEnumerable<(Outline, Color)> outlines = GetComponentsInChildren<Outline>()
                .Select(delegate (Outline outline) 
            {
                float r = outline.effectColor.r;
                float g = outline.effectColor.g;
                float b = outline.effectColor.b;
                float a = outline.effectColor.a;
                return (outline, new Color(r, g, b, a));
            });
            foreach ((Outline outline, Color _) in outlines) {
                Color transparent = Vector4.zero;
                outline.effectColor = transparent;
            }
            yield return new WaitForSeconds(LOAD_TIME);
            // ...
            foreach ((Outline outline, Color effectColor) in outlines)
            {
                // Mysteriously, effectColor is assigned to Vector4.zero here.
                // Setting effectColor to Color.cyan above also causes us to set it to cyan here.
                outline.effectColor = effectColor;
            }

But this does not work. Even though I created a copy of the effectColor to put in my tuple, manipulating outline.effectColor changes the value in the tuple. I checked this by assigning outline.effectColor to cyan instead of transparent, to make sure we weren't losing the reference entirely.

The below code works, though, and I don't understand why. Shouldn't they be doing the same thing? Is there something fundamentally different about creating an object in the body of an anonymous function vs a for loop?

            // ...
            List<(Outline, Color)> outlines = new List<(Outline, Color)>();
            foreach (Outline outline in GetComponentsInChildren<Outline>())
            {
                float r = outline.effectColor.r;
                float g = outline.effectColor.g;
                float b = outline.effectColor.b;
                float a = outline.effectColor.a;                
                outlines.Add((outline, new Color(r, g, b, a)));
            }
            foreach ((Outline outline, Color _) in outlines) {
                outline.effectColor = Vector4.zero;
            }
            yield return new WaitForSeconds(LOAD_TIME);
            // ...
            foreach ((Outline outline, Color effectColor) in outlines)
            {
                // effectColor is correctl assigned to its original color in this
                // implementation
                outline.effectColor = effectColor;
            }

So far I've read some documentation to try and figure out whether something magical is going on under the hood, but I haven't been able to.
https://docs.unity3d.com/ScriptReference/Color.html
https://learn.microsoft.com/en-us/dotnet/api/system.linq.enumerable.select?view=net-7.0

I read the Linq Select documentation more closely and figured it out!

> [Select] is implemented by using deferred execution. The immediate
> return value is an object that stores all the information that is
> required to perform the action. The query represented by this method
> is not executed until the object is enumerated either by calling its
> GetEnumerator method directly or by using foreach in Visual C# or For
> Each in Visual Basic.

"Why is Linq Select making my new object a reference to the object I copied its constructor arguments from?" Because that's what it does, lol. I guess it stores the outline as well as a function : Outine -> (Outline, Color) and applies the function once it needs to use the tuple?

I appended .ToList() to my [outlines] declaration to cause the values to "lock in", which resulted in the behavior I expected.

The reason why the first version of your code is not behaving as you expect is because of deferred execution in LINQ.

When you use a LINQ method like Select, it doesn't immediately execute the code inside the delegate function. Instead, it returns an IEnumerable that will execute the code when it's enumerated. In your case, this means the color objects are not actually created until you enumerate outlines in your foreach loop.

Because of this, the color objects are created after you've already set outline.effectColor to Vector4.zero, so you end up with a list of tuples where the color is always Vector4.zero.

The second version of your code works because you're manually creating the color objects and adding them to a list. This happens immediately when you execute the code, not when you enumerate the list, so you end up with the original colors as expected.

Here is a modified version of your first code snippet that should work:

var outlines = GetComponentsInChildren<Outline>()
    .Select(outline => (outline, new Color(outline.effectColor.r, outline.effectColor.g, outline.effectColor.b, outline.effectColor.b, outline.effectColor.a)))
    .ToList(); // ToList forces immediate execution

foreach ((Outline outline, Color _) in outlines) 
{
    outline.effectColor = Vector4.zero;
}

yield return new WaitForSeconds(LOAD_TIME);

foreach ((Outline outline, Color effectColor) in outlines)
{
    outline.effectColor = effectColor;
}

In this version, I've added a call to ToList after the Select method. This forces immediate execution of the delegate function, so the color objects are created with the original color values.