C# 动态字典（可以随机实时增删访问，保证先入先出的字典）

最新推荐文章于 2024-04-27 07:08:18 发布
最新推荐文章于 2024-04-27 07:08:18 发布
阅读量536 收藏 1
点赞数
文章标签： c# 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46273241/article/details/131808995
版权

在这里插入图片描述

如果你有以下需求：
1. 需要对Dictionary进行遍历的同时移除或者添加元素
2. 需要按顺序遍历Dictionary并且保证先入先出
3. 需要即时的获取字典内的元素数量，即时增删

如果你觉得好，请给我的框架点一个免费的star，球球啦
Yueh0607 - AirFramework

动态字典实现

/********************************************************************************************
 * Date : 2023.1.30
 * Description : 
 * 可顺序遍历且可以随机移除的队列
 * 
 * 遍历方法例程：
 * 
            _modules.ResetTraversalCount();
            int traversalCount = _modules.TraversalCount;    
            for (int i = 0; i < traversalCount; ++i)
            {
                if (_modules.TryDequeue(out IModule module, out Type key))
                {
                    module.OnUpdate();
                    _modules.TryEnqueue(key, module);
                }
            }
 * 
 * 
 ********************************************************************************************/


using System;
using System.Collections;
using System.Collections.Generic;
namespace AirFramework
{
    public class DynamicDictionary<T, K> : IEnumerable<KeyValuePair<T, K>> where T : notnull
    {

        //队列顺序
        private readonly Queue<T> queue;
        //实际存储键值对，即时
        private readonly Dictionary<T, K> dictionary;
        //临时移除状态
        private readonly Dictionary<T, int> state;

        /// <summary>
        /// 真正剩余元素数量
        /// </summary>
        public int Count => dictionary.Count;

        /// <summary>
        /// 遍历出队的次数
        /// </summary>
        public int TraversalCount { get; private set; } = 0;

        /// <summary>
        /// 刷新遍历数量，在每次遍历之前都要进行一次刷新以校准遍历数量
        /// </summary>
        public int ResetTraversalCount() => TraversalCount = queue.Count;

        public DynamicDictionary()
        {
            queue = new Queue<T>();
            dictionary = new Dictionary<T, K>();
            state = new Dictionary<T, int>();
        }

        /// <summary>
        /// 通过自定义比较器来提高字典比较效率的构造方式
        /// </summary>
        /// <param name="equalityComparer"></param>
        public DynamicDictionary(IEqualityComparer<T> equalityComparer)
        {
            queue = new Queue<T>();
            dictionary = new Dictionary<T, K>(equalityComparer);
            state = new Dictionary<T, int>(equalityComparer);
        }


        /// <summary>
        /// 入队
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void Enqueue(T key, K value)
        {
            if (TryEnqueue(key, value)) return;
            throw new InvalidOperationException("The operation on an empty container is invalid");
        }
        /// <summary>
        /// 尝试入队
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool TryEnqueue(T key, K value)
        {
            if (!dictionary.TryAdd(key, value))
            {
                return false;
            }
            queue.Enqueue(key);
            return true;
        }
        /// <summary>
        /// 从队中移除
        /// </summary>
        /// <param name="key"></param>
        public void Remove(T key)
        {
            if (!TryRemove(key))
            {
                throw new InvalidOperationException("The operation on an empty container is invalid");
            }
        }
        /// <summary>
        /// 尝试从队中移除
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool TryRemove(T key)
        {
            if (dictionary.ContainsKey(key))
            {
                dictionary.Remove(key);
                if (state.ContainsKey(key)) state[key]++;
                else state.Add(key, 1);
                return true;
            }
            return false;
        }

