使用递归从 IDictionary 中删除项目

Question

有人有更巧妙的方法来做到这一点吗？ 看起来应该比这更容易，但我有心理障碍。 基本上我需要从字典中删除项目并递归到也是字典的项目的值。

private void RemoveNotPermittedItems(ActionDictionary menu)
{
    var keysToRemove = new List<string>();
    foreach (var item in menu)
    {
        if (!GetIsPermitted(item.Value.Call))
        {
            keysToRemove.Add(item.Key);
        }
        else if (item.Value is ActionDictionary)
        {
            RemoveNotPermittedItems((ActionDictionary)item.Value);
            if (((ActionDictionary)item.Value).Count == 0)
            {
                keysToRemove.Add(item.Key);
            }
        }
    }
    foreach (var key in (from item in menu where keysToRemove.Contains(item.Key) select item.Key).ToArray())
    {
        menu.Remove(key);
    }
}

动作字典是这样的：

public class ActionDictionary : Dictionary<string, IActionItem>, IActionItem

Answer 1

如果您反向迭代字典（从“menu.Count - 1”到零），您实际上不需要收集键并再次迭代它们。 当然，如果您开始删除某些内容，则按正向顺序迭代会产生变异的集合异常。

我不知道 ActionDictionary 是什么，所以我无法测试您的确切场景，但这里有一个仅使用 Dictionary 的示例。

    static int counter = 0;
    private static void RemoveNotPermittedItems(Dictionary<string, object> menu)
    {
        for (int c = menu.Count - 1; c >= 0; c--)
        {
            var key = menu.Keys.ElementAt(c);
            var value = menu[key];
            if (value is Dictionary<string, object>)
            {
                RemoveNotPermittedItems((Dictionary<string, object>)value);
                if (((Dictionary<string, object>)value).Count == 0)
                {
                    menu.Remove(key);
                }
            }
            else if (!GetIsPermitted(value))
            {
                menu.Remove(key);
            }
        }
    }

    // This just added to actually cause some elements to be removed...
    private static bool GetIsPermitted(object value)
    {
        if (counter++ % 2 == 0)
            return false;
        return true;
    }

我还颠倒了“if”语句，但这只是一个假设，即您希望在调用对项目的值进行操作的方法之前进行类型检查...假设“GetIsPermission”始终返回 TRUE，那么无论哪种方式都可以工作行动词典。

希望这可以帮助。

Answer 2

虽然 foreach 和 GetEnumerator 失败，但 for 循环可以工作，

var table = new Dictionary<string, int>() {{"first", 1}, {"second", 2}};
for (int i = 0; i < table.Keys.Count; i++)//string key in table.Keys)
{
    string key = table.Keys.ElementAt(i);
    if (key.StartsWith("f"))
    {
        table.Remove(key);
    }
}

但 ElementAt() 是 .NET 3.5 的一项功能。

Answer 3

首先，您的 foreach 循环比它需要的要复杂得多。 就这样做：

foreach (var key in keysToRemove)
{
    menu.Remove(key);
}

我有点惊讶 Dictionary 没有 RemoveAll 方法，但它看起来不像有......

Answer 4

选项 1：字典仍然是集合。 迭代 menu.Values。

您可以迭代 menu.Values 并在迭代时删除它们。 这些值不会按任何排序顺序出现（这应该适合您的情况）。 您可能需要使用 for 循环并调整索引，而不是使用 foreach - 如果您在迭代时修改集合，枚举器将引发异常。

（周一，我将在我的开发机器上尝试添加代码）

选项 2：创建自定义迭代器。

从 Winforms 中的 ListBox SelectedItems 返回的一些集合并不真正包含该集合，它们提供了底层集合的包装。 有点像 WPF 中的 CollectionViewSource。 ReadOnlyCollection 也做了类似的事情。

创建一个类，可以将嵌套字典“扁平化”为可以枚举它们的类，就像它们是单个集合一样。 实现一个删除函数，看起来像是从集合中删除一个项目，但实际上是从当前字典中删除。

Answer 5

在我的观点中，您可以定义自己的从 KeyValuePair<...> 派生的泛型类，TKey 和 TValue 都将是 List 并且您可以使用新的 RemoveRange() 或 RemoveAll( 中 List 的 RemoveAll 或 RemoveRange ) 方法在您的派生类中删除您想要的项目。

Answer 6

我知道您可能已经找到了很好的解决方案，但只是出于“圆滑”的原因，如果您可以将方法签名修改为（我知道它可能不适合您的场景）：

private ActionDictionary RemoveNotPermittedItems(ActionDictionary menu)
{
 return new ActionDictionary(from item in menu where GetIsPermitted(item.Value.Call) select item)
.ToDictionary(d=>d.Key, d=>d.Value is ActionDictionary?RemoveNotPermittedItems(d.Value as ActionDictionary) : d.Value));
}

而且我可以看到几种方法，您可以使用您的方法带有过滤项目的字典，无需修改并具体化新字典。

Answer 7

它并没有那么复杂，但是一些惯用的改变使它变得更短并且更容易看：

    private static void RemoveNotPermittedItems(IDictionary<string, IActionItem> menu)
    {
        var keysToRemove = new List<string>();

        foreach (var item in menu)
        {
            if (GetIsPermitted(item.Value.Call))
            {
                var value = item.Value as ActionDictionary;

                if (value != null)
                {
                    RemoveNotPermittedItems(value);
                    if (!value.Any())
                    {
                        keysToRemove.Add(item.Key);
                    }
                }
            }
            else
            {
                keysToRemove.Add(item.Key);
            }
        }

        foreach (var key in keysToRemove)
        {
            menu.Remove(key);
        }
    }

    private static bool GetIsPermitted(object call)
    {
        return ...;
    }

Answer 8

将 keysToRemove 的类型更改为 HashSet，您将获得 O(1) Contains 方法。 对于 List ，它的复杂度为 O(n)，正如您可能猜到的那样，速度较慢。

Answer 9

明天我在我的 VS 机器上之前尚未测试:o

private void RemoveNotPermittedItems(ActionDictionary menu)
{
    foreach(var _checked in (from m in menu
                             select new
                             {
                                 gip = !GetIsPermitted(m.Value.Call),
                                 recur = m.Value is ActionDictionary,
                                 item = m
                             }).ToArray())
    {
        ActionDictionary tmp = _checked.item.Value as ActionDictionary;
        if (_checked.recur)
        {
            RemoveNotPermittedItems(tmp);
        }
        if (_checked.gip || (tmp != null && tmp.Count == 0) {
            menu.Remove(_checked.item.Key);
        }
    }
}

Answer 10

我认为

public class ActionSet : HashSet<IActionItem>, IActionItem

并且

bool Clean(ActionSet nodes)
    {
        if (nodes != null)
        {
            var removed = nodes.Where(n => this.IsNullOrNotPermitted(n) || !this.IsNotSetOrNotEmpty(n) || !this.Clean(n as ActionSet));

            removed.ToList().ForEach(n => nodes.Remove(n));

            return nodes.Any();
        }

        return true;
    }

    bool IsNullOrNotPermitted(IActionItem node)
    {
        return node == null || *YourTest*(node.Call);
    }

    bool IsNotSetOrNotEmpty(IActionItem node)
    {
        var hset = node as ActionSet;
        return hset == null || hset.Any();
    }

应该工作得快