C# 如何通过不使用内置排序c的属性对类对象数组进行排序#

目前，我已经构建了一个包含1200个“Element”类实例的数组。每个数组都是通过其构造函数自动填充的（从9个不同的数组中逐行删除数据（数组来自9个不同的文本文件））

公共类元素
{
公共国际元素日；
公共字符串元素月；
公共国际年；
公共字符串元素时间；
公共整数元素时间戳；
公共字符串元素区域；
公共浮动元素经度；
公共浮动元素纬度；
公共浮动要素；
公共浮动元素深度；
公共浮动元素IRIS_Id；
公共元素（整数[]天，字符串[]月，整数[]年，字符串[]时间，整数[]时间戳，字符串[]区域，浮点[]经度，浮点[]纬度，浮点[]幅度，浮点[]深度，浮点[]虹膜Id，参考整数计数器）
{
elementDay=日[计数器]；
elementMonth=月份[计数器]；
elementYear=年份[计数器]；
elementTime=时间[计数器]；
elementTimestamp=时间戳[计数器]；
elementRegion=区域[计数器]；
Element经度=经度[计数器]；
元素纬度=纬度[计数器]；
元素幅值=幅值[计数器]；
elementDepth=深度[计数器]；
elementIris_Id=iris_Id[计数器]；
计数器++；
}
公共静态void CreateElementList（元素[]数组元素，整数[]天，字符串[]月，整数[]年，字符串[]时间，整数[]时间戳，字符串[]区域，浮点[]经度，浮点[]纬度，浮点[]幅度，浮点[]深度，浮点[]虹膜Id，参考整数计数器）
{
对于（int i=0；i<1200；i++）
{
arrayElements[i]=新元素（日、月、年、时间、时间戳、区域、经度、纬度、震级、深度、iris_Id、参考计数器）；
}
}

现在我需要找到一种按某些属性对这些对象进行排序的方法。 我想要的一个工作示例是：

Array.Sort（arrayElements，delegate（Element x，Element y）{return y.elementDay.CompareTo（x.elementDay）；}）；

但是我不能使用它，因为它是一个内置函数。我正在尝试实现一个快速排序算法，按“天”对这些对象进行排序，但我不知道是否可以对元素数组进行排序，因为我只知道如何对简单的整数数组进行排序。最终目标是能够按任何属性和要根据所选属性进行排序的整个元素数组

---

请记住这是家庭作业，所以请不要给我完整的解决方案，我主要想知道这是否可能/值得我花时间，或者我应该尝试另一种方法吗？

关于通常如何实现排序的框架：

public static void MySort<T>(IList<T> list, Comparison<T> comparison = null)
{
    if (comparison == null)
    {
        comparison = Comparer<T>.Default.Compare;
    }

    // ** Your sort algorithm goes here **

    // To compare two elements do it like:

    // Compare first and last element
    int cmp = comparison(list[0], list[list.Count - 1]);
    if (cmp < 0)
    {
        Console.WriteLine("first < last");
    }
    else if (cmp == 0)
    {
        Console.WriteLine("first == last");
    }
    else
    {
        Console.WriteLine("first > last");
    }
}

现在…如果您想按不同的字段排序，并将它们链接起来（例如，

elementYear

，然后是

elementMonth

，然后是

elementDay

），该怎么办

“链接”比较创建者是解决方案之一：-）

公共类多重比较
{
私有多重比较（）
{
}
//从比较数组创建单OLE比较，
//此比较是所有比较的“链接”
公共静态比较创建（参数比较[]比较）
{
if（比较==null | |比较.长度==0）
{
抛出新的ArgumentException（“比较”）；
}
//单比较==它已经是我们可以返回的比较
如果（比较。长度==1）
{
返回比较[0]；
}
//我们克隆了数组，以便Create的调用者不能修改它
//在幕后。
比较=（比较[]）比较。克隆（）；
//我们返回一个将使用所有比较的方法，
//在给出结果的第一次比较时停止！=0
比较=（x，y）=>
{
for（int i=0；i

像这样使用它：

MySort(
    elements, 
    MultiComparison.Create<Element>(
        (x, y) => x.elementYear.CompareTo(y.elementYear),
        (x, y) => x.elementMonth.CompareTo(y.elementMonth),
        (x, y) => x.elementDay.CompareTo(y.elementDay)
));

MySort(
元素，
多重比较。创建(
（x，y）=>x.elementYear.与（y.elementYear）相比，
（x，y）=>x.elementMonth.与（y.elementMonth）相比，
（x，y）=>x.elementDay.与（y.elementDay）相比
));

你真正想问的是什么？可能吗？当然可能。值得你花时间吗？我想这取决于它是否给你的课程打分。如果你想尝试写它，这里的人会帮助你，但否则这是非常模糊和太宽泛的。请阅读本文

var elements = new[]
{
    new Element { elementDay = 15, elementMonth = 3, elementYear = 2017 },
    new Element { elementDay = 14, elementMonth = 3, elementYear = 2017 },
    new Element { elementDay = 13, elementMonth = 3, elementYear = 2016 },
};

MySort(elements, (x, y) => x.elementDay.CompareTo(y.elementDay));

public class MultiComparison
{
    private MultiComparison()
    {
    }

    // Create a singole comparison from an array of comparisons,
    // this comparison is the "chaining" of all the comparisons
    public static Comparison<T> Create<T>(params Comparison<T>[] comparisons)
    {
        if (comparisons == null || comparisons.Length == 0)
        {
            throw new ArgumentException("comparisons");
        }

        // Single comparison == it is already the comparison we can return
        if (comparisons.Length == 1)
        {
            return comparisons[0];
        }

        // We clone the array so that the caller of Create can't modify it 
        // behind the scene.
        comparisons = (Comparison<T>[])comparisons.Clone();

        // We return a method that will use all the comparisons,
        // stopping at the first comparison that gives a result != 0
        Comparison<T> comparison = (x, y) =>
        {
            for (int i = 0; i < comparisons.Length; i++)
            {
                int cmp = comparisons[i](x, y);

                if (cmp != 0)
                {
                    return cmp;
                }
            }

            return 0;
        };

        return comparison;
    }
}

MySort(
    elements, 
    MultiComparison.Create<Element>(
        (x, y) => x.elementYear.CompareTo(y.elementYear),
        (x, y) => x.elementMonth.CompareTo(y.elementMonth),
        (x, y) => x.elementDay.CompareTo(y.elementDay)
));