        /// <summary>
        /// 尝试获取队首
        /// </summary>
        /// <param name="result"></param>
        /// <returns></returns>
        public bool TryPeek(out K result)
        {
            do
            {
                if (queue.TryPeek(out var key))
                {
                    if (state.TryGetValue(key, out int count))
                    {
                        state[key] = --count;
                        if (TraversalCount > 0) TraversalCount--;
                        if (count == 0) state.Remove(key);
                        queue.Dequeue();
                    }
                    else return dictionary.TryGetValue(key, out result);
                }
                else
                {
                    result = default;
                    return false;
                }
            }
            while (true);
        }
        /// <summary>
        /// 获取队首
        /// </summary>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public K Peek()
        {
            if (TryPeek(out var result)) return result;
            throw new InvalidOperationException("The operation on an empty container is invalid");
        }
        /// <summary>
        /// 尝试出队
        /// </summary>
        /// <param name="result"></param>
        /// <returns></returns>
        public bool TryDequeue(out K result)
        {
            return TryDequeue(out result, out _);
        }
        /// <summary>
        /// 尝试出队
        /// </summary>
        /// <param name="result"></param>
        /// <param name="k"></param>
        /// <returns></returns>
        public bool TryDequeue(out K result, out T k)
        {
            if (queue.TryDequeue(out var key))
            {
                while (state.TryGetValue(key, out var count))
                {
                    state[key] = --count;
                    if (TraversalCount > 0) TraversalCount--;
                    if (count == 0) state.Remove(key);
                    if (!queue.TryDequeue(out key))
                    {
                        result = default;
                        k = default;
                        return false;
                    }
                }
                if (dictionary.TryGetValue(key, out result))
                {
                    k = key;
                    dictionary.Remove(key);
                    return true;
                }
            }

            result = default;
            k = default;
            return false;
        }

        /// <summary>
        /// 出队
        /// </summary>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public K Dequeue()
        {
            if (TryDequeue(out var result))
            {
                return result;
            }
            throw new InvalidOperationException("The operation on an empty container is invalid");
        }

        /// <summary>
        /// 访问以K为键的对象
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public K this[T key]
        {
            get => dictionary[key];
            set => dictionary[key] = value;
        }
        /// <summary>
        /// 是否存在以K为键的对象
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool ContainsKey(T key) => dictionary.ContainsKey(key);

        /// <summary>
        /// 清空
        /// </summary>
        public void Clear()
        {
            dictionary.Clear();
            queue.Clear();
            state.Clear();
        }


        /// <summary>
        /// 无序遍历  不可动态随机移除  迭代器
        /// </summary>
        /// <returns></returns>
        public IEnumerator<KeyValuePair<T, K>> GetEnumerator()
        {
            return dictionary.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return dictionary.GetEnumerator();
        }
    }
}

配套拓展方法

using System;
namespace AirFramework
{
    public static class DynamicDictionaryExtensions
    {
        /// <summary>
        /// 从动态字典获取一个值，如果值不存在则返回传入的默认值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="K"></typeparam>
        /// <param name="dictionary"></param>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static K GetValueOrDefault<T, K>(this DynamicDictionary<T, K> dictionary, T key, K value = default)
        {
            if (dictionary.ContainsKey(key))
            {
                return dictionary[key];
            }
            return value;

        }
        /// <summary>
        /// 从动态字典获取一个值，如果不存在则添加指定值后返回该值
        /// </summary>
        /// <typeparam name="T">键类型</typeparam>
        /// <typeparam name="K">值类型</typeparam>
        /// <param name="dictionary">动态字典</param>
        /// <param name="key">键</param>
        /// <param name="value">默认值</param>
        /// <returns>值</returns>
        public static K GetValueOrAddDefault<T, K>(this DynamicDictionary<T, K> dictionary, T key, K value = default)
        {
            if (dictionary.ContainsKey(key))
            {
                return dictionary[key];
            }
            dictionary.Enqueue(key, value);
            return dictionary[key];
        }
        /// <summary>
        /// 从动态字典获取一个值，如果不存在则添加指定值后返回该值
        /// </summary>
        /// <typeparam name="T">键类型</typeparam>
        /// <typeparam name="K">值类型</typeparam>
        /// <param name="dictionary">动态字典</param>
        /// <param name="key">键</param>
        /// <param name="value">默认值</param>
        /// <returns>值</returns>
        public static K GetValueOrAddDefault<T, K>(this DynamicDictionary<T, K> dictionary, T key, Func<K> getter = null)
        {
            if (dictionary.ContainsKey(key))
            {
                return dictionary[key];
            }

            dictionary.Enqueue(key, getter == null ? default : getter());
            return dictionary[key];
        }

