Question

怀疑我的大脑今天不工作 - 我需要提取一系列密钥等等：

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

第二行无法编译，因为Keys属性返回“KeyCollection”类而不是列表＆lt;＆gt;关键对象。

Answer 1

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

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

但是，根据您的目标是什么（选择性枚举等），使用密钥集合而不是转换为列表可能更有意义。

Answer 2

KeyCollection实现IEnumerable接口。

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

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

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

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

Answer 3

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

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

Answer 4

如果您需要一个真实的清单：

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

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;
        }

    }
}

尚未完成，因此您可以进行任何更改。

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

5 个答案: