Question

试图用2个钥匙做一个词典,因为它似乎比制造2个具有同样价值的字典好。我想得到两个钥匙中一个的价值,即如果两个钥匙中有1个符合标准,它就会收回价值。我还认为,我可以增加2个具有不同关键因素的内容,但对于一个字典来说,同样价值。

我是这样说的,但我想知道,这样做是否更加有效。或者如果在不使用多基字典的情况下获得我所希望的东西还有另一种更好的途径

    public bool TryGetValue(out TValue value, TKey1 key1 = default, TKey2 key2 = default)
    {
        value = default;

        if (EqualityComparer<TKey1>.Default.Equals(key1, default) && EqualityComparer<TKey2>.Default.Equals(key2, default))
            return false;

        foreach (var pair in this)
        {
            if ((EqualityComparer<TKey1>.Default.Equals(key1, default) || pair.Key.Item1.Equals(key1))
                && (EqualityComparer<TKey2>.Default.Equals(key2, default) || pair.Key.Item2.Equals(key2)))
            {
                value = pair.Value;
                return true;
            }
        }

        return false;
    }

Answer 1

如果你只需要一个关键才能获得这一价值,则使用一个正常的

你们并不要求两个单独的独裁者持有能够用两个钥匙获得的价值。

一个具有重复价值的单一字典可以达到这一目的。

例如,您的关键词典价值记录可考虑:

1 “可使用”

2名“主席”

3 “可使用”

4 «Lamp”

你们可以获取“可变”和“3”这两个关键值。

值得注意的是,贵方的数值被储存为 https://learn.microsoft.com/en-us/dotnet/csharp/English-vis/builtin-types/ Value-types”rel=“nofollow noreferer”>,从而改变某一关键值,独立于改变其他关键值的价值,而

Answer 2

任务是将具有不同类型钥匙的物体列入字典,但标准字典由同类钥匙界定。

你们可能有不同的钥匙界定自己的物体,这些钥匙需要放在一个字典上,因此钥匙可以不同类型。

最简单的方式是,对关键目标进行接口,然后这些物体可以相同(通用接口类型)。

守则实例显示了两个具有共同接口的关键结构,以及该接口的字典工程(伊凯)。

值得记住的是,词典要求(至少)实施一个关键的“平等”和“发展”;接口,以及关键功能的实施——字典的业绩取决于这一点。

public interface IKey : System.IEquatable<IKey>
{
}
public struct Key1 : IKey
{
    public int Value;
    public Key1(int value)
    {
        Value = value;
    }
    public override int GetHashCode()
    {
        // !! return adequate hashcode
        return Value.GetHashCode();
    }
    public bool Equals(IKey other)
    {
        // !! return adequate equals
        return Value.Equals(((Key1)other).Value);
    }
    public override string ToString()
    {
        return Value.ToString();
    }
}
public struct Key2 : IKey
{
    public string Value;
    public Key2(string value)
    {
        Value = value;
    }
    public override int GetHashCode()
    {
        // !! return adequate hashcode
        return Value.GetHashCode();
    }
    public bool Equals(IKey other)
    {
        // !! return adequate equals
        return Value.Equals(((Key2)other).Value,
                            System.StringComparison.Ordinal);
    }
    public override string ToString()
    {
        return Value;
    }
}
public class DictionaryIKey<TValue> :
    System.Collections.Generic.Dictionary<IKey, TValue>
{
    public void Add(int key, TValue value)
    {
        Add(new Key1(key), value);
    }
    public void Add(string key, TValue value)
    {
        Add(new Key2(key), value);
    }

    public bool TryGetValue(int key, out TValue value)
    {
        return TryGetValue(new Key1(key), out value);
    }
    public bool TryGetValue(string key, out TValue value)
    {
        return TryGetValue(new Key2(key), out value);
    }
}

public static void Run()
{
    DictionaryIKey<string> dict = new DictionaryIKey<string>(3);

    string value = "123456, John, Duus";

    // add object to dictionary, and this object is accessible
    // by keys of different types

    dict.Add(123456, value);
    dict.Add("John", value);
    dict.Add("Duus", value);

    string _out;
    dict.TryGetValue(123456, out _out);
    System.Console.WriteLine(_out);
    dict.TryGetValue("John", out _out);
    System.Console.WriteLine(_out);
    dict.TryGetValue("Duus", out _out);
    System.Console.WriteLine(_out);

    dict.TryGetValue(111000, out _out);
    System.Console.WriteLine(_out);
    dict.TryGetValue("no??", out _out);
    System.Console.WriteLine(_out);

    // output:
    // 123456, John, Duus
    // 123456, John, Duus
    // 123456, John, Duus
    // <empty>
    // <empty>
}

友情链接