尝试从.NET字典中提取键列表

Question

今天我猜想我的大脑不太好用，我需要提取一个键的列表：

Dictionary<string, MyClass>  myDict;
List<String> myKeys = myDict.Keys;

第二行无法编译，因为Keys属性返回的是"KeyCollection"类而不是键对象的列表<>。

- winwaed

---

如何获取字典中的键列表 - CAD bloke

可能是重复的问题：如何获取字典中的键列表？ - dsolimano

Answer 1

使用LINQ，您可以执行以下操作...

List<String> myKeys = myDict.Keys.ToList();

然而，根据您使用键的目的（例如选择性枚举等），使用键集合并不转换为列表可能更有意义。

- Quintin Robinson

---

谢谢 - 这很棒：我需要掌握Linq的技巧！ - winwaed

啊，我缺少的只是 using System.Linq;。我从来没有习惯这些突然出现的扩展方法... - Göran Roseen

Answer 2

KeyCollection实现了IEnumerable接口。

你可以使用扩展方法将其转换为列表。

List<String> myKeys = myDict.Keys.ToList();

或者使用不同的构造函数：

List<String> myKeys = new List<String>(myDict.Keys);

- Jaroslav Jandek

Answer 3

是的，你可以尝试使用 - IEnumerable<String> myKeys = myDict.Keys;

使用更通用的类型IEnumerable总是一个好主意。

- Kumar

Answer 4

如果您需要一个真实的列表：

List<string> myKeys = new List<string>(myDict.Keys);

- dsolimano

Answer 5

我已经创建了一个简化版的字典：

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

namespace CS_Library
{
    public sealed class Dict : IEquatable<Dict>, IDict
    {
        private ArrayList keys, values;

        private int LocalCount; public int Count { get => LocalCount; }

        public Dict()
        {
            keys = new ArrayList();
            values = new ArrayList();
        }

        public Dict(ArrayList keys, ArrayList values)
        {
            this.keys = keys;
            this.values = values;
        }

        ~Dict() { }

        public object this[object key] { get => values[keys.IndexOf(key)]; }
        public int Add(object key, object value) // The more strange is the Visual Studio don't color the 'value'
        {

            if (keys.IndexOf(key) > -1 || values.IndexOf(value) > -1)
            {
                return -1;
            }
            LocalCount = keys.Add(key);
            return values.Add(value);
        }
        public void Override(object newKey, object newValue, object key)
        {
            if (keys.IndexOf(newKey) > -1 || values.IndexOf(newValue) > -1)
            {
                return;
            }
            keys[keys.IndexOf(key)] = newKey;
            values[keys.IndexOf(key)] = newValue;
        }

        public void Delete(object key)
        {
            if (keys.IndexOf(key) == -1)
            {
                return;
            }
            values.RemoveAt(keys.IndexOf(key));
            keys.Remove(key);
        }

        public void DeleteAt(int index)
        {
            if (index < 0 || index > keys.Count)
            {
                return;
            }
            keys.RemoveAt(index);
            values.RemoveAt(index);
        }

        public void Erase()
        {
            values = null;
            keys = null;
        }

        public void Rebuild(ArrayList newKeys, ArrayList newValues)
        {
            if (keys != null && values != null)
            {
                throw new InvalidOperationException("Expected 'Erase()' method before this one. Or the 'Queue_Rebuild()' method instead this one.");
            }
            keys = newKeys;
            values = newValues;
        }

        public void Queue_Rebuild(ArrayList newKeys, ArrayList newValues)
        {
            Erase();
            Rebuild(newKeys, newValues);
        }

        public override bool Equals(object obj)
        {
            return Equals(obj as Dict);
        }

        public bool Equals(Dict other)
        {
            return other != null &&
                   EqualityComparer<ArrayList>.Default.Equals(keys, other.keys) &&
                   EqualityComparer<ArrayList>.Default.Equals(values, other.values) &&
                   LocalCount == other.LocalCount;
        }

        public override int GetHashCode()
        {
            return HashCode.Combine(keys, values, LocalCount);
        }

        public override string ToString()
        {
            string r = "{ ";
            bool first = true;
            for (int i = 0; i < LocalCount; i++)
            {
                if (!first)
                {
                    r += ", ";
                }
                else
                {
                    first = false;
                }
                r += $"{keys[i]}:{values[i]}";
            }
            return r + " }";
        }

        public static bool operator ==(Dict left, Dict right)
        {
            return EqualityComparer<Dict>.Default.Equals(left, right);
        }

        public static bool operator !=(Dict left, Dict right)
        {
            return !(left == right);
        }

        public static Dict operator +(Dict left, Dict right)
        {
            Dict r = left;
            for (int i = 0; i < right.Count; i++)
            {
                r.Add(right.keys[i], right.values[i]);
            }
            return r;
        }

    }
}

这还没完成，所以你可以做任何更改。

- DerickXIGamer