wanshenmean
2026-03-02 bfd4fd8e4a05a681ec10a47992294cf752a764c4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
using Microsoft.Extensions.Caching.Distributed;
using Microsoft.Extensions.Caching.Memory;
using Newtonsoft.Json;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEAWCS_Core.Helper;
 
namespace WIDESEAWCS_Core.Caches
{
    public class MemoryCacheService : ICacheService
    {
        protected IMemoryCache _cache;
        public MemoryCacheService(IMemoryCache cache)
        {
            _cache = cache;
 
        }
 
        public bool Add(string key, string value, int expireSeconds = -1, bool isSliding = false)
        {
            return AddObject(key, value, expireSeconds, isSliding);
        }
 
        public bool AddObject(string key, object value, int expireSeconds = -1, bool isSliding = false)
        {
            if (expireSeconds > 0)
            {
                _cache.Set(key,
                    value,
                    new MemoryCacheEntryOptions()
                    .SetSlidingExpiration(new TimeSpan(0, 0, expireSeconds))
                    );
            }
            else
            {
                _cache.Set(key, value);
            }
 
            return true;
        }
 
        public void AddOrUpdate(string key, string value, int expireSeconds = -1, bool isSliding = false)
        {
            if (!string.IsNullOrEmpty(Get(key)))
            {
                Remove(key);
                Add(key, value, expireSeconds, isSliding);
            }
            else
            {
                Add(key, value, expireSeconds, isSliding);
            }
        }
 
        public void AddOrUpdate(string key, object value, int expireSeconds = -1, bool isSliding = false)
        {
            if (!string.IsNullOrEmpty(Get(key)))
            {
                Remove(key);
                Add(key, value.Serialize(), expireSeconds, isSliding);
            }
            else
            {
                Add(key, value.Serialize(), expireSeconds, isSliding);
            }
        }
 
        public void Dispose()
        {
            if (_cache != null)
                _cache.Dispose();
            GC.SuppressFinalize(this);
        }
 
        public bool Exists(string key)
        {
            if (key == null)
            {
                throw new ArgumentNullException(nameof(key));
            }
            return _cache.Get(key) != null;
        }
 
        public T? Get<T>(string key) where T : class
        {
            if (key == null)
            {
                throw new ArgumentNullException(nameof(key));
            }
            object? value = _cache.Get(key);
            if (value == null)
            {
                throw new ArgumentNullException(nameof(key));
            }
            return value as T;
        }
 
        public string? Get(string key)
        {
            try
            {
                return _cache.Get(key)?.ToString();
            }
            catch
            {
                return string.Empty;
            }
        }
 
        public object? Get(Type type, string key)
        {
            try
            {
                object res = _cache.Get(key);
                return res == null ? default : JsonConvert.DeserializeObject(res?.ToString() ?? "{}", type);
            }
            catch
            {
                return string.Empty;
            }
        }
 
        public bool Remove(string key)
        {
            if (key == null)
            {
                throw new ArgumentNullException(nameof(key));
            }
            _cache.Remove(key);
 
            return !Exists(key);
        }
 
        public void Remove(IEnumerable<string> keys)
        {
            if (keys == null)
            {
                throw new ArgumentNullException(nameof(keys));
            }
 
            keys.ToList().ForEach(item => _cache.Remove(item));
        }
 
        public bool TryAdd(string key, string value, int expireSeconds = -1)
        {
            if (Exists(key)) return false;
            return Add(key, value, expireSeconds);
        }
 
        public bool TryAdd<T>(string key, T value, int expireSeconds = -1) where T : class
        {
            if (Exists(key)) return false;
            return AddObject(key, value, expireSeconds);
        }
 
        public bool TryGetValue(string key, out string? value)
        {
            value = _cache.Get(key)?.ToString();
            return value != null;
        }
 
        public bool TryGetValue<T>(string key, out T? value) where T : class
        {
            if (_cache.TryGetValue(key, out object? obj) && obj != null)
            {
                value = obj as T ?? JsonConvert.DeserializeObject<T>(obj.ToString() ?? "");
                return value != null;
            }
            value = default;
            return false;
        }
 
        public bool TryRemove(string key, out string? value)
        {
            value = _cache.Get(key)?.ToString();
            if (value == null) return false;
            _cache.Remove(key);
            return true;
        }
 
        public bool TryUpdate(string key, string newValue, int expireSeconds = -1)
        {
            if (!Exists(key)) return false;
            Remove(key);
            Add(key, newValue, expireSeconds);
            return true;
        }
 
        public string GetOrAdd(string key, string value, int expireSeconds = -1)
        {
            var existing = _cache.Get(key)?.ToString();
            if (existing != null) return existing;
            Add(key, value, expireSeconds);
            return value;
        }
 
        public string GetOrAdd(string key, Func<string, string> valueFactory, int expireSeconds = -1)
        {
            var existing = _cache.Get(key)?.ToString();
            if (existing != null) return existing;
            var value = valueFactory(key);
            Add(key, value, expireSeconds);
            return value;
        }
 
        public T GetOrAdd<T>(string key, Func<string, T> valueFactory, int expireSeconds = -1) where T : class
        {
            if (_cache.TryGetValue(key, out object? obj) && obj != null)
            {
                if (obj is T t) return t;
                var deserialized = JsonConvert.DeserializeObject<T>(obj.ToString() ?? "");
                if (deserialized != null) return deserialized;
            }
            var value = valueFactory(key);
            AddObject(key, value, expireSeconds);
            return value;
        }
    }
}