/// <summary>
/// Withs the json serializer.
/// </summary>
/// <param name="options">Options.</param>
/// <param name="configure">Configure serializer settings.</param>
/// <param name="name">The name of this serializer instance.</param>
public static EasyCachingOptions WithSystemTextJson(this EasyCachingOptions options, Action <EasyCachingJsonSerializerOptions> configure, string name)
{
var easyCachingJsonSerializerOptions = new EasyCachingJsonSerializerOptions();
configure(easyCachingJsonSerializerOptions);
void jsonSerializerSettings(JsonSerializerOptions x)
{
x.MaxDepth = easyCachingJsonSerializerOptions.MaxDepth;
x.AllowTrailingCommas = easyCachingJsonSerializerOptions.AllowTrailingCommas;
x.Converters.Union(easyCachingJsonSerializerOptions.Converters);
x.DefaultBufferSize = easyCachingJsonSerializerOptions.DefaultBufferSize;
x.DefaultIgnoreCondition = easyCachingJsonSerializerOptions.DefaultIgnoreCondition;
x.DictionaryKeyPolicy = easyCachingJsonSerializerOptions.DictionaryKeyPolicy;
x.Encoder = easyCachingJsonSerializerOptions.Encoder;
x.IgnoreReadOnlyFields = easyCachingJsonSerializerOptions.IgnoreReadOnlyFields;
x.IgnoreReadOnlyProperties = easyCachingJsonSerializerOptions.IgnoreReadOnlyProperties;
x.IncludeFields = easyCachingJsonSerializerOptions.IncludeFields;
x.NumberHandling = easyCachingJsonSerializerOptions.NumberHandling;
x.PropertyNameCaseInsensitive = easyCachingJsonSerializerOptions.PropertyNameCaseInsensitive;
x.PropertyNamingPolicy = easyCachingJsonSerializerOptions.PropertyNamingPolicy;
x.ReadCommentHandling = easyCachingJsonSerializerOptions.ReadCommentHandling;
x.ReferenceHandler = easyCachingJsonSerializerOptions.ReferenceHandler;
x.WriteIndented = easyCachingJsonSerializerOptions.WriteIndented;
}
options.RegisterExtension(new JsonOptionsExtension(name, jsonSerializerSettings));
return(options);
}
/// <summary>
/// Uses the in-memory provider (read config from configuration file).
/// </summary>
/// <param name="options">Options.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="name">The name of this provider instance.</param>
/// <param name="sectionName">The section name in the configuration file.</param>
public static EasyCachingOptions UseInMemory(
this EasyCachingOptions options
, IConfiguration configuration
, string name = EasyCachingConstValue.DefaultInMemoryName
, string sectionName = EasyCachingConstValue.InMemorySection
)
{
var dbConfig = configuration.GetSection(sectionName);
var memoryOptions = new InMemoryOptions();
dbConfig.Bind(memoryOptions);
void configure(InMemoryOptions x)
{
x.EnableLogging = memoryOptions.EnableLogging;
x.MaxRdSecond = memoryOptions.MaxRdSecond;
x.LockMs = memoryOptions.LockMs;
x.SleepMs = memoryOptions.SleepMs;
x.SerializerName = memoryOptions.SerializerName;
x.CacheNulls = memoryOptions.CacheNulls;
x.DBConfig = memoryOptions.DBConfig;
}
return(options.UseInMemory(configure, name));
}
/// <summary>
/// Uses the LiteDB provider (read config from configuration file).
/// </summary>
/// <param name="options">Options.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="name">The name of this provider instance.</param>
/// <param name="sectionName">The section name in the configuration file.</param>
public static EasyCachingOptions UseLiteDB(
this EasyCachingOptions options
, IConfiguration configuration
, string name = EasyCachingConstValue.DefaultLiteDBName
, string sectionName = EasyCachingConstValue.LiteDBSection
)
{
var dbConfig = configuration.GetSection(sectionName);
var LiteDBOptions = new LiteDBOptions();
dbConfig.Bind(LiteDBOptions);
void configure(LiteDBOptions x)
{
x.EnableLogging = LiteDBOptions.EnableLogging;
x.MaxRdSecond = LiteDBOptions.MaxRdSecond;
x.LockMs = LiteDBOptions.LockMs;
x.SleepMs = LiteDBOptions.SleepMs;
x.SerializerName = LiteDBOptions.SerializerName;
x.CacheNulls = LiteDBOptions.CacheNulls;
x.DBConfig = LiteDBOptions.DBConfig;
}
options.RegisterExtension(new LiteDBOptionsExtension(name, configure));
return(options);
}
/// <summary>
/// Uses the memcached provider (read config from configuration file).
/// </summary>
/// <param name="options">Options.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="name">The name of this provider instance.</param>
/// <param name="sectionName">The section name in the configuration file.</param>
public static EasyCachingOptions UseMemcached(
this EasyCachingOptions options
, IConfiguration configuration
, string name = EasyCachingConstValue.DefaultMemcachedName
, string sectionName = EasyCachingConstValue.MemcachedSection
)
{
var dbConfig = configuration.GetSection(sectionName);
var mOptions = new MemcachedOptions();
dbConfig.Bind(mOptions);
void configure(MemcachedOptions x)
{
x.EnableLogging = mOptions.EnableLogging;
x.MaxRdSecond = mOptions.MaxRdSecond;
x.LockMs = mOptions.LockMs;
x.SleepMs = mOptions.SleepMs;
x.SerializerName = mOptions.SerializerName;
x.DBConfig = mOptions.DBConfig;
}
options.RegisterExtension(new MemcachedOptionsExtension(name, configure));
return(options);
}
/// <summary>
/// Withs the RabbitMQ bus (read config from configuration file).
/// </summary>
/// <param name="options">Options.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="sectionName">The section name in the configuration file.</param>
public static EasyCachingOptions WithRabbitMQBus(
this EasyCachingOptions options
, IConfiguration configuration
, string sectionName = EasyCachingConstValue.RabbitMQBusSection
)
{
var dbConfig = configuration.GetSection(sectionName);
var busOptions = new RabbitMQBusOptions();
dbConfig.Bind(busOptions);
void configure(RabbitMQBusOptions x)
{
x.HostName = busOptions.HostName;
x.Password = busOptions.Password;
x.Port = busOptions.Port;
x.QueueMessageExpires = busOptions.QueueMessageExpires;
x.RequestedConnectionTimeout = busOptions.RequestedConnectionTimeout;
//x.RouteKey = busOptions.RouteKey;
x.SocketReadTimeout = busOptions.SocketReadTimeout;
x.SocketWriteTimeout = busOptions.SocketWriteTimeout;
x.TopicExchangeName = busOptions.TopicExchangeName;
x.UserName = busOptions.UserName;
x.VirtualHost = busOptions.VirtualHost;
x.QueueName = busOptions.QueueName;
}
options.RegisterExtension(new RabbitMQBusOptionsExtension(configure));
return(options);
}
/// <summary>
/// Uses the CSRedis provider (read config from configuration file).
/// </summary>
/// <param name="options">Options.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="name">The name of this provider instance.</param>
/// <param name="sectionName">The section name in the configuration file.</param>
public static EasyCachingOptions UseCSRedis(
this EasyCachingOptions options
, IConfiguration configuration
, string name = EasyCachingConstValue.DefaultCSRedisName
, string sectionName = EasyCachingConstValue.CSRedisSection
)
{
var dbConfig = configuration.GetSection(sectionName);
var redisOptions = new RedisOptions();
dbConfig.Bind(redisOptions);
void configure(RedisOptions x)
{
x.EnableLogging = redisOptions.EnableLogging;
x.MaxRdSecond = redisOptions.MaxRdSecond;
x.LockMs = redisOptions.LockMs;
x.SleepMs = redisOptions.SleepMs;
x.SerializerName = redisOptions.SerializerName;
x.DBConfig = redisOptions.DBConfig;
}
options.RegisterExtension(new RedisOptionsExtension(name, configure));
return(options);
}
/// <summary>
/// Uses the CSRedis.
/// </summary>
/// <returns>The CSR edis.</returns>
/// <param name="options">Options.</param>
/// <param name="configure">Configure.</param>
/// <param name="name">Name.</param>
public static EasyCachingOptions UseCSRedis(this EasyCachingOptions options, Action <RedisOptions> configure, string name = EasyCachingConstValue.DefaultCSRedisName)
{
ArgumentCheck.NotNull(configure, nameof(configure));
options.RegisterExtension(new RedisOptionsExtension(name, configure));
return(options);
}
/// <summary>
/// Uses the disk caching provider (read config from configuration file).
/// </summary>
/// <param name="options">Options.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="name">The name of this provider instance.</param>
/// <param name="sectionName">The section name in the configuration file.</param>
public static EasyCachingOptions UseDisk(
this EasyCachingOptions options
, IConfiguration configuration
, string name = EasyCachingConstValue.DefaultDiskName
, string sectionName = EasyCachingConstValue.DiskSection
)
{
var dbConfig = configuration.GetSection(sectionName);
var diskOptions = new DiskOptions();
dbConfig.Bind(diskOptions);
void configure(DiskOptions x)
{
x.EnableLogging = diskOptions.EnableLogging;
x.MaxRdSecond = diskOptions.MaxRdSecond;
x.LockMs = diskOptions.LockMs;
x.SleepMs = diskOptions.SleepMs;
x.SerializerName = diskOptions.SerializerName;
x.CacheNulls = diskOptions.CacheNulls;
x.DBConfig = diskOptions.DBConfig;
}
return(options.UseDisk(configure, name));
}
/// <summary>
/// Uses the SQLite provider (read config from configuration file).
/// </summary>
/// <param name="options">Options.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="name">The name of this provider instance.</param>
/// <param name="sectionName">The section name in the configuration file.</param>
public static EasyCachingOptions UseSQLite(
this EasyCachingOptions options
, IConfiguration configuration
, string name = EasyCachingConstValue.DefaultSQLiteName
, string sectionName = EasyCachingConstValue.SQLiteSection
)
{
var dbConfig = configuration.GetSection(sectionName);
var sqliteOptions = new SQLiteOptions();
dbConfig.Bind(sqliteOptions);
void configure(SQLiteOptions x)
{
x.EnableLogging = sqliteOptions.EnableLogging;
x.MaxRdSecond = sqliteOptions.MaxRdSecond;
x.LockMs = sqliteOptions.LockMs;
x.SleepMs = sqliteOptions.SleepMs;
x.SerializerName = sqliteOptions.SerializerName;
x.DBConfig = sqliteOptions.DBConfig;
}
options.RegisterExtension(new SQLiteOptionsExtension(name, configure));
return(options);
}
/// <summary>
/// Withs the SERedis bus (read config from configuration file).
/// </summary>
/// <param name="options">Options.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="sectionName">The section name in the configuration file.</param>
public static EasyCachingOptions WithRedisBus(
this EasyCachingOptions options
, IConfiguration configuration
, string sectionName = EasyCachingConstValue.RedisBusSection
)
{
var dbConfig = configuration.GetSection(sectionName);
var redisOptions = new RedisBusOptions();
dbConfig.Bind(redisOptions);
void configure(RedisBusOptions x)
{
x.AbortOnConnectFail = redisOptions.AbortOnConnectFail;
x.AllowAdmin = redisOptions.AllowAdmin;
x.Configuration = redisOptions.Configuration;
x.ConnectionTimeout = redisOptions.ConnectionTimeout;
x.Database = redisOptions.Database;
x.IsSsl = redisOptions.IsSsl;
x.Username = redisOptions.Username;
x.Password = redisOptions.Password;
x.SslHost = redisOptions.SslHost;
foreach (var item in redisOptions.Endpoints)
{
x.Endpoints.Add(item);
}
}
options.RegisterExtension(new RedisBusOptionsExtension(configure));
return(options);
}
/// <summary>
/// Add specified compressor upon the specified serializer by name.
/// </summary>
/// <param name="options"></param>
/// <param name="serializerName"></param>
/// <param name="compressorName"></param>
/// <returns></returns>
public static EasyCachingOptions WithCompressor(this EasyCachingOptions options, string serializerName, string compressorName)
{
var optionsExtension = new EasyCompressorEasyCachingOptionsExtension(serializerName, compressorName);
options.RegisterExtension(optionsExtension);
return(options);
}
/// <summary>
/// Add default compressor upon the default serializer.
/// </summary>
/// <param name="options">EasyCachingOptions</param>
/// <returns>EasyCachingOptions</returns>
public static EasyCachingOptions WithCompressor(this EasyCachingOptions options)
{
var optionsExtension = new EasyCompressorEasyCachingOptionsExtension();
options.RegisterExtension(optionsExtension);
return(options);
}
protected override void SetupCachingProvider(EasyCachingOptions options, Action <BaseProviderOptions> additionalSetup)
{
options.UseInMemory(providerOptions =>
{
providerOptions.MaxRdSecond = 0;
additionalSetup(providerOptions);
});
}
protected override void SetupCachingProvider(EasyCachingOptions options, Action <BaseProviderOptions> additionalSetup)
{
options.UseMemcached(providerOptions =>
{
providerOptions.DBConfig.AddServer("127.0.0.1", 11211);
additionalSetup(providerOptions);
});
}
/// <summary>
/// Withs the CAP bus.
/// </summary>
/// <returns>The CAP bus.</returns>
/// <param name="options">Options.</param>
/// <param name="configure">Configure.</param>
public static EasyCachingOptions WithCapBus(this EasyCachingOptions options, Action <CapBusOptions> configure)
{
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
options.RegisterExtension(new CapBusOptionsExtension(configure));
return(options);
}
/// <summary>
/// Uses the SQLite.
/// </summary>
/// <returns>The SQL ite.</returns>
/// <param name="options">Options.</param>
/// <param name="configure">Configure.</param>
/// <param name="name">Name.</param>
public static EasyCachingOptions UseSQLite(this EasyCachingOptions options, Action<SQLiteOptions> configure, string name = EasyCachingConstValue.DefaultSQLiteName)
{
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
options.RegisterExtension(new SQLiteOptionsExtension(name, configure));
return options;
}
/// <summary>
/// Withs the RabbitMQ bus (specify the config via hard code).
/// </summary>
/// <param name="options">Options.</param>
/// <param name="configure">Configure bus settings.</param>
public static EasyCachingOptions WithRabbitMQBus(
this EasyCachingOptions options
, Action <RabbitMQBusOptions> configure
)
{
ArgumentCheck.NotNull(configure, nameof(configure));
options.RegisterExtension(new RabbitMQBusOptionsExtension(configure));
return(options);
}
/// <summary>
/// Uses the redis.
/// </summary>
/// <returns>The redis.</returns>
/// <param name="options">Options.</param>
/// <param name="configure">Configure.</param>
/// <param name="name">Name.</param>
public static EasyCachingOptions UseRedis(this EasyCachingOptions options, Action <RedisOptions> configure, string name = EasyCachingConstValue.DefaultRedisName)
{
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
options.RegisterExtension(new RedisOptionsExtension(name, configure));
return(options);
}
/// <summary>
/// Uses the memcached.
/// </summary>
/// <returns>The memcached.</returns>
/// <param name="options">Options.</param>
/// <param name="configure">Configure.</param>
/// <param name="name">Name.</param>
public static EasyCachingOptions UseMemcached(this EasyCachingOptions options, Action <MemcachedOptions> configure, string name = "")
{
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
options.RegisterExtension(new MemcachedOptionsExtension(name, configure));
return(options);
}
/// <summary>
/// Uses the hybrid (specify the config via hard code).
/// </summary>
/// <param name="options">Options.</param>
/// <param name="configure">Configure.</param>
/// <param name="name">The name of this hybrid provider instance.</param>
public static EasyCachingOptions UseHybrid(
this EasyCachingOptions options
, Action <HybridCachingOptions> configure
, string name = EasyCachingConstValue.DefaultHybridName
)
{
options.RegisterExtension(new HybridCacheOptionsExtension(name, configure));
return(options);
}
private void UseHybrid(EasyCachingOptions x)
{
x.UseHybrid(options =>
{
options.EnableLogging = false;
options.TopicName = "test_topic";
options.LocalCacheProviderName = LocalCacheProviderName;
options.DistributedCacheProviderName = DistributedCacheProviderName;
options.DefaultExpirationForTtlFailed = 60;
});
}
protected override void SetupCachingProvider(EasyCachingOptions options, Action <BaseProviderOptions> additionalSetup)
{
options.UseLiteDB(providerOptions =>
{
providerOptions.DBConfig = new LiteDBDBOptions
{
FileName = "s1.ldb"
};
additionalSetup(providerOptions);
});
}
/// <summary>
/// Withs the message pack serializer.
/// </summary>
/// <param name="options">Options.</param>
/// <param name="name">The name of this serializer instance.</param>
public static EasyCachingOptions WithMessagePack(this EasyCachingOptions options, string name = "msgpack")
{
Action <EasyCachingMsgPackSerializerOptions> action = x =>
{
x.EnableCustomResolver = false;
};
options.RegisterExtension(new MessagePackOptionsExtension(name, action));
return(options);
}
protected override void SetupCachingProvider(EasyCachingOptions options, Action <BaseProviderOptions> additionalSetup)
{
options.UseDisk(providerOptions =>
{
providerOptions.MaxRdSecond = 0;
providerOptions.DBConfig = new DiskDbOptions
{
BasePath = Path.GetTempPath()
};
additionalSetup(providerOptions);
});
}
public static EasyCachingOptions UseDistributedLock <T>(this EasyCachingOptions options)
where T : class, IDistributedLockFactory
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
options.RegisterExtension(new DistributedLockOptionsExtension <T>());
return(options);
}
protected override void SetupCachingProvider(EasyCachingOptions options, Action <BaseProviderOptions> additionalSetup)
{
options.UseRedis(providerOptions =>
{
providerOptions.DBConfig = new RedisDBOptions
{
AllowAdmin = true
};
providerOptions.DBConfig.Endpoints.Add(new ServerEndPoint("127.0.0.1", 6380));
providerOptions.DBConfig.Database = 5;
additionalSetup(providerOptions);
});
}
protected override void SetupCachingProvider(EasyCachingOptions options, Action <BaseProviderOptions> additionalSetup)
{
options.UseSQLite(providerOptions =>
{
providerOptions.DBConfig = new SQLiteDBOptions
{
FileName = "s1.db",
CacheMode = Microsoft.Data.Sqlite.SqliteCacheMode.Default,
OpenMode = Microsoft.Data.Sqlite.SqliteOpenMode.Memory,
};
additionalSetup(providerOptions);
});
}
/// <summary>
/// Uses the in memory.
/// </summary>
/// <returns>The in memory.</returns>
/// <param name="options">Options.</param>
/// <param name="name">Name.</param>
public static EasyCachingOptions UseInMemory(this EasyCachingOptions options, string name = EasyCachingConstValue.DefaultInMemoryName)
{
var option = new InMemoryOptions();
void configure(InMemoryOptions x)
{
x.EnableLogging = option.EnableLogging;
x.MaxRdSecond = option.MaxRdSecond;
x.DBConfig = option.DBConfig;
}
return(options.UseInMemory(configure, name));
}
public static EasyCachingOptions WithFakeBus(
this EasyCachingOptions options,
Action <FakeBusOptions> configure,
string name = FakeBusOptions.DefaultName)
{
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
options.RegisterExtension(new FakeBusOptionsExtensions(name, configure));
return(options);
}
/// <summary>
/// Withs the redis bus.
/// </summary>
/// <returns>The redis bus.</returns>
/// <param name="options">Options.</param>
/// <param name="configuration">Configuration.</param>
/// <param name="sectionName">Section name.</param>
public static EasyCachingOptions WithCSRedisBus(this EasyCachingOptions options, IConfiguration configuration, string sectionName = EasyCachingConstValue.RedisBusSection)
{
var dbConfig = configuration.GetSection(sectionName);
var redisOptions = new CSRedisBusOptions();
dbConfig.Bind(redisOptions);
void configure(CSRedisBusOptions x)
{
x.ConnectionStrings = redisOptions.ConnectionStrings;
}
options.RegisterExtension(new CSRedisOptionsExtension(configure));
return(options);
}
