private static void ApplyCachingProvider(CachingProviderType cachingProvider, RepositoryOptionsBuilder builder)
{
switch (cachingProvider)
{
case CachingProviderType.MicrosoftInMemory:
{
builder.UseCachingProvider(new InMemoryCacheProvider());
break;
}
case CachingProviderType.Redis:
{
var redis = new RedisCacheProvider(allowAdmin: true, defaultDatabase: 0, expiry: null);
redis.Server.FlushAllDatabases();
builder.UseCachingProvider(redis);
break;
}
default:
throw new ArgumentOutOfRangeException(nameof(cachingProvider));
}
}
private static void ApplyCachingProvider(CachingProviderType cachingProvider, RepositoryOptionsBuilder builder)
{
switch (cachingProvider)
{
case CachingProviderType.MicrosoftInMemory:
{
builder.UseCachingProvider(new InMemoryCacheProvider());
break;
}
case CachingProviderType.Redis:
{
var provider = new RedisCacheProvider(allowAdmin: true, defaultDatabase: 0, expiry: null);
provider.Cache.Server.FlushAllDatabases();
builder.UseCachingProvider(provider);
break;
}
case CachingProviderType.Memcached:
{
var provider = new MemcachedCacheProvider("127.0.0.1", 11211);
provider.Cache.Client.FlushAll();
builder.UseCachingProvider(provider);
break;
}
case CachingProviderType.Couchbase:
{
var provider = new CouchbaseCacheProvider("http://localhost:8091", "default", "password");
using (var bucket = provider.Cache.Cluster.OpenBucket())
{
bucket.CreateManager("default", "password").Flush();
}
builder.UseCachingProvider(provider);
break;
}
default:
throw new ArgumentOutOfRangeException(nameof(cachingProvider));
}
}
/// <summary>
/// Configures the caching provider to use microsoft's in-memory cache.
/// </summary>
/// <param name="source">The repository options builder.</param>
/// <returns>The same builder instance.</returns>
public static RepositoryOptionsBuilder UseInMemoryCache([NotNull] this RepositoryOptionsBuilder source)
{
Guard.NotNull(source, nameof(source));
source.UseCachingProvider(new InMemoryCacheProvider());
return(source);
}
public void ConfigureCachingProvider()
{
var optionsBuilder = new RepositoryOptionsBuilder();
Assert.False(optionsBuilder.IsConfigured);
optionsBuilder.UseCachingProvider(new TestCacheProvider());
Assert.True(optionsBuilder.IsConfigured);
Assert.NotNull(optionsBuilder.Options.CachingProvider);
}
/// <summary>
/// Configures the caching provider to use the in-memory cache.
/// </summary>
/// <param name="source">The repository options builder.</param>
/// <param name="optionsAction">The options action.</param>
/// <returns>The same builder instance.</returns>
public static RepositoryOptionsBuilder UseInMemoryCache([NotNull] this RepositoryOptionsBuilder source, [NotNull] Action <InMemoryCacheOptions> optionsAction)
{
Guard.NotNull(source, nameof(source));
Guard.NotNull(optionsAction, nameof(optionsAction));
var options = new InMemoryCacheOptions();
optionsAction(options);
var provider = new InMemoryCacheProvider(
options.Clock,
options.ExpirationScanFrequency,
options.Expiry);
source.UseCachingProvider(provider);
return(source);
}
/// <summary>
/// Configures the caching provider to use couchbase.
/// </summary>
/// <param name="source">The repository options builder.</param>
/// <param name="optionsAction">The options action.</param>
/// <returns>The same builder instance.</returns>
public static RepositoryOptionsBuilder UseCouchbase([NotNull] this RepositoryOptionsBuilder source, [NotNull] Action <CouchbaseCacheOptions> optionsAction)
{
Guard.NotNull(source, nameof(source));
Guard.NotNull(optionsAction, nameof(optionsAction));
var options = new CouchbaseCacheOptions();
optionsAction(options);
var provider = new CouchbaseCacheProvider(
options.Host,
options.BucketName,
options.Username,
options.Password,
options.Expiry,
options.Serializer);
source.UseCachingProvider(provider);
return(source);
}
/// <summary>
/// Configures the caching provider to use memcached.
/// </summary>
/// <param name="source">The repository options builder.</param>
/// <param name="optionsAction">The options action.</param>
/// <returns>The same builder instance.</returns>
public static RepositoryOptionsBuilder UseMemcached([NotNull] this RepositoryOptionsBuilder source, [NotNull] Action <MemcachedCacheOptions> optionsAction)
{
Guard.NotNull(source, nameof(source));
Guard.NotNull(optionsAction, nameof(optionsAction));
var options = new MemcachedCacheOptions();
optionsAction(options);
var provider = new MemcachedCacheProvider(
options.Host,
options.Username,
options.Password,
options.Protocal,
options.AuthenticationType,
options.Expiry,
options.SerializerSettings);
source.UseCachingProvider(provider);
return(source);
}
/// <summary>
/// Configures the caching provider to use redis.
/// </summary>
/// <param name="source">The repository options builder.</param>
/// <param name="optionsAction">The options action.</param>
/// <returns>The same builder instance.</returns>
public static RepositoryOptionsBuilder UseRedis([NotNull] this RepositoryOptionsBuilder source, [NotNull] Action <RedisCacheOptions> optionsAction)
{
Guard.NotNull(source, nameof(source));
Guard.NotNull(optionsAction, nameof(optionsAction));
var options = new RedisCacheOptions();
optionsAction(options);
var provider = new RedisCacheProvider(
options.Host,
options.Username,
options.Password,
options.Ssl,
options.AllowAdmin,
options.DefaultDatabase,
options.Expiry,
options.SerializerSettings);
source.UseCachingProvider(provider);
return(source);
}
