C#

value => Method1(value, someString, someDouble)

(val1, val2) => Method(val1, val2)

private void TestCodeInDictinary()
{
    this.IntKeyValueCode.Add(1, delegate(int value)
    {
        this.Method1(value, this.someString, this.someDouble);
    });
}

private Dictionary<int, Action<int, int>> IntKeyValueCode = new Dictionary<int, Action<int, int>>();

private void TestCodeInDictinary()
{
    IntKeyValueCode.Add(1, (value1, value2) => Method1(thisCodeDoesnt, giveAShit, whatsPassedIn));  
    IntKeyValueCode[1](100, 200);
}

for ( y = miny ; y <= maxy ; y++ )
  for ( x = minx ; x <= maxx ; x++ )
    if ( data.ContainsKey ( hash ( x , y ) ) ...

// required
using System.Collections.Generic;
using System.Linq;

namespace YetAnother
{
    public class PointyPoint
    {
        public int X { set; get; }
        public int Y { set; get; }
        public double Value { set; get; }

        public PointyPoint() {}

        public PointyPoint(int x, int y, double value)
        {
            X = x;
            Y = y;
            Value = value;
        }
    }

    public enum PointySortType
    {
        PSortAscendingX,
        PSortAscendingY,
        PSortDescendingX,
        PSortDescendingY,
        PSortAscendingValue,
        PSortDescendingValue
    }

    public class PointyListClass : List<PointyPoint>
    {
        public PointyListClass() {}

        public List<PointyPoint> PointySortedBy(PointySortType pSType, PointyListClass pointyList)
        {
            // throw error ?
            if (pointyList == null || pointyList.Count == 1) return null;

            switch (pSType)
            {
                case PointySortType.PSortAscendingX:
                {
                    return pointyList.OrderBy(pointy => pointy.X).ToList();
                }
                case PointySortType.PSortAscendingY:
                {
                    return pointyList.OrderBy(pointy => pointy.Y).ToList();
                }
                case PointySortType.PSortDescendingX:
                {
                    return pointyList.OrderByDescending(pointy => pointy.X).ToList();
                }
                case PointySortType.PSortDescendingY:
                {
                    return pointyList.OrderByDescending(pointy => pointy.Y).ToList();
                }
                case PointySortType.PSortAscendingValue:
                {
                    return pointyList.OrderBy(pointy => pointy.Value).ToList();
                }
                case PointySortType.PSortDescendingValue:
                {
                    return pointyList.OrderByDescending(pointy => pointy.Value).ToList();
                }
            }

            // throw error ?
            return null;
        }
    }
}

// test it in some appropriate context

private void SomeButton_Click(object sender, EventArgs e)
{
    PointyListClass pointyList = new PointyListClass
    {
        {new PointyPoint(100,400,199.99)},
        {new PointyPoint(200,300,12.43)},
        {new PointyPoint(300,200,-12333)},
        {new PointyPoint(400,100,345.93)},
    };

    var pointyXAscending = pointyList.PointySortedBy(PointySortType.PSortAscendingX, pointyList).ToList();
    var pointyYAscending = pointyList.PointySortedBy(PointySortType.PSortAscendingY, pointyList).ToList();

    var pointyXDescending = pointyList.PointySortedBy(PointySortType.PSortDescendingX, pointyList).ToList();
    var pointyDescending = pointyList.PointySortedBy(PointySortType.PSortDescendingY, pointyList).ToList();

    var pointyValueAscending = pointyList.PointySortedBy(PointySortType.PSortAscendingValue, pointyList).ToList();
    var pointyValueDescending = pointyList.PointySortedBy(PointySortType.PSortDescendingValue, pointyList).ToList();
}

BillWoodruff wrote:

The result of a Linq statement is not a "concrete instance" of a generic List,
rather it is an internal form of what you might call the "makings of a generic
List:" only when you access the Linq result by, for example, using 'foreach on
its contents, or using .ToList, etc., is an actual final form "rendered."

BillWoodruff wrote:

So, let me get this straight: you object to having a method in a Class that
returns the result of one of several possible sort-orders depending on the value
of an Enum ?

BillWoodruff wrote:

It's a good thing I'm not your manager, because you are the kind of sledge
hammer I would set to work breaking concrete, rather than writing code

List<int> lst = new List<int>();

lst.Add(1);
lst.Add(2);
lst.Add(3);

System.Diagnostics.Debug.WriteLine(lst[1]);

var v1 = lst.OrderBy(x => x);

var v2 = lst.ToList();

lst[1] = 7;

foreach (int i in lst)
    System.Diagnostics.Debug.WriteLine("L: " + i);

foreach (int i in v1)
    System.Diagnostics.Debug.WriteLine("V1: " + i);

foreach (int i in v2)
    System.Diagnostics.Debug.WriteLine("V2: " + i);