/// <summary>
/// 创建redis对象
/// </summary>
/// <returns></returns>
public CacheClient CreateInstance()
{
CacheClient client = null;//获取Redis操作接口
if (IsTrue)
{
switch (IsCacheName)
{
case CacheEnum.RedisCache:
client = new RedisCacheClient((DBEnum)RedisDB);
break;
case CacheEnum.MemCache:
client = new MemCacheClient();
break;
case CacheEnum.LocalCache:
client = new LocalClient();
break;
}
}
else
{
cacheLog.Info(IsCacheName.ToString() + "缓存未启用");
}
return(client);
}
public RedisLockTests()
{
var muxer = ConnectionMultiplexer.Connect(Settings.Current.RedisConnectionInfo.ToString());
_cacheClient = new RedisCacheClient(muxer.GetDatabase());
_locker = new CacheLockProvider(_cacheClient);
}
public void ApplyDispatchBehavior(OperationDescription operationDescription, DispatchOperation dispatchOperation)
{
// We recommend to do this by using a IoC, for demo purposes a new instance is created manually.
var cacheClient = new RedisCacheClient();
dispatchOperation.Invoker = new CacheOperationInvoker(dispatchOperation.Invoker, cacheClient);
}
public async Task <JsonResult> PesquisarJson(String termo)
{
db.Configuration.ProxyCreationEnabled = false;
db.Configuration.LazyLoadingEnabled = false;
if (String.IsNullOrEmpty(termo))
{
return(Json(null, JsonRequestBehavior.AllowGet));
}
if (!await RedisCacheClient.ExistsAsync("Agencias"))
{
var agenciasBancarias = await db.AgenciasBancarias
// .Where(a => a.Nome.Contains(termo) || termo.Contains(a.CodigoCompensacao.ToString()))
.ToListAsync();
await RedisCacheClient.AddAsync("Agencias", agenciasBancarias, new TimeSpan(0, 3, 0));
}
termo = termo.ToUpper();
var lista = await RedisCacheClient.GetAsync <List <AgenciaBancaria> >("Agencias");
return(Json(lista
.Where(a => a.Nome.Contains(termo) || termo.Contains(a.CodigoCompensacao.ToString())), JsonRequestBehavior.AllowGet));
// return Json(agenciasBancarias, JsonRequestBehavior.AllowGet);
}
// GET: Veiculos
public async Task <ActionResult> Index(int?page)
{
if (!await RedisCacheClient.ExistsAsync("Veiculos"))
{
await RedisCacheClient.AddAsync("Veiculo", "", new TimeSpan(0, 3, 0));
var veiculosDB = await db.Veiculos.ToListAsync();
foreach (var item in veiculosDB)
{
await RedisCacheClient.AddAsync("Veiculo:" + item.VeiculoId.ToString(), item, new TimeSpan(0, 3, 0));
}
}
var veiculos = (await RedisCacheClient.SearchKeysAsync("Veiculo:*"))
.Select(p => RedisCacheClient.Get <Veiculo>(p)).OrderBy(x => x.VeiculoId).ToList() ??
await db.Veiculos.OrderBy(x => x.VeiculoId).ToListAsync();
var pageNumber = page ?? 1;
var paginacao = await veiculos.ToPagedListAsync(pageNumber, 25);
ViewBag.PageVeiculos = paginacao;
return(View());
}
// GET: Categorias
public async Task <ActionResult> Index(int?page)
{
if (!await RedisCacheClient.ExistsAsync("Categoria"))
{
await RedisCacheClient.AddAsync("Categoria", "", new TimeSpan(0, 3, 0));
var categoriaDB = await db.Categorias.ToListAsync();
foreach (var item in categoriaDB)
{
await RedisCacheClient.AddAsync("Categoria:" + item.CategoriaId.ToString(), item, new TimeSpan(0, 3, 0));
}
}
var categorias = (await RedisCacheClient.SearchKeysAsync("Categoria:*"))
.Select(p => RedisCacheClient.Get <Categoria>(p)).OrderBy(x => x.CategoriaId).ToList() ??
await db.Categorias.OrderBy(x => x.CategoriaId).ToListAsync();
var pageNumber = page ?? 1;
var paginacao = await categorias.ToPagedListAsync(pageNumber, 25);
ViewBag.PageCategorias = paginacao;
return(View());
}
public WeChatRedisCache(
RedisCacheClient client,
ILogger <WeChatRedisCache> logger)
{
_client = client;
_logger = logger;
}
private static async Task CacheSingleTest()
{
using (var cachePool = new CacheClientPoolAsync("Pool Test")
{
Serializer = GlobalSerializer
})
{
try
{
var cacheClient = new RedisCacheClient("localhost", "test")
{
DisableNotSupportedExceptions = true
};
cachePool.Add("test", cacheClient, StorageItemMode.ReadAndWrite);
for (var i = 0; i < 15; i++)
{
await cachePool.GetKeysAsync().ConfigureAwait(false);
}
for (var i = 0; i < 5000; i++)
{
var key = "test-" + i;
var kv = await cachePool.GetAsync(key).ConfigureAwait(false);
var kv2 = await cachePool.SetAsync(key, "bla bla bla bla bla bla").ConfigureAwait(false);
}
Core.Log.InfoBasic("Done.");
}
catch (Exception ex)
{
Core.Log.Write(ex);
}
}
}
public RedisLockTests()
{
var muxer = ConnectionMultiplexer.Connect(Settings.Current.RedisConnectionString);
_cacheClient = new RedisCacheClient(muxer);
_locker = new CacheLockProvider(_cacheClient);
}
public CacheClient(RedisConfiguration config)
{
this.config = config;
ConnectionPool = new RedisCacheConnectionPoolManager(this.config);
Client = new RedisCacheClient(ConnectionPool, new Utf8JsonSerializer(), config);
RedisDb = Client.GetDbFromConfiguration();
Db = RedisDb.Database;
}
public RedisService(RedisConfiguration redisConfiguration)
{
this.redisConfiguration = redisConfiguration;
var merged = MergeConfiguration(redisConfiguration, RedisHosts(), RedisPassword());
redisCacheClient = new RedisCacheClient(new RedisCacheConnectionPoolManager(merged), new SystemTextJsonSerializer(), merged);
}
public RedisAuthenticationSessionStore(string connectionString)
{
var muxer = ConnectionMultiplexer.Connect(connectionString);
_client = new RedisCacheClient(new RedisCacheClientOptions
{
ConnectionMultiplexer = muxer
});
}
public RedisCacheClientTests()
{
//if (!Settings.Current.UseAzureCache)
// return;
var muxer = ConnectionMultiplexer.Connect(Settings.Current.RedisConnectionInfo.ToString());
_cache = new RedisCacheClient(muxer.GetDatabase());
}
public override async Task CanHaveMultipleQueueInstancesWithLockingAsync()
{
var muxer = SharedConnection.GetMuxer();
using var cache = new RedisCacheClient(new RedisCacheClientOptions { ConnectionMultiplexer = muxer, LoggerFactory = Log });
using var messageBus = new RedisMessageBus(new RedisMessageBusOptions { Subscriber = muxer.GetSubscriber(), Topic = "test-queue", LoggerFactory = Log });
var distributedLock = new CacheLockProvider(cache, messageBus, Log);
await CanHaveMultipleQueueInstancesWithLockingImplAsync(distributedLock);
}
public void SetUp()
{
mockRedisConnection = new Mock <IConnectionMultiplexer>();
mockRedisDb = new Mock <IDatabase>();
mockRedisConnection.Setup(c => c.GetDatabase(-1, null)).Returns(mockRedisDb.Object);
redisCacheClient = new RedisCacheClient()
{
RedisConnection = mockRedisConnection.Object
};
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Contato contato = await db.Contatos.FindAsync(id);
db.Contatos.Remove(contato);
await db.SaveChangesAsync();
await RedisCacheClient.RemoveAsync("Contato:" + id);
return(RedirectToAction("Index"));
}
public RedisCacheClientTests()
{
if (Settings.Current.RedisConnectionInfo == null)
{
return;
}
var muxer = ConnectionMultiplexer.Connect(Settings.Current.RedisConnectionInfo.ToString());
_cache = new RedisCacheClient(muxer.GetDatabase());
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Veiculo veiculo = await db.Veiculos.FindAsync(id);
db.Veiculos.Remove(veiculo);
await db.SaveChangesAsync();
await RedisCacheClient.RemoveAsync("Veiculo:" + id);
return(RedirectToAction("Index"));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Funcionario funcionario = await db.Funcionarios.FindAsync(id);
db.Funcionarios.Remove(funcionario);
await db.SaveChangesAsync();
await RedisCacheClient.RemoveAsync("Funcionario:" + id);
return(RedirectToAction("Index"));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Empresa empresa = await db.Empresas.FindAsync(id);
db.Empresas.Remove(empresa);
await db.SaveChangesAsync();
await RedisCacheClient.RemoveAsync("Empresa:" + id);
return(RedirectToAction("Index"));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Banco banco = await db.Bancos.FindAsync(id);
db.Bancos.Remove(banco);
await db.SaveChangesAsync();
await RedisCacheClient.RemoveAsync("Banco:" + banco.BancoId);
return(RedirectToAction("Index"));
}
public override async Task CanHaveMultipleQueueInstancesWithLockingAsync()
{
var muxer = SharedConnection.GetMuxer();
using (var cache = new RedisCacheClient(muxer, loggerFactory: Log)) {
using (var messageBus = new RedisMessageBus(muxer.GetSubscriber(), "test", loggerFactory: Log)) {
var distributedLock = new CacheLockProvider(cache, messageBus, Log);
await CanHaveMultipleQueueInstancesWithLockingImplAsync(distributedLock);
}
}
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Categoria categoria = await db.Categorias.FindAsync(id);
db.Categorias.Remove(categoria);
await db.SaveChangesAsync();
await RedisCacheClient.RemoveAsync("Categoria:" + id);
return(RedirectToAction("Index"));
}
public RedisController(RedisCacheClient client, ConnectionMultiplexer redis, ILogger <RedisController> logger)
{
//这种获取每次都要连接一次redis
//可以考虑实际使用的时候再GetDatabase
_database = client.GetDatabase();
_client = client;
//直接ConnectionMultiplexer单例。
_redis = redis;
_database = _redis.GetDatabase();
_logger = logger;
}
public CacheClient(RedisConfiguration config)
{
this.config = config;
config.ConfigurationOptions.CertificateSelection += ConfigurationOptions_CertificateSelection;
// MEMO: Don't do this in production (Dev only)
// hack for local redis tls docker
config.ConfigurationOptions.CertificateValidation += ConfigurationOptions_CertificateValidation;
ConnectionPool = new RedisCacheConnectionPoolManager(this.config);
Client = new RedisCacheClient(ConnectionPool, new Utf8JsonSerializer(), config);
RedisDb = Client.GetDbFromConfiguration();
Db = RedisDb.Database;
}
private static IRedisCacheClient GetCacheClient(RedisConfiguration redisConfig, ISerializer sz = null)
{
var poolManager = new RedisCacheConnectionPoolManager(redisConfig);
if (sz == null)
{
sz = new MsgPackObjectSerializer();
}
var cacheClient = new RedisCacheClient(poolManager, sz, redisConfig);
return(cacheClient);
}
public async Task <ActionResult> Edit([Bind(Include = "VeiculoId,Carro,Marca,Ano,Placa")] Veiculo veiculo)
{
if (ModelState.IsValid)
{
db.Entry(veiculo).State = EntityState.Modified;
await db.SaveChangesAsync();
await RedisCacheClient.ReplaceAsync("Veiculo:" + veiculo.VeiculoId, veiculo, new TimeSpan(0, 10, 0));
return(RedirectToAction("Index"));
}
return(View(veiculo));
}
public async Task <ActionResult> Edit([Bind(Include = "CategoriaId,Nome")] Categoria categoria)
{
if (ModelState.IsValid)
{
db.Entry(categoria).State = EntityState.Modified;
await db.SaveChangesAsync();
await RedisCacheClient.ReplaceAsync("Categoria:" + categoria.CategoriaId, categoria, new TimeSpan(0, 10, 0));
return(RedirectToAction("Index"));
}
return(View(categoria));
}
public async Task <ActionResult> Edit([Bind(Include = "ContatoId,Nome,Email")] Contato contato)
{
if (ModelState.IsValid)
{
db.Entry(contato).State = EntityState.Modified;
await db.SaveChangesAsync();
await RedisCacheClient.ReplaceAsync("Contato:" + contato.ContatoId, contato, new TimeSpan(0, 10, 0));
return(RedirectToAction("Index"));
}
return(View(contato));
}
static void Main(string[] args)
{
MallCard mall = new MallCard()
{
ID = Guid.NewGuid().ToString("N"),
MallID = new Random().Next(1, 100),
UID = new Random().Next(1, 1000)
};
int seed = 1;
Stopwatch sw = new Stopwatch();
Task[] taskList = new Task[seed];
string conStr = System.Configuration.ConfigurationManager.AppSettings["conStr"];
using (RedisCacheClient client = new RedisCacheClient(conStr, 2))
{
sw.Restart();
string key = "123ABC";
taskList[0] = client.SetAsync<string>(key, "33333");
//for (var i = 0; i < seed; i++)
//{
// //RedisKey key = "MallCardbcb0878b8e814b8fa7540862729044c9"; //mall.GetKey();
// ////RedisValue val = serializer.Serialize(mall);
// client.Database.StringSet(key, val);
// //var task = client.Database.StringGetAsync(key).ContinueWith(x =>
// //{
// // var mall2 = serializer.Deserialize<MallCard2>(x.Result);
// // ;
// //});
// //taskList[i] = task;
// //client.s
// string key = "123ABC";
// taskList[i] = client.GetAsync<MallCard2>(key);
//}
Task.WhenAll(taskList);
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);
Console.WriteLine(seed / sw.Elapsed.TotalSeconds);
Console.ReadLine();
//Assert.AreEqual(mall.MallID, mall2.MallID);
}
}
public void Publish()
{
MallCard mall = new MallCard()
{
ID = Guid.NewGuid().ToString("N").Substring(0, 5),
Name = Guid.NewGuid().ToString("N"),
MallID = new Random().Next(1, 100),
UID = new Random().Next(1, 1000)
};
using (RedisCacheClient client = new RedisCacheClient(serializer))
{
client.Publish("var", mall);
}
}
static void Main(string[] args)
{
using (RedisCacheClient client = new RedisCacheClient())
{
client.Subscribe<MallCard>("var", (x) =>
{
Console.WriteLine(x.Name);
});
Console.ReadLine();
}
Console.WriteLine("over...");
}
public void StringSet_StringGet()
{
MallCard mall = new MallCard()
{
ID = Guid.NewGuid().ToString("N").Substring(0, 5),
Name = Guid.NewGuid().ToString("N"),
MallID = new Random().Next(1, 100),
UID = new Random().Next(1, 1000)
};
using (RedisCacheClient client = new RedisCacheClient(serializer))
{
var key = mall.GetKey();
RedisValue val = serializer.Serialize(mall);
client.Database.StringSet(key, val);
client.Set(key, mall);
//byte[] val2 = client.Database.StringGet(key);
//var mall2 = serializer.Deserialize<MallCard2>(val2);
var mall2 = client.Get<MallCard2>(key);
Assert.AreEqual(mall.Name, mall2.Name);
}
}
public RedisTableCache(RedisCacheClient client)
: base(client)
{
}
public RedisLockTests() {
var muxer = ConnectionMultiplexer.Connect(Settings.Current.RedisConnectionInfo.ToString());
_cacheClient = new RedisCacheClient(muxer.GetDatabase());
_locker = new CacheLockProvider(_cacheClient);
}
public RedisQueue(RedisQueueOptions <T> options) : base(options)
{
if (options.ConnectionMultiplexer == null)
{
throw new ArgumentException("ConnectionMultiplexer is required.");
}
options.ConnectionMultiplexer.ConnectionRestored += ConnectionMultiplexerOnConnectionRestored;
_cache = new RedisCacheClient(new RedisCacheClientOptions {
ConnectionMultiplexer = options.ConnectionMultiplexer, Serializer = _serializer
});
_payloadTimeToLive = GetPayloadTtl();
_subscriber = _options.ConnectionMultiplexer.GetSubscriber();
string listPrefix = _options.ConnectionMultiplexer.IsCluster() ? "{q:" + _options.Name + "}" : $"q:{_options.Name}";
_queueListName = $"{listPrefix}:in";
_workListName = $"{listPrefix}:work";
_waitListName = $"{listPrefix}:wait";
_deadListName = $"{listPrefix}:dead";
// min is 1 second, max is 1 minute
var interval = _options.WorkItemTimeout > TimeSpan.FromSeconds(1) ? _options.WorkItemTimeout.Min(TimeSpan.FromMinutes(1)) : TimeSpan.FromSeconds(1);
_maintenanceLockProvider = new ThrottlingLockProvider(_cache, 1, interval);
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace("Queue {QueueId} created. Retries: {Retries} Retry Delay: {RetryDelay:g}, Maintenance Interval: {MaintenanceInterval:g}", QueueId, _options.Retries, _options.RetryDelay, interval);
}
}
public RedisCacheClientTests() {
//if (!Settings.Current.UseAzureCache)
// return;
var muxer = ConnectionMultiplexer.Connect(Settings.Current.RedisConnectionInfo.ToString());
_cache = new RedisCacheClient(muxer.GetDatabase());
}
