索引数组多于一个元素

Question

在C＃中，我目前正在使用SortedSet来对包含三个字段的结构进行索引：

public struct ChannelId : IComparable<ChannelId>
{
    public int ChanNumber;
    public Tower ChanTower;
    public double AvailableProbability;

    public int CompareTo(ChannelId other)
    { return other.AvailableProbability.CompareTo(AvailableProbability); }
}

（是的， CompareTo函数是正确编写的。我想要颠倒的顺序。）因此，我想要某种可以在此处通过两个字段索引的集合/结构（也包括ChanNumber ）。 有没有办法做到这一点？

Answer 1

您可以使用自定义比较器创建两个集合：

class ChanNumberComparer : IComparer<ChannelId>
{
    public int Compare(ChannelId x, ChannelId y)
    {
        return y.ChanNumber.CompareTo(x.ChanNumber);
    }
}

在SortedSet构造函数中使用它

Answer 2

我假设您需要能够基于ChanNumber和ChanTower查找ChannelId。

但是，我认为该类名是错误的。

我将创建两个类：

ChannelID类：

• int ChanNumber
• 塔塔

班级频道：

• ChannelID ChanID
• 可用概率翻倍

然后，字典可以很好地满足您的需求：

Dictionary<ChannelID, Channel>

您将需要为ChannelID实现GetHashCode和Equals方法。 然后，您只需创建一个新的ChannelID对象作为查找，即可在字典中获取Channel对象，在字典中您可以获取AvailableProbability值。

完整代码如下：

using System;
using System.Collections.Generic;
using System.Linq;

namespace Test
{
    class ChannelTest
    {
        public static void Test()
        {
            var dict = new Dictionary<ChannelID, Channel>();

            var a = new Channel(new ChannelID(0, Tower.A), 0.5);
            var b = new Channel(new ChannelID(7, Tower.B), 0.35);

            dict.Add(a.ChanID, a);
            dict.Add(b.ChanID, b);

            // To get a channel from the ID
            // Just create a new ID object with the same values
            var aRef = dict[new ChannelID(0, Tower.A)];
            var bRef = dict[new ChannelID(7, Tower.B)];

            // If you want the sorted channels - use linq
            // This will give you the best 10
            var sorted = dict.Values.OrderByDescending(c => c.AvailableProbability).Take(10).ToList();

        }
    }

    class ChannelID
    {
        public int ChanNumber { get; private set; }
        public Tower ChanTower { get; private set; }

        public ChannelID(int chanNumber, Tower chanTower)
        {
            ChanNumber = chanNumber;
            ChanTower = chanTower;
        }

        public override bool Equals(object obj)
        {
            if (!(obj is ChannelID))
            {
                return false;
            }

            var o = (ChannelID)obj;

            return this.ChanNumber == o.ChanNumber
                && this.ChanTower == o.ChanTower;
        }

        public override int GetHashCode()
        {
            // Using random prime multipliers to get a good hash code distribution
            // http://stackoverflow.com/questions/263400/what-is-the-best-algorithm-for-an-overridden-system-object-gethashcode
            return 17
                + 23 * this.ChanNumber.GetHashCode()
                + 23 * this.ChanTower.GetHashCode();
        }
    }

    class Channel : IComparable<Channel>
    {
        public ChannelID ChanID { get; private set; }
        public double AvailableProbability { get; private set; }

        public Channel(ChannelID chanID, double availableProbability)
        {
            ChanID = chanID;
            AvailableProbability = availableProbability;
        }

        public int CompareTo(Channel other)
        { return other.AvailableProbability.CompareTo(AvailableProbability); }
    }

    enum Tower
    {
        A,
        B,
        C
    }
}