Converting 'list of Foo' into 'lists of Foo properties' I'm looking at some code that goes a bit like this:

class Foo { public int Frob; public int Frib; }
class Bar { public Foo Left; public Foo Right; }

public void ProcessBars(Bar[] bars)
{
    this.LeftFrobs = new int[bars.Count];
    this.RightFrobs = new int[bars.Count];
    this.LeftFribs = new int[bars.Count];
    this.RightFribs = new int[bars.Count];
    //... you get the idea

    int counter = 0;
    foreach(Bar bar in bars)
    {
        LeftFrobs[counter] = bar.Left.Frob;
        LeftFribs[counter] = bar.Left.Frib;
        //...27 more lines of similar
        if(bar.Left.Frob == MAGICNUM_A) LeftFribs[counter] = MAGICNUM_B;

        RightFrobs[counter] = bar.Right.Frob;
        RightFribs[counter] = bar.Right.Frib;
        //...27 more lines of similar
        if(bar.Right.Frob == MAGICNUM_C) LeftFribs[counter] = MAGICNUM_D;

        counter++;
    }
}


Aesthetically, this bothers me, but so far, I haven't managed to come up with anything better.
That method is immense, and is surely impossible to easily read and maintain. Once you break it into smaller methods you will be able to work with it ("just like those acorns, one at a time").
This will also help avoid repetitions of code.

I propose creating a class to hold all that data, and merely instantiate a Left and a Right objects of that class. Then move the loading of data into the class as well.

Then the foreach is limited to 3 lines plus all the ifs:

public class WildGooseChaser
{
    class Foo { public int Frob; public int Frib; }
    class Bar { public Foo Left; public Foo Right; }

    private InternalData Left;
    private InternalData Right;

    class InternalData
    {
        public int[] Frobs;
        public int[] Fribs;
        // ... 27 more lines of similar.

        public InternalData(int dataLength) {
            Frobs = new int[dataLength];
            Fribs = new int[dataLength];
            //... you get the idea
        }

        public void LoadBar(int index, Bar bar) {
            Frobs[index] = bar.Left.Frob;
            Fribs[index] = bar.Left.Frib;
            //...27 more lines of similar
        }
    }

    public void ProcessBars(Bar[] bars) {
        Left = new InternalData(bars.Length);
        Right = new InternalData(bars.Length);

        int counter = 0;
        foreach (Bar bar in bars) {
            Left.LoadBar(counter, bar);
            Right.LoadBar(counter, bar);

            if (bar.Left.Frob == MAGICNUM_A) {
                Left.Fribs[counter] = MAGICNUM_B;
            }

            if (bar.Right.Frob == MAGICNUM_C) {
                Left.Fribs[counter] = MAGICNUM_D;
            }

            counter++;
        }
    }
}


If you receive an array, you can use for instead of foreach.
So you can either get rid of the counter variable, or receive an IEnumerable&lt;Bar&gt; instead.