Merge branch 'master' of http://115.159.85.185:8098/r/ZhuHaiChuangZhi/GanFe...

wankeda

2025-04-15 9bae33c85d698987a6c9cf8ba8edbe9497b101dc

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