        /// <summary>
        /// 尝试从动态字典获取一个值，如果该值存在则返回true并传出Value
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="K"></typeparam>
        /// <param name="dictionary"></param>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static bool TryGetValue<T, K>(this DynamicDictionary<T, K> dictionary, T key, out K value)
        {
            if (dictionary.ContainsKey(key))
            {
                value = dictionary[key];
                return true;
            }
            value = default;
            return false;
        }

        /// <summary>
        /// 尝试从动态字典获取一个值，如果该值存在则返回true并传出Value
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="K"></typeparam>
        /// <param name="dictionary"></param>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static bool GetValueOrDefault<T, K>(this DynamicDictionary<T, K> dictionary, T key, out K value)
        {
            if (dictionary.ContainsKey(key))
            {
                value = dictionary[key];
                return true;
            }
            value = default;
            return false;
        }


        /// <summary>
        /// 尝试从动态字典移除一个值并调用Dispose，如果该值存在则返回true
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="K"></typeparam>
        /// <param name="dictionary"></param>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static bool TryRemoveAndDispose<T, K>(this DynamicDictionary<T, K> dictionary, T key) where K : IDisposable
        {
            if (dictionary.TryGetValue(key, out var value))
            {
                value.Dispose();
                return true;
            }
            return false;
        }

        /// <summary>
        /// 从动态字典移除一个值并调用其Dispose方法，如果该值不存在将引发异常
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="K"></typeparam>
        /// <param name="dictionary"></param>
        /// <param name="key"></param>
        public static void RemoveAndDispose<T, K>(this DynamicDictionary<T, K> dictionary, T key) where K : IDisposable
        {
            dictionary.Remove(key);
            dictionary[key].Dispose();
        }

        /// <summary>
        /// 清空动态字典并调用所有元素的Dispose方法s
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="K"></typeparam>
        /// <param name="dictionary"></param>
        public static void ClearAndDispose<T, K>(this DynamicDictionary<T, K> dictionary) where K : IDisposable
        {
            while (dictionary.Count > 0)
            {
                dictionary.Dequeue().Dispose();
            }
        }
    }
}

动态HashSet的实现

/********************************************************************************************
 * Date : 2023.1.30
 * Description : 
 * 可顺序遍历且可以随机移除的队列
 * 
 * 遍历方法例程：
 * 
            _modules.ResetTraversalCount();
            int traversalCount = _modules.TraversalCount;    
            for (int i = 0; i < traversalCount; ++i)
            {
                if (_modules.TryDequeue(out IModule module))
                {
                    module.OnUpdate();
                    _modules.TryEnqueue( module);
                }
            }
 * 
 * 
 ********************************************************************************************/


using System;
using System.Collections;
using System.Collections.Generic;
namespace AirFramework
{
    public class DynamicHashSet<T> : IEnumerable<T> where T : notnull
    {

        //队列顺序
        private readonly Queue<T> queue;
        //实际存储键值对，即时
        private readonly HashSet<T> hashSet;
        //临时移除状态
        private readonly Dictionary<T, int> state;

        /// <summary>
        /// 真正剩余元素数量
        /// </summary>
        public int Count => hashSet.Count;

        /// <summary>
        /// 遍历出队的次数
        /// </summary>
        public int TraversalCount { get; private set; } = 0;

        /// <summary>
        /// 刷新遍历数量，在每次遍历之前都要进行一次刷新以校准遍历数量
        /// </summary>
        public int ResetTraversalCount() => TraversalCount = queue.Count;

        public DynamicHashSet()
        {
            queue = new Queue<T>();
            hashSet = new HashSet<T>();
            state = new Dictionary<T, int>();
        }

        /// <summary>
        /// 通过自定义比较器来提高比较效率的构造方式
        /// </summary>
        /// <param name="equalityComparer"></param>
        public DynamicHashSet(IEqualityComparer<T> equalityComparer)
        {
            queue = new Queue<T>();
            hashSet = new HashSet<T>(equalityComparer);
            state = new Dictionary<T, int>(equalityComparer);
        }


