Yes. The [] operator on a list is, in fact, a function, so the value
stored at that location in the list is returned as a function result,
on the stack.

This doesn't cause problems for reference types, because usually you
want to change some property of the reference type, so the fact that
you get a copy of the reference in the list (not the actual reference
that is in the list) doesn't cause problems.

However, for value types exactly the same thing happens, and it does
cause problems: the value is copied from the list onto the stack and
returned as a function result. Modifying the returned value, of
course, has no effect on the contents of the list. The compiler wisely
catches this.

You need to do this:

MyStruct y = list[0];
y.MyProperty = 45;
list[0] = y;

If you declare your structure to implement an interface and then
declare the list as containing the interface instead of the structure,
then you can work with the structure (through the interface
implemented members) directly (interfaces allow you to pierce the
box).

Code sample below.

HTH,

Sam

------------------------------------------------------------
We're hiring!  B-Line Medical is seeking .NET
Developers for exciting positions in medical product
development in MD/DC.  Work with a variety of technologies
in a relaxed team environment.  See ads on Dice.com.

 public static void Test()
 {
   MyClass[] classArray = new MyClass[1];
   MyStruct[] structArray = new MyStruct[1];
   MyInterface[] interfaceArray = new MyInterface[1];
   List<MyClass> classList = new List<MyClass>(1);
   List<MyStruct> structList = new List<MyStruct>(1);
   List<MyInterface> interfaceList = new List<MyInterface>(1);

   classArray[0] = new MyClass();        
   classList.Add(new MyClass());
   interfaceArray[0] = new MyStruct();
   structList.Add(new MyStruct());
   interfaceList.Add(new MyStruct());

   classArray[0].X++;
   interfaceArray[0].X++;
   structArray[0].X++;
   classList[0].X++;

   // Cannot modify the return value of 'List<MyStruct>.this[int]'
   // because it is not a variable
   //structList[0].X++;
   interfaceList[0].X++;

   Console.WriteLine("Class Array     : " + classArray[0].X);
   Console.WriteLine("Struct Array    : " + structArray[0].X);
   Console.WriteLine("Interface Array : " + interfaceArray[0].X);
   Console.WriteLine("Class List      : " + classList[0].X);
   Console.WriteLine("Struct List     : " + structList[0].X);
   Console.WriteLine("Interface List  : " + interfaceList[0].X);
 }
}

public class MyClass : MyInterface
{
 private int x;

 public int X
 {
   get
   {
     return x;
   }
   set
   {
     x = value;
   }
 }
}

public struct MyStruct : MyInterface
{
 private int x;

 public int X
 {
   get
   {
     return x;
   }
   set
   {
     x = value;
   }
 }
}

public interface MyInterface
{
 int X { get; set; }
}