/// <summary>
/// Adds a <see cref="BucketCacheHandle{TCacheValue}"/> with the required name.
/// <para>
/// This handle requires a Couchbase <see cref="ClientConfiguration"/> to be defined with
/// the <paramref name="couchbaseConfigurationKey"/> matching the configuration's key.
/// </para>
/// </summary>
/// <param name="part">The builder part.</param>
/// <param name="couchbaseConfigurationKey">
/// The Couchbase configuration identifier will be used as name for the cache handle and to
/// retrieve the connection configuration.
/// </param>
/// <param name="bucketName">
/// The name of the Couchbase bucket which should be used by the cache handle.
/// </param>
/// <param name="isBackplaneSource">
/// Set this to true if this cache handle should be the source of the backplane.
/// <para>This setting will be ignored if no backplane is configured.</para>
/// </param>
/// <returns>The part.</returns>
/// <exception cref="System.ArgumentNullException">If bucketName is null.</exception>
/// <exception cref="ArgumentNullException">
/// Thrown if handleName or handleType are null.
/// </exception>
public static ConfigurationBuilderCacheHandlePart WithCouchbaseCacheHandle(this ConfigurationBuilderCachePart part, string couchbaseConfigurationKey, string bucketName, bool isBackplaneSource)
{
NotNull(part, nameof(part));
NotNullOrWhiteSpace(bucketName, nameof(bucketName));
return(part.WithHandle(typeof(BucketCacheHandle <>), couchbaseConfigurationKey + ":" + bucketName, isBackplaneSource));
}
/// <summary>
/// Adds a <see cref="MemcachedCacheHandle{TCacheValue}"/> using the <paramref name="clientConfiguration"/> to setup a <see cref="MemcachedClient"/> instance.
/// </summary>
/// <param name="part">The builder part.</param>
/// <param name="clientConfiguration">The <see cref="MemcachedClientConfiguration"/> to use to create the <see cref="MemcachedClient"/> for this cache handle.</param>
/// <param name="isBackplaneSource">
/// Set this to true if this cache handle should be the source of the backplane.
/// <para>This setting will be ignored if no backplane is configured.</para>
/// </param>
/// <returns>The part.</returns>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="clientConfiguration"/> is null.
/// </exception>
public static ConfigurationBuilderCacheHandlePart WithMemcachedCacheHandle(this ConfigurationBuilderCachePart part, MemcachedClientConfiguration clientConfiguration, bool isBackplaneSource = true)
{
NotNull(part, nameof(part));
NotNull(clientConfiguration, nameof(clientConfiguration));
return(part.WithHandle(typeof(MemcachedCacheHandle <>), Guid.NewGuid().ToString(), isBackplaneSource, clientConfiguration));
}
/// <summary>
/// Add a <see cref="RedisCacheHandle"/> with the required name.
/// <para>
/// This handle requires a redis configuration to be defined with the
/// <paramref name="redisConfigurationId"/> matching the configuration's id.
/// </para>
/// </summary>
/// <param name="part">The builder part.</param>
/// <param name="redisConfigurationId">
/// The redis configuration identifier will be used as name for the cache handle and to
/// retrieve the connection configuration.
/// </param>
/// <param name="isBackPlateSource">
/// Set this to true if this cache handle should be the source of the back plate.
/// <para>This setting will be ignored if no back plate is configured.</para>
/// </param>
/// <returns>The part.</returns>
/// <exception cref="ArgumentNullException">
/// Thrown if handleName or handleType are null.
/// </exception>
public static ConfigurationBuilderCacheHandlePart WithRedisCacheHandle(this ConfigurationBuilderCachePart part, string redisConfigurationId, bool isBackPlateSource)
{
if (part == null)
{
throw new ArgumentNullException("part");
}
return(part.WithHandle(typeof(RedisCacheHandle <>), redisConfigurationId, isBackPlateSource));
}
/// <summary>
/// Add a <see cref="MemcachedCacheHandle"/> with the required name.
/// </summary>
/// <param name="part">The builder part.</param>
/// <param name="handleName">The name to be used for the cache handle.</param>
/// <param name="isBackPlateSource">
/// Set this to true if this cache handle should be the source of the back plate.
/// <para>This setting will be ignored if no back plate is configured.</para>
/// </param>
/// <returns>The part.</returns>
/// <exception cref="ArgumentNullException">
/// Thrown if handleName or handleType are null.
/// </exception>
public static ConfigurationBuilderCacheHandlePart WithMemcachedCacheHandle(this ConfigurationBuilderCachePart part, string handleName, bool isBackPlateSource)
{
if (part == null)
{
throw new ArgumentNullException("part");
}
return(part.WithHandle(typeof(MemcachedCacheHandle <>), handleName, isBackPlateSource));
}
/// <summary>
/// Adds a <see cref="BucketCacheHandle{TCacheValue}"/> with the required name.
/// <para>
/// This handle requires a Couchbase <see cref="ClientConfiguration"/> to be defined with
/// the <paramref name="couchbaseConfigurationKey"/> matching the configuration's key.
/// </para>
/// </summary>
/// <param name="part">The builder part.</param>
/// <param name="couchbaseConfigurationKey">
/// The Couchbase configuration identifier will be used as name for the cache handle and to
/// retrieve the connection configuration.
/// </param>
/// <param name="isBackPlateSource">
/// Set this to true if this cache handle should be the source of the back plate.
/// <para>This setting will be ignored if no back plate is configured.</para>
/// </param>
/// <returns>The part.</returns>
/// <exception cref="ArgumentNullException">
/// Thrown if handleName or handleType are null.
/// </exception>
public static ConfigurationBuilderCacheHandlePart WithCouchbaseCacheHandle(
this ConfigurationBuilderCachePart part,
string couchbaseConfigurationKey,
bool isBackPlateSource)
{
NotNull(part, nameof(part));
return(part.WithHandle(typeof(BucketCacheHandle <>), couchbaseConfigurationKey, isBackPlateSource));
}
/// <summary>
/// Add a <see cref="BucketCacheHandle"/> with the required name.
/// <para>
/// This handle requires a Couchbase <see cref="ClientConfiguration"/> to be defined with
/// the <paramref name="couchbaseConfigurationKey"/> matching the configuration's key.
/// </para>
/// </summary>
/// <param name="part">The builder part.</param>
/// <param name="couchbaseConfigurationKey">
/// The Couchbase configuration identifier will be used as name for the cache handle and to
/// retrieve the connection configuration.
/// </param>
/// <param name="isBackPlateSource">
/// Set this to true if this cache handle should be the source of the back plate.
/// <para>This setting will be ignored if no back plate is configured.</para>
/// </param>
/// <returns>The part.</returns>
/// <exception cref="ArgumentNullException">
/// Thrown if handleName or handleType are null.
/// </exception>
public static ConfigurationBuilderCacheHandlePart WithCouchbaseCacheHandle(this ConfigurationBuilderCachePart part, string couchbaseConfigurationKey, bool isBackPlateSource)
{
if (part == null)
{
throw new ArgumentNullException("part");
}
return(part.WithHandle(typeof(BucketCacheHandle <>), couchbaseConfigurationKey, isBackPlateSource));
}
/// <summary>
/// Adds a <see cref="BucketCacheHandle{TCacheValue}" /> using the configuration referenced via <paramref name="couchbaseConfigurationKey" />.
/// <para>
/// The cache handle needs configuration specific to Couchbase, see remarks for details.
/// </para>
/// </summary>
/// <param name="part">The builder part.</param>
/// <param name="couchbaseConfigurationKey">The configuration identifier.</param>
/// <param name="bucketName">The name of the Couchbase bucket which should be used by the cache handle.</param>
/// <param name="isBackplaneSource">Set this to <c>true</c> if this cache handle should be the source of the backplane. This setting will be ignored if no backplane is configured.</param>
/// <returns>
/// The part.
/// </returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="bucketName" /> or <paramref name="couchbaseConfigurationKey" /> is null.</exception>
/// <remarks>
/// The Couchbase cache handle requires configuration which can be defined via:
/// <list type="bullet"><item>
/// <term>
/// A configuration with a matching <paramref name="couchbaseConfigurationKey" /> being added via <see cref="WithCouchbaseConfiguration(ConfigurationBuilderCachePart, string, ClientConfiguration)" />.
/// </term></item>
/// <item><term>
/// A cluster with a matching <paramref name="couchbaseConfigurationKey" /> being added via <see cref="WithCouchbaseCluster(ConfigurationBuilderCachePart, string, ICluster)" />.
/// </term></item>
/// <item><term>
/// A <c>CouchbaseClientSection</c> configured in <c>App/Web.config</c> (only available on full .NET Framework).
/// </term></item>
/// <item><term>
/// Or, the cluster has been configured via <see cref="ClusterHelper" /> and CacheManager will use the cluster returned by <see cref="ClusterHelper.Get" />.
/// Anyways, this will be the last fallback which, if nothing has been configured at all, will fall back to the default server endpoint on <c>127.0.0.1:8091</c>.
/// </term></item>
/// </list>
/// <para>
/// If your cluster requires authentication, use either the <see cref="ClusterHelper" /> or add a <see cref="ICluster" /> with valid authentication via <c>cluster.Authenticate(...)</c>.
/// </para>
/// </remarks>
public static ConfigurationBuilderCacheHandlePart WithCouchbaseCacheHandle(
this ConfigurationBuilderCachePart part,
string couchbaseConfigurationKey,
string bucketName = CouchbaseConfigurationManager.DefaultBucketName,
bool isBackplaneSource = true)
{
NotNull(part, nameof(part));
NotNullOrWhiteSpace(bucketName, nameof(bucketName));
return(part.WithHandle(typeof(BucketCacheHandle <>), couchbaseConfigurationKey, isBackplaneSource, new BucketCacheHandleAdditionalConfiguration()
{
BucketName = bucketName
}));
}
/// <summary>
/// Add a <see cref="BucketCacheHandle"/> with the required name.
/// <para>
/// This handle requires a Couchbase <see cref="ClientConfiguration"/> to be defined with
/// the <paramref name="couchbaseConfigurationKey"/> matching the configuration's key.
/// </para>
/// </summary>
/// <param name="part">The builder part.</param>
/// <param name="couchbaseConfigurationKey">
/// The Couchbase configuration identifier will be used as name for the cache handle and to
/// retrieve the connection configuration.
/// </param>
/// <param name="bucketName">
/// The name of the Couchbase bucket which should be used by the cache handle.
/// </param>
/// <param name="isBackPlateSource">
/// Set this to true if this cache handle should be the source of the back plate.
/// <para>This setting will be ignored if no back plate is configured.</para>
/// </param>
/// <returns>The part.</returns>
/// <exception cref="System.ArgumentNullException">If bucketName is null.</exception>
/// <exception cref="ArgumentNullException">
/// Thrown if handleName or handleType are null.
/// </exception>
public static ConfigurationBuilderCacheHandlePart WithCouchbaseCacheHandle(this ConfigurationBuilderCachePart part, string couchbaseConfigurationKey, string bucketName, bool isBackPlateSource)
{
if (part == null)
{
throw new ArgumentNullException("part");
}
if (string.IsNullOrWhiteSpace(bucketName))
{
throw new ArgumentNullException("bucketName");
}
return(part.WithHandle(typeof(BucketCacheHandle <>), couchbaseConfigurationKey + ":" + bucketName, isBackPlateSource));
}
/// <summary>
/// Adds a <see cref="MemcachedCacheHandle{TCacheValue}"/>. The <paramref name="configurationName"/> must match with cache configured via enyim configuration section.
/// </summary>
/// <param name="part">The builder part.</param>
/// <param name="configurationName">The configuration name.</param>
/// <param name="isBackPlateSource">
/// Set this to true if this cache handle should be the source of the back plate.
/// <para>This setting will be ignored if no back plate is configured.</para>
/// </param>
/// <returns>The part.</returns>
/// <exception cref="ArgumentNullException">
/// Thrown if handleName or handleType are null.
/// </exception>
public static ConfigurationBuilderCacheHandlePart WithMemcachedCacheHandle(this ConfigurationBuilderCachePart part, string configurationName, bool isBackPlateSource)
{
NotNull(part, nameof(part));
return(part.WithHandle(typeof(MemcachedCacheHandle <>), configurationName, isBackPlateSource));
}
/// <summary>
/// Adds a <see cref="MemcachedCacheHandle{TCacheValue}"/>. The <paramref name="configurationName"/> must match with cache configured via enyim configuration section.
/// </summary>
/// <param name="part">The builder part.</param>
/// <param name="configurationName">The configuration name.</param>
/// <param name="client">The <see cref="MemcachedClient"/> to use for this cache handle.</param>
/// <param name="isBackplaneSource">
/// Set this to true if this cache handle should be the source of the backplane.
/// <para>This setting will be ignored if no backplane is configured.</para>
/// </param>
/// <returns>The part.</returns>
/// <exception cref="System.ArgumentNullException">
/// Thrown if <paramref name="client"/> is null.
/// </exception>
public static ConfigurationBuilderCacheHandlePart WithMemcachedCacheHandle(this ConfigurationBuilderCachePart part, string configurationName, MemcachedClient client, bool isBackplaneSource = true)
{
NotNull(part, nameof(part));
return(part.WithHandle(typeof(MemcachedCacheHandle <>), configurationName, isBackplaneSource, client));
}
/// <summary>
/// Adds a <see cref="RedisCacheHandle{TCacheValue}"/>.
/// This handle requires a redis configuration to be defined with the given <paramref name="redisConfigurationKey"/>.
/// </summary>
/// <param name="part">The builder instance.</param>
/// <param name="redisConfigurationKey">
/// The redis configuration key will be used to find a matching redis connection configuration.
/// </param>
/// <param name="isBackPlateSource">
/// Set this to true if this cache handle should be the source of the back plate.
/// This setting will be ignored if no back plate is configured.
/// </param>
/// <returns>The builder instance.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="redisConfigurationKey"/> is null.</exception>
public static ConfigurationBuilderCacheHandlePart WithRedisCacheHandle(this ConfigurationBuilderCachePart part, string redisConfigurationKey, bool isBackPlateSource)
{
NotNull(part, nameof(part));
return(part.WithHandle(typeof(RedisCacheHandle <>), redisConfigurationKey, isBackPlateSource));
}
/// <summary>
/// Adds a <see cref="MemoryCacheHandle{TCacheValue}" /> using a <see cref="System.Runtime.Caching.MemoryCache"/> instance with the given <paramref name="instanceName"/>.
/// The named cache instance can be configured via <c>app/web.config</c> <c>system.runtime.caching</c> section.
/// </summary>
/// <param name="part">The builder part.</param>
/// <param name="instanceName">The name to be used for the cache instance.</param>
/// <param name="isBackPlateSource">Set this to true if this cache handle should be the source of the back plate.
/// This setting will be ignored if no back plate is configured.</param>
/// <returns>
/// The builder part.
/// </returns>
/// <exception cref="System.ArgumentNullException">If part is null.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="instanceName"/> is null.</exception>
public static ConfigurationBuilderCacheHandlePart WithSystemRuntimeCacheHandle(this ConfigurationBuilderCachePart part, string instanceName, bool isBackPlateSource)
=> part?.WithHandle(typeof(MemoryCacheHandle <>), instanceName, isBackPlateSource);
/// <summary>
/// Adds a <see cref="MemoryCacheHandle{TCacheValue}" /> using a <see cref="System.Runtime.Caching.MemoryCache"/>.
/// The name of the cache instance will be 'default'.
/// </summary>
/// <param name="part">The builder part.</param>
/// <returns>The builder part.</returns>
public static ConfigurationBuilderCacheHandlePart WithSystemRuntimeCacheHandle(this ConfigurationBuilderCachePart part)
=> part?.WithHandle(typeof(MemoryCacheHandle <>), DefaultName, false);
public static ConfigurationBuilderCacheHandlePart WithAppFabricCacheHandle(this ConfigurationBuilderCachePart part, string handleName, bool isBackPlateSource)
{
return(part.WithHandle(typeof(AppFabricCacheHandle <>), handleName, isBackPlateSource));
}
/// <summary>
/// Adds a <see cref="MemoryCacheHandle{TCacheValue}" /> using a <see cref="System.Runtime.Caching.MemoryCache"/>.
/// </summary>
/// <param name="part">The builder part.</param>
/// <returns>The builder part.</returns>
public static ConfigurationBuilderCacheHandlePart WithSystemRuntimeCacheHandle(this ConfigurationBuilderCachePart part)
=> part?.WithHandle(typeof(MemoryCacheHandle <>), Guid.NewGuid().ToString("N"), false);
/// <summary>
/// Adds a <see cref="SystemWebCacheHandle{TCacheValue}" /> to the cache manager.
/// This handle uses <c>System.Web.Caching.Cache</c> and requires <c>HttpContext.Current</c> to be not null.
/// </summary>
/// <param name="part">The builder part.</param>
/// <param name="instanceName">The name to be used for the cache handle instance.</param>
/// <param name="isBackplaneSource">Set this to true if this cache handle should be the source of the backplane.
/// This setting will be ignored if no backplane is configured.</param>
/// <returns>
/// The builder part.
/// </returns>
/// <exception cref="System.ArgumentNullException">If part is null.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="instanceName"/> is null.</exception>
public static ConfigurationBuilderCacheHandlePart WithSystemWebCacheHandle(this ConfigurationBuilderCachePart part, string instanceName, bool isBackplaneSource)
=> part?.WithHandle(typeof(SystemWebCacheHandle <>), instanceName, isBackplaneSource);
/// <summary>
/// Adds a <see cref="MemoryCacheHandle{TCacheValue}" /> using a <see cref="Microsoft.Extensions.Caching.Memory"/> instance with the given <paramref name="instanceName"/>.
/// </summary>
/// <param name="part">The builder part.</param>
/// <param name="instanceName">The name to be used for the cache instance.</param>
/// <param name="isBackplaneSource">Set this to true if this cache handle should be the source of the backplane.
/// This setting will be ignored if no backplane is configured.</param>
/// <returns>
/// The builder part.
/// </returns>
/// <exception cref="System.ArgumentNullException">If part is null.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="instanceName"/> is null.</exception>
public static ConfigurationBuilderCacheHandlePart WithMicrosoftMemoryCacheHandle(
this ConfigurationBuilderCachePart part, string instanceName, bool isBackplaneSource)
=> part?.WithHandle(typeof(MemoryCacheHandle <>), instanceName, isBackplaneSource);
public static ConfigurationBuilderCacheHandlePart WithSystemRuntimeCacheHandle(this ConfigurationBuilderCachePart part, string handleName, bool isBackPlateSource)
{
return(part.WithHandle(typeof(MemoryCacheHandle <>), handleName, isBackPlateSource));
}
public static ConfigurationBuilderCacheHandlePart WithFileCacheHandle(this ConfigurationBuilderCachePart part, SerializationBinder binder, bool calculateCacheSize = false, TimeSpan cleanInterval = new TimeSpan())
=> part?.WithHandle(typeof(FileCacheHandle <>), DefaultCacheName, false, new FileCacheHandleAdditionalConfiguration {
SerializationBinder = binder, CalculateCacheSize = calculateCacheSize, CleanInterval = cleanInterval
});
/// <summary>
/// Adds a <see cref="FileCacheHandle{TCacheValue}" /> using a <see cref="System.Runtime.Caching.FileCache"/> instance with the given <paramref name="instanceName"/>.
/// The named cache instance can be configured via <c>app/web.config</c> <c>system.runtime.caching</c> section.
/// </summary>
/// <param name="part">The builder part.</param>
/// <param name="cacheRoot">The name to be used for the cache instance.</param>
/// <param name="calculateCacheSize">A flag indicating whether or not to calculate the cache size on initialization</param>
/// <param name="cleanInterval">If supplied, sets the interval of time that must occur between self cleans</param>
/// <returns>
/// The builder part.
/// </returns>
/// <exception cref="System.ArgumentNullException">Thrown if <paramref name="part"/> is null.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="cacheRoot"/> is null.</exception>
public static ConfigurationBuilderCacheHandlePart WithFileCacheHandle(this ConfigurationBuilderCachePart part, string cacheRoot, bool calculateCacheSize = false, TimeSpan cleanInterval = new TimeSpan())
=> part?.WithHandle(typeof(FileCacheHandle <>), cacheRoot, false, new FileCacheHandleAdditionalConfiguration {
CalculateCacheSize = calculateCacheSize, CleanInterval = cleanInterval
});
/// <summary>
/// Adds a <see cref="MemoryCacheHandle{TCacheValue}" /> using a <see cref="System.Runtime.Caching.MemoryCache"/>.
/// The name of the cache instance will be 'default'.
/// </summary>
/// <param name="part">The builder part.</param>
/// <param name="isBackplaneSource">Set this to true if this cache handle should be the source of the backplane.
/// This setting will be ignored if no backplane is configured.</param>
/// <returns>
/// The builder part.
/// </returns>
/// <returns>The builder part.</returns>
public static ConfigurationBuilderCacheHandlePart WithSystemRuntimeCacheHandle(this ConfigurationBuilderCachePart part, bool isBackplaneSource = false)
=> part?.WithHandle(typeof(MemoryCacheHandle <>), DefaultName, isBackplaneSource);
