Question

我有以下示例C＃代码：

struct Card : Equatable {

    // nested Suit enumeration
    enum Suit: Character {
        case spades = "♠", hearts = "♡", diamonds = "♢", clubs = "♣"
    }

    // nested Rank enumeration
    enum Rank: Int {
        case two = 2, three, four, five, six, seven, eight, nine, ten
        case jack, queen, king, ace
        struct Values {
            let first: Int, second: Int?
        }
        var values: Values {
            switch self {
            case .ace:
                return Values(first: 11, second: nil)
            case .jack, .queen, .king:
                return Values(first: 10, second: nil)
            default:
                return Values(first: self.rawValue, second: nil)
            }
        }
    }

    // Card properties and methods
    let rank: Rank, suit: Suit
    var description: String {
        var output = "suit is \(suit.rawValue),"
        output += " value is \(rank.values.first)"
        if let second = rank.values.second {
            output += " or \(second)"
        }
        return output
    }
}


extension Card {
    public static func == (lhs: Card, rhs: Card) -> Bool {
        return ((lhs.rank == rhs.rank) && (lhs.suit == rhs.suit))
    }
}

// Try to compare two cards
let ace = Card(rank: .ace, suit: .clubs)
let king = Card(rank: .king, suit: .diamonds)

if (ace > king) {
    print ("Ace is higher value")
}
else {
    print ("Ace is NOT higher")
}

调用Main（）结束打印：

class Stuff { }  // empty class

void Main()
{
    var list = new List<Stuff> {
        new Stuff(),
        new Stuff()
    };
    Fun(list);
}

void Fun<T>(List<T> a)
{
    Debug.Log("called List<T> Fun");
    foreach (T t in a) {
        Fun(t);
    }
}

void Fun(Stuff a)
{
    Debug.Log("called Stuff Fun");
}

void Fun<T>(T a)
{
    Debug.Log("called T Fun");
}

我不明白为什么编译器能够按预期方式调用called List<T> Fun called T Fun called T Fun，但是不知道调用Fun<T>(List<T> a)，它比Fun(Stuff a)更具体。在这种情况下，是否不确定在编译时T是否为Fun<T>(T a)？在Stuff内打印typeof(T)会得到预期的“填充”，但这不能证明任何事情……

添加Fun<T>(List<T> a)方法是可行的，但却是不可取的（项目中List的类型可能很多，并且所有对象的行为都应该相同）。

我尝试搜索此问题，但是无法以我能找到的方式来表达它。抱歉，之前有人问过（可能！）。

Answer 1

关键是要了解void Fun<T>(List<T> a)是一次编译的，并且过载解析是一次执行的。不是每个T一次，而是一次。

在编译此代码时，请考虑编译器的情况：

void Fun<T>(List<T> a)
{
    Debug.Log("called List<T> fun");
    foreach (T t in a) {
        Fun(t);
    }
}

尤其是在对Fun(t)的调用中考虑重载解决方案。

编译器对T一无所知，Fun(t)是void Fun<T>(List<T> a) void Fun(Stuff a) void Fun<T>(T a)调用中参数的类型-它可以是任何非指针类型。它必须在这些签名之间执行重载解析：

仅个适用的方法之一是最后一个-调用代码中的T用作我们方法中T的类型参数正在打电话，这很好。其他两种方法不适用，因为没有从List<TList>到TList的转换（对于任何T），也没有从Stuff到foreach (dynamic d in a) { Fun(d); }的转换。 / p>

如果您希望在执行时执行重载解析，则可以使用动态类型：

我个人不喜欢这样做，但是在这种情况下，它可能可以满足您的要求。另一方面，使用嵌套列表可能会比较棘手-如果List<int>是Fun<List<int>>(list)，那么您希望它调用Fun<int>(list)还是src="https://www.youtube.com/embed/HWl8XAOQnTg?rel=0&controls=0&showinfo=0;autoplay=1&mute=1"吗？老实说，我不记得要掌握哪些规则“比较好”或它是否模棱两可的规则。

收到List <t>的C＃通用方法不会为T的实际类型调用重载方法（首选通用方法）

1 个答案: