[+] TEngineServer

[+] TEngineServer

Assets/GameScripts/DotNet/Core/DataStructure/Dictionary/DictionaryExtensions.cs

@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+#pragma warning disable CS8601
+
+namespace TEngine.DataStructure
+{
+    public static class DictionaryExtensions
+    {
+        public static bool TryRemove<T, TV>(this IDictionary<T, TV> self, T key, out TV value)
+        {
+            if (!self.TryGetValue(key, out value))
+            {
+                return false;
+            }
+
+            self.Remove(key);
+            return true;
+        }
+    }
+}

Assets/GameScripts/DotNet/Core/DataStructure/Dictionary/DictionaryExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2906692879c7825458790e8cb128e7f2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameScripts/DotNet/Core/DataStructure/Dictionary/DictionaryPool.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+
+namespace TEngine.DataStructure
+{
+    public sealed class DictionaryPool<TM, TN> : Dictionary<TM, TN>, IDisposable where TM : notnull
+    {
+        private bool _isDispose;
+
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+            Pool<DictionaryPool<TM, TN>>.Return(this);
+        }
+
+        public static DictionaryPool<TM, TN> Create()
+        {
+            var dictionary = Pool<DictionaryPool<TM, TN>>.Rent();
+            dictionary._isDispose = false;
+            return dictionary;
+        }
+    }
+}

Assets/GameScripts/DotNet/Core/DataStructure/Dictionary/DictionaryPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 45285f160861f9c4bb96634e744e2c74
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameScripts/DotNet/Core/DataStructure/Dictionary/DoubleMapDictionary.cs

@@ -0,0 +1,174 @@
+using System;
+using System.Collections.Generic;
+#pragma warning disable CS8601
+#pragma warning disable CS8604
+#pragma warning disable CS8603
+
+namespace TEngine.DataStructure
+{
+    public class DoubleMapDictionaryPool<TKey, TValue> : DoubleMapDictionary<TKey, TValue>, IDisposable
+        where TKey : notnull where TValue : notnull
+    {
+        private bool _isDispose;
+
+        public static DoubleMapDictionaryPool<TKey, TValue> Create()
+        {
+            var a = Pool<DoubleMapDictionaryPool<TKey, TValue>>.Rent();
+            a._isDispose = false;
+            return a;
+        }
+
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+            Pool<DoubleMapDictionaryPool<TKey, TValue>>.Return(this);
+        }
+    }
+
+    public class DoubleMapDictionary<TK, TV> where TK : notnull where TV : notnull
+    {
+        private readonly Dictionary<TK, TV> _kv = new Dictionary<TK, TV>();
+        private readonly Dictionary<TV, TK> _vk = new Dictionary<TV, TK>();
+
+        public DoubleMapDictionary()
+        {
+        }
+
+        public DoubleMapDictionary(int capacity)
+        {
+            _kv = new Dictionary<TK, TV>(capacity);
+            _vk = new Dictionary<TV, TK>(capacity);
+        }
+
+        public List<TK> Keys => new List<TK>(_kv.Keys);
+
+        public List<TV> Values => new List<TV>(_vk.Keys);
+
+        public void ForEach(Action<TK, TV> action)
+        {
+            if (action == null)
+            {
+                return;
+            }
+
+            var keys = _kv.Keys;
+            foreach (var key in keys)
+            {
+                action(key, _kv[key]);
+            }
+        }
+
+        public void Add(TK key, TV value)
+        {
+            if (key == null || value == null || _kv.ContainsKey(key) || _vk.ContainsKey(value))
+            {
+                return;
+            }
+
+            _kv.Add(key, value);
+            _vk.Add(value, key);
+        }
+
+        public TV GetValueByKey(TK key)
+        {
+            if (key != null && _kv.ContainsKey(key))
+            {
+                return _kv[key];
+            }
+
+            return default;
+        }
+
+        public bool TryGetValueByKey(TK key, out TV value)
+        {
+            var result = key != null && _kv.ContainsKey(key);
+
+            value = result ? _kv[key] : default;
+
+            return result;
+        }
+
+        public TK GetKeyByValue(TV value)
+        {
+            if (value != null && _vk.ContainsKey(value))
+            {
+                return _vk[value];
+            }
+
+            return default;
+        }
+
+        public bool TryGetKeyByValue(TV value, out TK key)
+        {
+            var result = value != null && _vk.ContainsKey(value);
+
+            key = result ? _vk[value] : default;
+
+            return result;
+        }
+
+        public void RemoveByKey(TK key)
+        {
+            if (key == null)
+            {
+                return;
+            }
+
+            if (!_kv.TryGetValue(key, out var value))
+            {
+                return;
+            }
+
+            _kv.Remove(key);
+            _vk.Remove(value);
+        }
+
+        public void RemoveByValue(TV value)
+        {
+            if (value == null)
+            {
+                return;
+            }
+
+            if (!_vk.TryGetValue(value, out var key))
+            {
+                return;
+            }
+
+            _kv.Remove(key);
+            _vk.Remove(value);
+        }
+
+        public void Clear()
+        {
+            _kv.Clear();
+            _vk.Clear();
+        }
+
+        public bool ContainsKey(TK key)
+        {
+            return key != null && _kv.ContainsKey(key);
+        }
+
+        public bool ContainsValue(TV value)
+        {
+            return value != null && _vk.ContainsKey(value);
+        }
+
+        public bool Contains(TK key, TV value)
+        {
+            if (key == null || value == null)
+            {
+                return false;
+            }
+
+            return _kv.ContainsKey(key) && _vk.ContainsKey(value);
+        }
+    }
+}

Assets/GameScripts/DotNet/Core/DataStructure/Dictionary/DoubleMapDictionary.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e9b1abd0ffc450842bea6ec96e84425f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameScripts/DotNet/Core/DataStructure/Dictionary/EntityDictionary.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+
+namespace TEngine.DataStructure
+{
+    public sealed class EntityDictionary<TM, TN> : Dictionary<TM, TN>, IDisposable where TN : IDisposable where TM : notnull
+    {
+        private bool _isDispose;
+
+        public static EntityDictionary<TM, TN> Create()
+        {
+            var entityDictionary = Pool<EntityDictionary<TM, TN>>.Rent();
+            entityDictionary._isDispose = false;
+            return entityDictionary;
+        }
+
+        public new void Clear()
+        {
+            foreach (var keyValuePair in this)
+            {
+                keyValuePair.Value.Dispose();
+            }
+
+            base.Clear();
+        }
+
+        public void ClearNotDispose()
+        {
+            base.Clear();
+        }
+
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+            Pool<EntityDictionary<TM, TN>>.Return(this);
+        }
+    }
+}

Assets/GameScripts/DotNet/Core/DataStructure/Dictionary/EntityDictionary.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3e08b2b0077e40143a1f772a0f7b1ad5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameScripts/DotNet/Core/DataStructure/Dictionary/OneToManyDictionary.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+#pragma warning disable CS8603
+#pragma warning disable CS8601
+
+namespace TEngine.DataStructure
+{
+    public class OneToManyDictionaryPool<TKey, TValueKey, TValue> : OneToManyDictionary<TKey, TValueKey, TValue>,
+        IDisposable where TKey : notnull where TValueKey : notnull
+    {
+        private bool _isDispose;
+
+        public static OneToManyDictionaryPool<TKey, TValueKey, TValue> Create()
+        {
+            var a = Pool<OneToManyDictionaryPool<TKey, TValueKey, TValue>>.Rent();
+            a._isDispose = false;
+            return a;
+        }
+
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+            Pool<OneToManyDictionaryPool<TKey, TValueKey, TValue>>.Return(this);
+        }
+    }
+
+    public class OneToManyDictionary<TKey, TValueKey, TValue> : Dictionary<TKey, Dictionary<TValueKey, TValue>>
+        where TKey : notnull where TValueKey : notnull
+    {
+        private readonly Queue<Dictionary<TValueKey, TValue>> _queue = new Queue<Dictionary<TValueKey, TValue>>();
+        private readonly int _recyclingLimit = 120;
+
+        public OneToManyDictionary()
+        {
+        }
+
+        /// <summary>
+        /// 设置最大缓存数量
+        /// </summary>
+        /// <param name="recyclingLimit">
+        /// 1:防止数据量过大、所以超过recyclingLimit的数据还是走GC.
+        /// 2:设置成0不控制数量，全部缓存
+        /// </param>
+        public OneToManyDictionary(int recyclingLimit = 0)
+        {
+            _recyclingLimit = recyclingLimit;
+        }
+
+        public bool Contains(TKey key, TValueKey valueKey)
+        {
+            TryGetValue(key, out var dic);
+
+            return dic != null && dic.ContainsKey(valueKey);
+        }
+
+        public bool TryGetValue(TKey key, TValueKey valueKey, out TValue value)
+        {
+            value = default;
+            return TryGetValue(key, out var dic) && dic.TryGetValue(valueKey, out value);
+        }
+
+        public TValue First(TKey key)
+        {
+            return !TryGetValue(key, out var dic) ? default : dic.First().Value;
+        }
+
+        public void Add(TKey key, TValueKey valueKey, TValue value)
+        {
+            if (!TryGetValue(key, out var dic))
+            {
+                dic = Fetch();
+                dic[valueKey] = value;
+                // dic.Add(valueKey, value);
+                Add(key, dic);
+
+                return;
+            }
+
+            dic[valueKey] = value;
+            // dic.Add(valueKey, value);
+        }
+
+        public bool Remove(TKey key, TValueKey valueKey)
+        {
+            if (!TryGetValue(key, out var dic)) return false;
+
+            var result = dic.Remove(valueKey);
+
+            if (dic.Count == 0) RemoveKey(key);
+
+            return result;
+        }
+
+        public bool Remove(TKey key, TValueKey valueKey, out TValue value)
+        {
+            if (!TryGetValue(key, out var dic))
+            {
+                value = default;
+                return false;
+            }
+
+            var result = dic.TryGetValue(valueKey, out value);
+
+            if (result) dic.Remove(valueKey);
+
+            if (dic.Count == 0) RemoveKey(key);
+
+            return result;
+        }
+
+        public void RemoveKey(TKey key)
+        {
+            if (!TryGetValue(key, out var dic)) return;
+
+            Remove(key);
+            Recycle(dic);
+        }
+
+        private Dictionary<TValueKey, TValue> Fetch()
+        {
+            return _queue.Count <= 0 ? new Dictionary<TValueKey, TValue>() : _queue.Dequeue();
+        }
+
+        private void Recycle(Dictionary<TValueKey, TValue> dic)
+        {
+            dic.Clear();
+
+            if (_recyclingLimit != 0 && _queue.Count > _recyclingLimit) return;
+
+            _queue.Enqueue(dic);
+        }
+
+        public new void Clear()
+        {
+            foreach (var keyValuePair in this) Recycle(keyValuePair.Value);
+
+            base.Clear();
+        }
+    }
+}