        /// <summary>
        /// 入队
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void Enqueue(T key)
        {
            if (TryEnqueue(key)) return;
            throw new ArgumentException("Same key exists");
        }
        /// <summary>
        /// 尝试入队
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool TryEnqueue(T key)
        {
            if (!hashSet.TryAdd(key)) return false;
            queue.Enqueue(key);
            return true;
        }
        /// <summary>
        /// 从队中移除
        /// </summary>
        /// <param name="key"></param>
        public void Remove(T key)
        {
            if (!TryRemove(key)) throw new ArgumentException("error remove key ");
        }
        /// <summary>
        /// 尝试从队中移除
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool TryRemove(T key)
        {
            if (hashSet.Contains(key))
            {
                hashSet.Remove(key);
                if (state.ContainsKey(key)) state[key]++;
                else state.Add(key, 1);
                return true;
            }
            return false;
        }

        /// <summary>
        /// 尝试获取队首
        /// </summary>
        /// <param name="result"></param>
        /// <returns></returns>
        public bool TryPeek(out T result)
        {
            do
            {
                if (queue.TryPeek(out var key))
                {
                    if (state.TryGetValue(key, out int count))
                    {
                        state[key] = --count;
                        if (TraversalCount > 0) TraversalCount--;
                        if (count == 0) state.Remove(key);
                        queue.Dequeue();
                    }
                    else return hashSet.TryGetValue(key, out result);
                }
                else
                {
                    result = default;
                    return false;
                }
            }
            while (true);
        }
        /// <summary>
        /// 获取队首
        /// </summary>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public T Peek()
        {
            if (TryPeek(out var result)) return result;
            throw new InvalidOperationException("The operation on an empty container is invalid");
        }

        /// <summary>
        /// 尝试出队
        /// </summary>
        /// <param name="result"></param>
        /// <param name="result"></param>
        /// <returns></returns>
        public bool TryDequeue(out T result)
        {
            if (queue.TryDequeue(out var key))
            {
                while (state.TryGetValue(key, out var count))
                {
                    state[key] = --count;
                    if (TraversalCount > 0) TraversalCount--;
                    if (count == 0) state.Remove(key);
                    if (!queue.TryDequeue(out key))
                    {
                        result = default;
                        return false;
                    }
                }
                if (hashSet.Contains(key))
                {
                    result = key;
                    hashSet.Remove(key);
                    return true;
                }
            }
            result = default;
            return false;
        }

        /// <summary>
        /// 出队
        /// </summary>
        /// <returns></returns>
        /// <exception cref="InvalidOperationException"></exception>
        public T Dequeue()
        {
            if (TryDequeue(out var result))
            {
                return result;
            }
            throw new InvalidOperationException("The operation on an empty container is invalid");
        }


        /// <summary>
        /// 是否存在Key对象
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public bool Contains(T key) => hashSet.Contains(key);

        /// <summary>
        /// 清空
        /// </summary>
        public void Clear()
        {
            hashSet.Clear();
            queue.Clear();
            state.Clear();
        }


        /// <summary>
        /// 无序遍历  不可动态随机移除  迭代器
        /// </summary>
        /// <returns></returns>
        public IEnumerator<T> GetEnumerator()
        {
            return hashSet.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return hashSet.GetEnumerator();
        }
    }
}

配套拓展方法

using System;
namespace AirFramework
{
    public static class DynamicHashSetExtensions
    {

        /// <summary>
        /// 尝试从动态HashSet移除一个值并调用Dispose，如果该值存在则返回true
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="K"></typeparam>
        /// <param name="hashSet"></param>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static bool TryRemoveAndDispose<T>(this DynamicHashSet<T> hashSet, T key) where T : IDisposable
        {
            if (hashSet.Contains(key))
            {
                key.Dispose();
                return true;
            }
            return false;
        }

        /// <summary>
        /// 从动态字典移除一个值并调用其Dispose方法，如果该值不存在将引发异常
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="K"></typeparam>
        /// <param name="hashSet"></param>
        /// <param name="key"></param>
        public static void RemoveAndDispose<T, K>(this DynamicHashSet<T> hashSet, T key) where T : IDisposable
        {
            hashSet.Remove(key);
            key.Dispose();
        }

