C#

George_George wrote:

...delete during foreach is not hard to implement and should not be expensive

private List<SomeType> myList = new List<SomeType>

// ...

// this is what supports foreach - it gets compiled into
// an IEnumerator class with MoveNext and Current methods
// (and i as a private field) by the compiler:
public System.Collections.Generic.IEnumerator<SomeType> GetEnumerator()
{
    for (int i = 0; i < myList.Length; i++)
    {
        yield return myList[i];
    }
}

// explicit implementation of non-generic version:
public System.Collections.Generic.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
    return this.GetEnumerator();
}

George_George wrote:

for example, why do we need to "copy a reference for each element into a temporary array when it is created"? Could you clarify or give more description please?

// my private list:
private List<SomeType> myList = new List<SomeType>
 
// other code...
 
// super-robust enumerator:
public System.Collections.Generic.IEnumerator<SomeType> GetEnumerator()
{
    SomeType[] elems = myList.ToArray(); // EXPENSIVE!
 
    for (int i = 0; i < elems.Length; i++)
    {
        yield return elems[i];
    }
}
 
// explicit implementation of non-generic version:
public System.Collections.Generic.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
    return this.GetEnumerator();
}

Guffa wrote:

Yes, assigning a reference is an atomic operation.

Assume var2 starts == 1.

Thread 1:
  var1 = var2;

Thread2:
  var2 = 2;
  var1 = 3;

supercat9 wrote:

An assignment of a reference type consists of an atomic read followed by an atomic write.

Guffa wrote:

No, it doesn't. An assignment is only a write operation.

Guffa wrote:

The complete statement is of course not an atomic operation.

Thread[] threads = new Thread[2];
threads[0] = new Thread(new ThreadStart(UIMethod));
threads[1] = new Thread(new ThreadStart(BackGroundMethod));
threads[0].SetApartmentState(ApartmentState.STA);
threads[0].Start();
threads[1].Start();
threads[1].Join();  //This blocks the current thread until threads[1] finishes

Sub EnableKillMeTimer
  If InvokeRequired then
    BeginInvoke(New MethodInvoker(AddressOf EnableKillMeTimer))
  Else
    tmrKillMe.Enabled = True
  Endif
End Sub

Yoyosch wrote:

How to assign a value for the specific field of that variable?

private static void Main(string[] args)
{
    var a;
    a = new <>f__AnonymousType0<int, int>(1, 2);
    return;
}

[CompilerGenerated, DebuggerDisplay(@"\{ i = {i}, j = {j} }", Type="<Anonymous Type>")]
internal sealed class <>f__AnonymousType0<<i>j__TPar, <j>j__TPar>
{
    // Fields
    [DebuggerBrowsable(0)]
    private readonly <i>j__TPar <i>i__Field;
    [DebuggerBrowsable(0)]
    private readonly <j>j__TPar <j>i__Field;

    // Methods
    [DebuggerHidden]
    public <>f__AnonymousType0(<i>j__TPar i, <j>j__TPar j);
    [DebuggerHidden]
    public override bool Equals(object value);
    [DebuggerHidden]
    public override int GetHashCode();
    [DebuggerHidden]
    public override string ToString();

    // Properties
    public <i>j__TPar i { get; }
    public <j>j__TPar j { get; }
}