Assets/GameScripts/DotNet/Core/DataStructure/Dictionary/OneToManyDictionary.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5db437bfa1f9b8b438b7260196e01934
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameScripts/DotNet/Core/DataStructure/Dictionary/OneToManySortedDictionary.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+#pragma warning disable CS8601
+
+namespace TEngine.DataStructure
+{
+    public class
+        OneToManySortedDictionaryPool<TKey, TSortedKey, TValue> : OneToManySortedDictionary<TKey, TSortedKey, TValue>,
+            IDisposable where TKey : notnull where TSortedKey : notnull
+    {
+        private bool _isDispose;
+
+        public static OneToManySortedDictionaryPool<TKey, TSortedKey, TValue> Create()
+        {
+            var a = Pool<OneToManySortedDictionaryPool<TKey, TSortedKey, TValue>>.Rent();
+            a._isDispose = false;
+            return a;
+        }
+
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+            Pool<OneToManySortedDictionaryPool<TKey, TSortedKey, TValue>>.Return(this);
+        }
+    }
+
+    public class
+        OneToManySortedDictionary<TKey, TSortedKey, TValue> : Dictionary<TKey, SortedDictionary<TSortedKey, TValue>>
+        where TSortedKey : notnull where TKey : notnull
+    {
+        private readonly int _recyclingLimit = 120;
+
+        private readonly Queue<SortedDictionary<TSortedKey, TValue>> _queue =
+            new Queue<SortedDictionary<TSortedKey, TValue>>();
+
+        protected OneToManySortedDictionary()
+        {
+        }
+
+        /// <summary>
+        /// 设置最大缓存数量
+        /// </summary>
+        /// <param name="recyclingLimit">
+        /// 1:防止数据量过大、所以超过recyclingLimit的数据还是走GC.
+        /// 2:设置成0不控制数量，全部缓存
+        /// </param>
+        public OneToManySortedDictionary(int recyclingLimit)
+        {
+            _recyclingLimit = recyclingLimit;
+        }
+
+        public bool Contains(TKey key)
+        {
+            return this.ContainsKey(key);
+        }
+
+        public bool Contains(TKey key, TSortedKey sortedKey)
+        {
+            return TryGetValue(key, out var dic) && dic.ContainsKey(sortedKey);
+        }
+
+        public new bool TryGetValue(TKey key, out SortedDictionary<TSortedKey, TValue> dic)
+        {
+            return base.TryGetValue(key, out dic);
+        }
+
+        public bool TryGetValueBySortedKey(TKey key, TSortedKey sortedKey, out TValue value)
+        {
+            if (base.TryGetValue(key, out var dic))
+            {
+                return dic.TryGetValue(sortedKey, out value);
+            }
+
+            value = default;
+            return false;
+        }
+
+        public void Add(TKey key, TSortedKey sortedKey, TValue value)
+        {
+            if (!TryGetValue(key, out var dic))
+            {
+                dic = Fetch();
+                dic.Add(sortedKey, value);
+                Add(key, dic);
+
+                return;
+            }
+
+            dic.Add(sortedKey, value);
+        }
+
+        public bool RemoveSortedKey(TKey key, TSortedKey sortedKey)
+        {
+            if (!TryGetValue(key, out var dic))
+            {
+                return false;
+            }
+
+            var isRemove = dic.Remove(sortedKey);
+
+            if (dic.Count == 0)
+            {
+                isRemove = RemoveKey(key);
+            }
+
+            return isRemove;
+        }
+
+        public bool RemoveKey(TKey key)
+        {
+            if (!TryGetValue(key, out var list))
+            {
+                return false;
+            }
+
+            Remove(key);
+            Recycle(list);
+            return true;
+        }
+
+        private SortedDictionary<TSortedKey, TValue> Fetch()
+        {
+            return _queue.Count <= 0 ? new SortedDictionary<TSortedKey, TValue>() : _queue.Dequeue();
+        }
+
+        private void Recycle(SortedDictionary<TSortedKey, TValue> dic)
+        {
+            dic.Clear();
+
+            if (_recyclingLimit != 0 && _queue.Count > _recyclingLimit)
+            {
+                return;
+            }
+
+            _queue.Enqueue(dic);
+        }
+
+        protected new void Clear()
+        {
+            base.Clear();
+            _queue.Clear();
+        }
+    }
+}

Assets/GameScripts/DotNet/Core/DataStructure/Dictionary/OneToManySortedDictionary.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c0ac9ed7abbf4e4408901274ee344642
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GameScripts/DotNet/Core/DataStructure/Dictionary/ReuseDictionary.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+
+namespace TEngine.DataStructure
+{
+    public sealed class ReuseDictionary<TM, TN> : Dictionary<TM, TN>, IDisposable where TM : notnull
+    {
+        private bool _isDispose;
+
+        public static ReuseDictionary<TM, TN> Create()
+        {
+            var entityDictionary = Pool<ReuseDictionary<TM, TN>>.Rent();
+            entityDictionary._isDispose = false;
+            return entityDictionary;
+        }
+        
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+            Pool<ReuseDictionary<TM, TN>>.Return(this);
+        }
+    }
+}

Assets/GameScripts/DotNet/Core/DataStructure/Dictionary/ReuseDictionary.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bf01018dd07bd2243b8636a1321f50c5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: