Esempio n. 1
0
        /// <summary>
        /// Configures cache manager logging to use a <c>Microsoft.Extensions.Logging.ILoggerFactory</c>
        /// which gets resolved from the <paramref name="serviceCollection"/>.
        /// </summary>
        /// <param name="part">The builder part.</param>
        /// <param name="serviceCollection">The services collection.</param>
        /// <returns>The builder.</returns>
        public static ConfigurationBuilderCachePart WithMicrosoftLogging(this ConfigurationBuilderCachePart part, IServiceCollection serviceCollection)
        {
            NotNull(part, nameof(part));
            NotNull(serviceCollection, nameof(serviceCollection));

            return(part.WithLogging(typeof(MicrosoftLoggerFactoryAdapter), new Func <ILoggerFactory>(() => GetLoggerFactory(serviceCollection))));
        }
Esempio n. 2
0
        /// <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));
        }
Esempio n. 4
0
        /// <summary>
        /// Adds an already configured <see cref="ICluster" /> for the given key. Use this in case you want to use the <paramref name="cluster" /> outside of CacheManager, too
        /// and you want to share this instance.
        /// <para>
        /// Use <paramref name="configurationKey" /> in <see cref="WithCouchbaseCacheHandle(ConfigurationBuilderCachePart, string, string, bool)" /> (or similar overloads)
        /// to have the cache handle use this configuration.
        /// </para><para>
        /// If your cluster requires authentication, you might have to configure <c>cluster.Authenticate(...)</c>.
        /// </para>
        /// </summary>
        /// <param name="part">The part.</param>
        /// <param name="configurationKey">The configuration key.</param>
        /// <param name="cluster">The <see cref="ICluster" />.</param>
        /// <returns>
        /// The configuration builder.
        /// <exception cref="System.ArgumentNullException">If <paramref name="configurationKey" /> or <paramref name="cluster" /> is null.</exception>
        /// </returns>
        public static ConfigurationBuilderCachePart WithCouchbaseCluster(this ConfigurationBuilderCachePart part, string configurationKey, ICluster cluster)
        {
            NotNullOrWhiteSpace(configurationKey, nameof(configurationKey));
            NotNull(cluster, nameof(cluster));

            CouchbaseConfigurationManager.AddCluster(configurationKey, cluster);
            return(part);
        }
Esempio n. 5
0
        /// <summary>
        /// Adds a <see cref="ClientConfiguration"/> for the given key.
        /// <para>The key will be matched with the Couchbase cache handle name.</para>
        /// </summary>
        /// <param name="part">The part.</param>
        /// <param name="configurationKey">The key which has to match with the cache handle name.</param>
        /// <param name="config">The Couchbase configuration object.</param>
        /// <returns>The configuration builder.</returns>
        /// <exception cref="System.ArgumentNullException">If key or config are null.</exception>
        public static ConfigurationBuilderCachePart WithCouchbaseConfiguration(this ConfigurationBuilderCachePart part, string configurationKey, ClientConfiguration config)
        {
            NotNullOrWhiteSpace(configurationKey, nameof(configurationKey));
            NotNull(config, nameof(config));

            CouchbaseConfigurationManager.AddConfiguration(configurationKey, config);
            return(part);
        }
        /// <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>
        /// Adds a redis configuration with the given <paramref name="configurationKey"/>.
        /// </summary>
        /// <param name="part">The builder instance.</param>
        /// <param name="configurationKey">
        /// The configuration key which can be used to refernce this configuration by a redis cache handle or backplate.
        /// </param>
        /// <param name="connectionString">The redis connection string.</param>
        /// <returns>The configuration builder.</returns>
        /// <exception cref="System.ArgumentNullException">
        /// If <paramref name="configurationKey"/> or <paramref name="connectionString"/> are null.
        /// </exception>
        public static ConfigurationBuilderCachePart WithRedisConfiguration(this ConfigurationBuilderCachePart part, string configurationKey, string connectionString)
        {
            NotNullOrWhiteSpace(configurationKey, nameof(configurationKey));

            NotNullOrWhiteSpace(connectionString, nameof(connectionString));

            RedisConfigurations.AddConfiguration(new RedisConfiguration(configurationKey, connectionString));
            return(part);
        }
        /// <summary>
        /// Configures the back plate for the cache manager.
        /// <para>
        /// The <paramref name="redisConfigurationId"/> is used to define the redis configuration,
        /// the back plate should use to connect to the redis server.
        /// </para>
        /// <para>
        /// If a back plate is defined, at least one cache handle must be marked as back plate
        /// source. The cache manager then will try to synchronize multiple instances of the same configuration.
        /// </para>
        /// </summary>
        /// <param name="part">The part.</param>
        /// <param name="redisConfigurationId">
        /// The id of the configuration the back plate should use.
        /// </param>
        /// <returns>The builder instance.</returns>
        public static ConfigurationBuilderCachePart WithRedisBackPlate(this ConfigurationBuilderCachePart part, string redisConfigurationId)
        {
            if (part == null)
            {
                throw new ArgumentNullException("part");
            }

            return(part.WithBackPlate <RedisCacheBackPlate>(redisConfigurationId));
        }
        /// <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));
        }
Esempio n. 10
0
        /// <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>
        /// 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));
        }
Esempio n. 12
0
        public static ConfigurationBuilderCachePart WithMicrosoftLogging(this ConfigurationBuilderCachePart part, Action <ILoggerFactory> factory)
        {
            NotNull(part, nameof(part));
            NotNull(factory, nameof(factory));
            var externalFactory = new LoggerFactory();

            factory(externalFactory);
            return(part.WithLogging(typeof(MicrosoftLoggerFactoryAdapter), externalFactory));
        }
        /// <summary>
        /// Adds a redis configuration with the given <paramref name="configurationKey"/>.
        /// </summary>
        /// <param name="part">The builder instance.</param>
        /// <param name="configurationKey">
        /// The configuration key which can be used to refernce this configuration by a redis cache handle or backplane.
        /// </param>
        /// <param name="connectionString">The redis connection string.</param>
        /// <param name="database">The redis database to be used.</param>
        /// <param name="enableKeyspaceNotifications">
        /// Enables keyspace notifications to react on eviction/expiration of items.
        /// Make sure that all servers are configured correctly and 'notify-keyspace-events' is at least set to 'Exe', otherwise CacheManager will not retrieve any events.
        /// See <see href="https://redis.io/topics/notifications#configuration"/> for configuration details.
        /// </param>
        /// <returns>The configuration builder.</returns>
        /// <exception cref="System.ArgumentNullException">
        /// If <paramref name="configurationKey"/> or <paramref name="connectionString"/> are null.
        /// </exception>
        public static ConfigurationBuilderCachePart WithRedisConfiguration(this ConfigurationBuilderCachePart part, string configurationKey, string connectionString, int database = 0, bool enableKeyspaceNotifications = false)
        {
            NotNullOrWhiteSpace(configurationKey, nameof(configurationKey));

            NotNullOrWhiteSpace(connectionString, nameof(connectionString));

            RedisConfigurations.AddConfiguration(new RedisConfiguration(configurationKey, connectionString, database, enableKeyspaceNotifications));
            return(part);
        }
        /// <summary>
        /// Builds a <c>CacheManagerConfiguration</c> which can be used to create a new cache
        /// manager instance.
        /// <para>
        /// Pass the configuration to <c>CacheFactory.FromConfiguration</c> to create a valid cache manager.
        /// </para>
        /// </summary>
        /// <param name="settings">
        /// The configuration settings to define the cache handles and other properties.
        /// </param>
        /// <returns>The <c>CacheManagerConfiguration</c>.</returns>
        public static CacheManagerConfiguration BuildConfiguration(Action <ConfigurationBuilderCachePart> settings)
        {
            NotNull(settings, nameof(settings));

            var part = new ConfigurationBuilderCachePart();

            settings(part);
            return(part.Configuration);
        }
Esempio n. 15
0
        /// <summary>
        /// <para>Instantiates a cache manager using the inline configuration defined by <paramref name="settings"/>.</para>
        /// </summary>
        /// <example>
        /// The following example show how to build a <c>CacheManagerConfiguration</c> and then
        /// using the <c>CacheFactory</c> to create a new cache manager instance.
        /// <code>
        /// <![CDATA[
        /// var cache = CacheFactory.Build("myCacheName", settings =>
        /// {
        ///    settings
        ///        .WithUpdateMode(CacheUpdateMode.Up)
        ///        .WithDictionaryHandle()
        ///            .EnablePerformanceCounters()
        ///            .WithExpiration(ExpirationMode.Sliding, TimeSpan.FromSeconds(10));
        /// });
        ///
        /// cache.Add("key", "value");
        /// ]]>
        /// </code>
        /// </example>
        /// <param name="cacheName">The name of the cache manager instance.</param>
        /// <param name="settings">
        /// The configuration. Use the settings element to configure the cache manager instance, add
        /// cache handles and also to configure the cache handles in a fluent way.
        /// </param>
        /// <typeparam name="TCacheValue">The type of the cache item value.</typeparam>
        /// <returns>The cache manager instance with cache item type being <c>TCacheValue</c>.</returns>
        /// <seealso cref="ICacheManager{TCacheValue}"/>
        /// <exception cref="System.ArgumentNullException">
        /// Thrown if the <paramref name="cacheName"/> or <paramref name="settings"/> is null.
        /// </exception>
        /// <exception cref="System.InvalidOperationException">
        /// Thrown on certain configuration errors related to the cache handles.
        /// </exception>
        public static ICacheManager <TCacheValue> Build <TCacheValue>(string cacheName, Action <ConfigurationBuilderCachePart> settings)
        {
            NotNull(settings, nameof(settings));

            var part = new ConfigurationBuilderCachePart();

            settings(part);
            return(new BaseCacheManager <TCacheValue>(cacheName, part.Configuration));
        }
        /// <summary>
        /// Adds a redis configuration with the given <paramref name="configurationKey"/>.
        /// </summary>
        /// <param name="part">The builder instance.</param>
        /// <param name="configurationKey">
        /// The configuration key which can be used to refernce this configuration by a redis cache handle or backplate.
        /// </param>
        /// <param name="configuration">The redis configuration object.</param>
        /// <returns>The configuration builder.</returns>
        /// <exception cref="System.ArgumentNullException">If <paramref name="configuration"/> or <paramref name="configurationKey"/> are null.</exception>
        public static ConfigurationBuilderCachePart WithRedisConfiguration(this ConfigurationBuilderCachePart part, string configurationKey, Action <RedisConfigurationBuilder> configuration)
        {
            NotNull(configuration, nameof(configuration));

            var builder = new RedisConfigurationBuilder(configurationKey);

            configuration(builder);
            RedisConfigurations.AddConfiguration(builder.Build());
            return(part);
        }
Esempio n. 17
0
        /// <summary>
        /// Builds a <see cref="CacheManagerConfiguration"/> which can be used to create a new cache
        /// manager instance.
        /// <para>
        /// Pass the configuration to <see cref="CacheFactory.FromConfiguration{TCacheValue}(CacheManagerConfiguration)"/>
        /// to create a valid cache manager.
        /// </para>
        /// </summary>
        /// <param name="name">The name of the cache manager.</param>
        /// <param name="settings">
        /// The configuration settings to define the cache handles and other properties.
        /// </param>
        /// <returns>The <see cref="CacheManagerConfiguration"/>.</returns>
        public static CacheManagerConfiguration BuildConfiguration(string name, Action <ConfigurationBuilderCachePart> settings)
        {
            NotNullOrWhiteSpace(name, nameof(name));
            NotNull(settings, nameof(settings));

            var part = new ConfigurationBuilderCachePart();

            settings(part);
            part.Configuration.Name = name;
            return(part.Configuration);
        }
Esempio n. 18
0
        /// <summary>
        /// Configures cache manager logging to use a <c>Microsoft.Extensions.Logging.ILoggerFactory</c>
        /// which gets resolved from the <paramref name="serviceCollection"/>.
        /// </summary>
        /// <param name="part">The builder part.</param>
        /// <param name="serviceCollection">The services collection.</param>
        /// <returns>The builder.</returns>
        public static ConfigurationBuilderCachePart WithMicrosoftLogging(this ConfigurationBuilderCachePart part, IServiceCollection serviceCollection)
        {
            NotNull(part, nameof(part));
            NotNull(serviceCollection, nameof(serviceCollection));

            var loggerFactory = GetLoggerFactory(serviceCollection);

            EnsureNotNull(loggerFactory, "No instance of ILoggerFactory found in {0}.", nameof(serviceCollection));

            return(WithMicrosoftLogging(part, loggerFactory));
        }
        /// <summary>
        /// Builds a <c>CacheManagerConfiguration</c> which can be used to create a new cache
        /// manager instance.
        /// <para>
        /// Pass the configuration to <c>CacheFactory.FromConfiguration</c> to create a valid cache manager.
        /// </para>
        /// </summary>
        /// <param name="settings">
        /// The configuration settings to define the cache handles and other properties.
        /// </param>
        /// <returns>The <c>CacheManagerConfiguration</c>.</returns>
        public static CacheManagerConfiguration BuildConfiguration(Action <ConfigurationBuilderCachePart> settings)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }

            var part = new ConfigurationBuilderCachePart();

            settings(part);
            return(part.Configuration);
        }
Esempio n. 20
0
        /// <summary>
        /// <para>Instantiates a cache manager using the inline configuration defined by <paramref name="settings"/>.</para>
        /// </summary>
        /// <example>
        /// The following example show how to build a <c>CacheManagerConfiguration</c> and then
        /// using the <c>CacheFactory</c> to create a new cache manager instance.
        /// <code>
        /// <![CDATA[
        /// var cache = CacheFactory.Build("myCacheName", settings =>
        /// {
        ///    settings
        ///        .WithUpdateMode(CacheUpdateMode.Up)
        ///        .WithHandle<DictionaryCacheHandle>("handle1")
        ///            .EnablePerformanceCounters()
        ///            .WithExpiration(ExpirationMode.Sliding, TimeSpan.FromSeconds(10));
        /// });
        ///
        /// cache.Add("key", "value");
        /// ]]>
        /// </code>
        /// </example>
        /// <param name="cacheName">The name of the cache manager instance.</param>
        /// <param name="settings">
        /// The configuration. Use the settings element to configure the cache manager instance, add
        /// cache handles and also to configure the cache handles in a fluent way.
        /// </param>
        /// <typeparam name="TCacheValue">The type of the cache item value.</typeparam>
        /// <returns>The cache manager instance with cache item type being <c>TCacheValue</c>.</returns>
        /// <seealso cref="ICacheManager{TCacheValue}"/>
        /// <exception cref="System.ArgumentNullException">
        /// Thrown if the <paramref name="cacheName"/> or <paramref name="settings"/> is null.
        /// </exception>
        /// <exception cref="System.InvalidOperationException">
        /// Thrown on certain configuration errors related to the cache handles.
        /// </exception>
        public static ICacheManager <TCacheValue> Build <TCacheValue>(string cacheName, Action <ConfigurationBuilderCachePart> settings)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }

            var part = new ConfigurationBuilderCachePart();

            settings(part);
            return(new BaseCacheManager <TCacheValue>(cacheName, part.Configuration));
        }
        /// <summary>
        /// Adds a redis configuration.
        /// </summary>
        /// <param name="part">The part.</param>
        /// <param name="configurationKey">
        /// The configuration key which has to match with the cache handle name.
        /// </param>
        /// <param name="config">The redis configuration object.</param>
        /// <returns>The configuration builder.</returns>
        /// <exception cref="System.ArgumentNullException">If config is null.</exception>
        public static ConfigurationBuilderCachePart WithRedisConfiguration(this ConfigurationBuilderCachePart part, string configurationKey, Action <RedisConfigurationBuilder> config)
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }
            var builder = new RedisConfigurationBuilder(configurationKey);

            config(builder);
            RedisConfigurations.AddConfiguration(builder.Build());
            return(part);
        }
        /// <summary>
        /// Configures the cache manager to use the <code>DataContract</code> based cache serializer in binary format.
        /// </summary>
        /// <param name="part">The configuration part.</param>
        /// <param name="serializerSettings">Settings for the serializer.</param>
        /// <returns>The builder instance.</returns>
        public static ConfigurationBuilderCachePart WithDataContractBinarySerializer(this ConfigurationBuilderCachePart part, DataContractSerializerSettings serializerSettings = null)
        {
            NotNull(part, nameof(part));

            if (serializerSettings == null)
            {
                return(part.WithSerializer(typeof(DataContractBinaryCacheSerializer)));
            }
            else
            {
                return(part.WithSerializer(typeof(DataContractBinaryCacheSerializer), serializerSettings));
            }
        }
        public static ConfigurationBuilderCachePart WithRedisConfiguration(this ConfigurationBuilderCachePart part, string configurationKey, IConnectionMultiplexer redisClient, int database = 0)
        {
            NotNullOrWhiteSpace(configurationKey, nameof(configurationKey));

            NotNull(redisClient, nameof(redisClient));

            var connectionString = redisClient.Configuration;

            part.WithRedisConfiguration(configurationKey, connectionString, database);

            RedisConnectionManager.AddConnection(connectionString, redisClient);

            return(part);
        }
        /// <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="ClientConfiguration"/> for the given key.
        /// <para>The key will be matched with the Couchbase cache handle name.</para>
        /// </summary>
        /// <param name="part">The part.</param>
        /// <param name="key">The key which has to match with the cache handle name.</param>
        /// <param name="config">The Couchbase configuration object.</param>
        /// <returns>The configuration builder.</returns>
        /// <exception cref="System.ArgumentNullException">If key or config are null.</exception>
        public static ConfigurationBuilderCachePart WithCouchbaseConfiguration(this ConfigurationBuilderCachePart part, string key, ClientConfiguration config)
        {
            if (string.IsNullOrWhiteSpace(key))
            {
                throw new ArgumentNullException("key");
            }
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }

            CouchbaseConfigurationManager.AddConfiguration(key, config);
            return(part);
        }
Esempio n. 26
0
        /// <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>
        /// Adds a redis configuration.
        /// </summary>
        /// <param name="part">The part.</param>
        /// <param name="configurationKey">
        /// The configuration key which has to match with the cache handle name.
        /// </param>
        /// <param name="connectionString">The redis connection string.</param>
        /// <returns>The configuration builder.</returns>
        /// <exception cref="System.ArgumentNullException">
        /// If configurationKey or connectionString are null.
        /// </exception>
        public static ConfigurationBuilderCachePart WithRedisConfiguration(this ConfigurationBuilderCachePart part, string configurationKey, string connectionString)
        {
            if (string.IsNullOrWhiteSpace(configurationKey))
            {
                throw new ArgumentNullException("configurationKey");
            }

            if (string.IsNullOrWhiteSpace(connectionString))
            {
                throw new ArgumentNullException("connectionString");
            }

            RedisConfigurations.AddConfiguration(new RedisConfiguration(configurationKey, connectionString));
            return(part);
        }
Esempio n. 28
0
        /// <summary>
        /// Builds a <see cref="CacheManagerConfiguration"/> which can be used to create a new cache
        /// manager instance.
        /// <para>
        /// Pass the configuration to <see cref="CacheFactory.FromConfiguration{TCacheValue}(CacheManagerConfiguration)"/>
        /// to create a valid cache manager.
        /// </para>
        /// </summary>
        /// <param name="settings">
        /// The configuration settings to define the cache handles and other properties.
        /// </param>
        /// <returns>The <see cref="CacheManagerConfiguration"/>.</returns>
        public static CacheManagerConfiguration BuildConfiguration(Action<ConfigurationBuilderCachePart> settings)
        {
            NotNull(settings, nameof(settings));

            var part = new ConfigurationBuilderCachePart();
            settings(part);
            return part.Configuration;
        }
Esempio n. 29
0
 internal ConfigurationBuilderCacheHandlePart(CacheHandleConfiguration cfg, ConfigurationBuilderCachePart parentPart)
 {
     this.Configuration = cfg;
     this.parent = parentPart;
 }
Esempio n. 30
0
        /// <summary>
        /// Builds a <see cref="CacheManagerConfiguration"/> which can be used to create a new cache
        /// manager instance.
        /// <para>
        /// Pass the configuration to <see cref="CacheFactory.FromConfiguration{TCacheValue}(CacheManagerConfiguration)"/>
        /// to create a valid cache manager.
        /// </para>
        /// </summary>
        /// <param name="name">The name of the cache manager.</param>
        /// <param name="settings">
        /// The configuration settings to define the cache handles and other properties.
        /// </param>
        /// <returns>The <see cref="CacheManagerConfiguration"/>.</returns>
        public static CacheManagerConfiguration BuildConfiguration(string name, Action<ConfigurationBuilderCachePart> settings)
        {
            NotNullOrWhiteSpace(name, nameof(name));
            NotNull(settings, nameof(settings));

            var part = new ConfigurationBuilderCachePart();
            settings(part);
            part.Configuration.Name = name;
            return part.Configuration;
        }
        /// <summary>
        /// Configures the cache manager to use the Newtonsoft.Json based cache serializer.
        /// </summary>
        /// <param name="part">The part.</param>
        /// <param name="serializationSettings">Settings to be used during serialization.</param>
        /// <param name="deserializationSettings">Settings to be used during deserialization.</param>
        /// <returns>The builder instance.</returns>
        public static ConfigurationBuilderCachePart WithJsonSerializer(this ConfigurationBuilderCachePart part, JsonSerializerSettings serializationSettings, JsonSerializerSettings deserializationSettings)
        {
            NotNull(part, nameof(part));

            return(part.WithSerializer(typeof(JsonCacheSerializer), serializationSettings, deserializationSettings));
        }
        /// <summary>
        /// Configures the cache manager to use the Newtonsoft.Json based cache serializer.
        /// </summary>
        /// <param name="part">The part.</param>
        /// <returns>The builder instance.</returns>
        public static ConfigurationBuilderCachePart WithJsonSerializer(this ConfigurationBuilderCachePart part)
        {
            NotNull(part, nameof(part));

            return(part.WithSerializer(typeof(JsonCacheSerializer)));
        }
        /// <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));
        }