        /// <summary>
        /// 清空动态字典并调用所有元素的Dispose方法s
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="hashSet"></param>
        public static void ClearAndDispose<T>(this DynamicHashSet<T> hashSet) where T : IDisposable
        {
            while (hashSet.Count > 0)
            {
                hashSet.Dequeue().Dispose();
            }
        }
    }
}
YUE ZHEN PENG
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
DynamicDictionary:动态字典中的AC＃单个文件删除允许不区分大小写的访问，并且在访问不存在的属性时返回null
05-05
动态词典 ＃＃＃它是什么？＃＃＃ 动态字典中的AC＃单个文件放置允许不区分大小写的访问，并且在访问不存在的属性时返回null。 ###这与ExpandoObject有何不同？### .NET Framework提供的是如何使用动态对象的参考示例，并且适用于大多数情况。 DynamicDictionary提供了一种用于创建和使用动力学的替代解决方案，它具有两个主要区别： 不区分大小写的属性或键访问 当访问不存在的属性或键时，返回null，而不是抛出异常，异常是大多数词典实现和.NET框架提供的ExpandoObject的默认行为。 ＃＃＃用法＃＃＃ // Non-existent properties will return null dynamic obj = new DynamicDictionary (); var firstName = obj . FirstName
C# 动态类转换（将对象转成字典）
学个毛的博客
05-07 2527
C# 动态类转换（将对象转成字典） /// <summary> /// 动态类转换 将对象转成字典 可以添加属性返回给前端，前端得到的字典对象与其他对象无异 /// </summary> public class DynamicClassTransformation { /// <summary> /// 数据 /// </summary> private readonly Dictionary<string, dynamic&g
C#学习常用类（3000）---ConcurrentDictionary<TKey,TValue>类.TryRemove方法
weixin_33769207的博客
12-08 982
ConcurrentDictionary<TKey,TValue>.TryRemove Method(TKey,TValue):Attempts to remove and return the value that has the specified key from the System.Collections.Concurrent.ConcurrentDic...
ConcurrentDictionary中的 TryRemove
weixin_34345753的博客
04-27 1008
  class A { internal int value; }     ConcurrentDictionary&lt;int, A&gt; dic = new ConcurrentDictionary&lt;int, A&gt;(); dic.TryAdd(1,...
C#中 列表List的用法 字典Dictionary的用法
qq_74158527的博客
07-23 1175
在 C# 中，`List` 是一种动态数组（也称为可变大小数组或动态列表），用于存储同一类型 `T` 的元素。` 创建了一个名为 `zombies` 的 `List`，用于存储 `GameObject` 类型的元素。在 C# 中，`List` 是 System.Collections.Generic 命名空间下的一个泛型类，其中 `T` 表示列表中的元素类型。在您的例子中，`new List()` 创建了一个空的 `GameObject` 类型的列表。
C#开发英语字典程序源码
01-23
【程序老媛出品，必属精品，亲测校正，质量保证】 资源名：C#开发英语字典程序源码 资源类型：程序源代码 源码说明： 数据保存在xml文件中，新手级示例，ajax数据请求基于ashx 适合人群：新手及有一定经验的开发人员
C#Winform 增删改查 SqlServer（附数据库）
05-30
在本文中，我们将深入探讨如何使用C# Winform与Sql Server数据库进行交互，实现增删改查功能。这个系统特别适合初学者学习，通过Visual Studio 2017开发环境，我们可以构建一个用户友好的图形界面，以方便地管理学生...
在C#使用字典存储事件示例及实现自定义事件访问器
12-25
使用字典存储事件实例 accessor-declarations 的一种用法是公开很多事件但不为每个事件分配字段，而是使用字典来存储这些事件实例。这只在具有很多事件但您预计大多数事件都不会实现时才有用。 public delegate ...
C#创建安全的字典(Dictionary)存储结构
09-01
在C#编程中，字典（Dictionary）是一种非常重要的数据结构，它提供了键值对（Key-Value Pair）的存储方式，允许通过键来快速访问对应的值。字典基于哈希表实现，具有高效的数据查找和插入性能，平均时间复杂度为O(1)...
C#简单的通用基础字典实现方法
09-04
在C#编程中，字典（Dictionary）是一种常用的数据结构，它提供了键值对的存储方式，允许通过键来快速访问对应的值。本文将详细介绍如何在C#中实现一个简单的通用基础字典，包括字典的索引、记录管理、回调功能以及...
C#并发宝典：深度解锁ConcurrentDictionary的线程安全魔力与实战秘籍
最新发布
java专栏
04-27 1957
作为.NET框架中的线程安全字典类，提供了丰富的原子操作方法，确保了在多线程环境下的高效、安全使用。在实际编码过程中，适时结合其他并发工具和设计模式，更能发挥其潜力，应对各种复杂的并发场景。提供了线程安全的操作，但在某些情况下，过度依赖其同步机制可能会导致不必要的性能开销。作为.NET框架中的一员猛将，凭借其出色的并发控制机制，为多线程环境下的字典操作提供了安全高效的解决方案。接口，专为多线程环境设计，提供了线程安全的添加、删除、更新和查询操作。的原子操作特性，它非常适合用于实现并发计数器。
C# Dictionary和Dynamic类型
weixin_30542079的博客
03-12 569
开发中需要传递变参，考虑使用 dynamic 还是 Dictionary（准确地说是Dictionary<string,object>）。dynamic的编码体验显著优于 Dictionary，如果性能差距不大的话，我会选择使用dynamic。搜索后没有找到类似对比数据，决定自行实验。 首先使用以下测试代码： public void TestDynamic() { ...
c# 在字典（Dictionary）里面添加key value
weixin_43636050的博客
07-01 2440
c# 在字典（Dictionary）里面添加key value 在C#程序开发中，如何添加或修改字典(Dictionary)中指定键对应的值Dictionary<Key,Value>？ if(myDictionary.ContainsKey(myKey)) { myDictionary[myKey] = myValue; } else { myDictionary.Add(myKey, myValue); } ...
C# Dictionary用法总结
12-23 445
转自：http://www.cnblogs.com/linlf03/archive/2011/12/09/2282574.html 作者：work hard work smart  博客园   C# Dictionary用法总结 1、用法1：　常规用 　　增加键值对之前需要判断是否存在该键，如果已经存在该键而且不判断，将抛出异常。所以这样每次都要进行判断，很麻烦，在备注里使用了一个扩
C# Dictionary通过value获取对应的key值
cbbbc
11-30 7900
1：最直白的循环遍历方法，可以分为遍历key--value键值对以及所有的key两种表现形式 2：用Linq的方式去查询（当然了这里要添加对应的命名空间 using System.Linq）  如下为一个十分简单的代码示例： private void GetDicKeyByValue() { Dictionary dic = new D
C#键值对
weixin_58819477的博客
01-06 1414
记录自己的学习笔记也方便给予初学者做参考
C# 自动生成字典（数据多的时候）
一个编程的同学
07-17 788
代码】C#自动生成字典（数据多的时候）
6.11--5：动态生成字典
weixin_42345008的博客
06-13 1829
'''现有一个列表li = [1,2,3,’a’,’b’,4,’c’]， 有一个字典（此字典是动态生成的，你并不知道它里面有多少键值对， 所以使用dic={}模拟此字典）；现在需要完成这样的操作： 如果字典中没有‘k1’这个键，那就创建这个‘k1’键和其对于的值(该键对应的值设置为空列表)， 并将列表li中的索引为奇数对应的元素，添加到‘k1’这个键对应的空列表中。 如果该字典中有‘k1’这个键...
C# Dictionary字典 T泛型反射
lccccccccc的专栏
06-25 6253
using Newtonsoft.Json; List listTJson = new List(); List listT0 = T0Service.Get(...) List listT1 = T1Service.Get(...) ... listTJson.Add(JsonConvert.SerializeObject(listT0)); listTJ
unity C#中字典的增删查改
04-25
# Unity C Unity C是指使用C#编写Unity游戏引擎中的代码。C#是一种高级编程语言，它具有易于学习和使用的特性，并且它是一种跨平台的语言，可以在不同的操作系统上实现代码的兼容性。Unity引擎使用C#作为默认的编程语言，这是因为它能够提供更快的开发速度和更好的代码可读性，而且它是游戏开发领域中非常流行的语言之一。Unity C专门用于开发Unity游戏引擎及其相关应用程序的代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

YUE ZHEN PENG

码字不易，如果你想请我喝杯果汁

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值