/// <summary> /// Configures the cache manager to use the <code>ProtoBuf</code> based cache serializer. /// </summary> /// <param name="part">The configuration part.</param> /// <returns>The builder instance.</returns> public static ConfigurationBuilderCachePart WithProtoBufSerializer( this ConfigurationBuilderCachePart part, RecyclableMemoryStreamManager recyclableMemoryStreamManager) { Guard.NotNull <ConfigurationBuilderCachePart>(part, nameof(part)); return(part.WithSerializer(typeof(ProtoBufSerializer), recyclableMemoryStreamManager)); }
public static ConfigurationBuilderCachePart TestSerializer(this ConfigurationBuilderCachePart part, Serializer serializer) { switch (serializer) { case Serializer.Binary: break; case Serializer.GzJson: part.WithGzJsonSerializer(); break; case Serializer.Json: part.WithJsonSerializer(); break; case Serializer.Proto: part.WithProtoBufSerializer(); break; case Serializer.BondBinary: part.WithBondCompactBinarySerializer(2048); break; } return(part); }
public static ConfigurationBuilderCacheHandlePart WithSQLiteCacheHandle( this ConfigurationBuilderCachePart part, SQLiteCacheHandleAdditionalConfiguration config) => part?.WithHandle( typeof(SQLiteCacheHandle <>), Guid.NewGuid().ToString(), isBackplaneSource: false, config);
/// <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) { Guard.NotNullOrWhiteSpace(configurationKey, nameof(configurationKey)); Guard.NotNullOrWhiteSpace(connectionString, nameof(connectionString)); RedisConfigurations.AddConfiguration(new RedisConfiguration(configurationKey, connectionString, database, enableKeyspaceNotifications)); return(part); }
/// <summary> /// Configures the cache manager to use the <code>Hyperion</code> based cache serializer. /// </summary> /// <param name="part">The configuration part.</param> /// <param name="serializerSettings">Hyperion serialization settings</param> /// <returns>The builder instance.</returns> public static ConfigurationBuilderCachePart WithHyperionSerializer(this ConfigurationBuilderCachePart part, HyperionSerializerSettings serializerSettings) { if (part == null) { throw new ArgumentNullException(nameof(part)); } return(part.WithSerializer(typeof(HyperionSerializer), serializerSettings)); }
/// <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="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) { Guard.NotNull(configuration, nameof(configuration)); var builder = new RedisConfigurationBuilder(configurationKey); configuration(builder); RedisConfigurations.AddConfiguration(builder.Build()); return(part); }
/// <summary> /// Adds an existing <see cref="IConnectionMultiplexer"/> to the cache manager configuration which can be referenced by redis cache handle and/or backplane. /// </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="redisClient">The connection multiplexer instance.</param> /// <param name="database">The redis database to use for caching.</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="redisClient"/> are null. /// </exception> public static ConfigurationBuilderCachePart WithRedisConfiguration(this ConfigurationBuilderCachePart part, string configurationKey, IConnectionMultiplexer redisClient, int database = 0, bool enableKeyspaceNotifications = false) { Guard.NotNullOrWhiteSpace(configurationKey, nameof(configurationKey)); Guard.NotNull(redisClient, nameof(redisClient)); var connectionString = redisClient.Configuration; part.WithRedisConfiguration(configurationKey, connectionString, database, enableKeyspaceNotifications); RedisConnectionManager.AddConnection(connectionString, redisClient); return(part); }
public static ConfigurationBuilderCachePart TestSerializer(this ConfigurationBuilderCachePart part, Serializer serializer) { switch (serializer) { case Serializer.Binary: break; case Serializer.GzJson: part.WithGzJsonSerializer(); break; case Serializer.Json: part.WithJsonSerializer(); break; case Serializer.Proto: part.WithProtoBufSerializer(); break; case Serializer.BondBinary: part.WithBondCompactBinarySerializer(2048); break; case Serializer.DataContract: part.WithDataContractSerializer(); break; case Serializer.DataContractBinary: part.WithDataContractBinarySerializer(); break; case Serializer.DataContractGzJson: part.WithDataContractGzJsonSerializer(); break; case Serializer.DataContractJson: part.WithDataContractJsonSerializer(); break; default: throw new InvalidOperationException("Unknown serializer"); } return(part); }
/// <summary> /// Adds a cache handle using <see cref="MemoryCache"/>. /// </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 WithMemoryCacheHandle(this ConfigurationBuilderCachePart part, bool isBackplaneSource = false) => WithMemoryCacheHandle(part, Guid.NewGuid().ToString(), isBackplaneSource, new MemoryCacheOptions());
public static void UseMemoryCache(this ConfigurationBuilderCachePart cacheConfigurationBuilder, uint expiresInSeconds) { cacheConfigurationBuilder.WithMicrosoftMemoryCacheHandle() .WithExpiration(ExpirationMode.Absolute, TimeSpan.FromSeconds(expiresInSeconds)); }
/// <summary> /// Adds a <see cref="MemoryCacheHandle{TCacheValue}" /> using a <see cref="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="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 WithMemoryCacheHandle(this ConfigurationBuilderCachePart part, string instanceName, bool isBackplaneSource = false) => part?.WithHandle(typeof(MemoryCacheHandle <>), instanceName, isBackplaneSource);
/// <summary> /// Adds a cache handle using <see cref="MemoryCache"/>. /// The name of the cache instance will be 'default'. /// </summary> /// <param name="part">The builder part.</param> /// <param name="options">The <see cref="MemoryCacheOptions"/> which should be used to initiate or reset this cache.</param> /// <returns>The builder part.</returns> public static ConfigurationBuilderCacheHandlePart WithMemoryCacheHandle(this ConfigurationBuilderCachePart part, MemoryCacheOptions options) => WithMemoryCacheHandle(part, Guid.NewGuid().ToString(), false, options);
/// <summary> /// Adds a cache handle using <see cref="MemoryCache"/>. /// </summary> /// <param name="part">The builder part.</param> /// <param name="instanceName">The name to be used for the cache handle instance.</param> /// <param name="options">The <see cref="MemoryCacheOptions"/> which should be used to initiate or reset this cache.</param> /// <returns>The builder part.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="instanceName"/> is null.</exception> public static ConfigurationBuilderCacheHandlePart WithMemoryCacheHandle(this ConfigurationBuilderCachePart part, string instanceName, MemoryCacheOptions options) => WithMemoryCacheHandle(part, instanceName, false, options);
/// <summary> /// Adds a cache handle using <see cref="MemoryCache"/>. /// </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 WithMemoryCacheHandle(this ConfigurationBuilderCachePart part, string instanceName, bool isBackplaneSource = false) => WithMemoryCacheHandle(part, instanceName, isBackplaneSource, new MemoryCacheOptions());
/// <summary> /// Configures the cache manager to use the <code>fastJSON</code> based cache serializer with compression. /// </summary> /// <param name="part">The configuration part.</param> /// <returns>The builder instance.</returns> public static ConfigurationBuilderCachePart WithGzJsonSerializer(this ConfigurationBuilderCachePart part) { NotNull(part, nameof(part)); return(part.WithSerializer(typeof(GzJsonCacheSerializer))); }
/// <summary> /// Configures the cache manager to use the <code>fastJSON</code> based cache serializer with compression. /// </summary> /// <param name="part">The configuration part.</param> /// <param name="fastJsonSettings">The settings to be used during serialization/deserialization.</param> /// <returns>The builder instance.</returns> public static ConfigurationBuilderCachePart WithGzJsonSerializer(this ConfigurationBuilderCachePart part, JSONParameters fastJsonSettings) { NotNull(part, nameof(part)); return(part.WithSerializer(typeof(GzJsonCacheSerializer), fastJsonSettings)); }
/// <summary> /// Configures a cache backplane for the cache manager. /// The <paramref name="redisConfigurationKey"/> is used to find a matching redis configuration. /// <para> /// If a backplane is defined, at least one cache handle must be marked as backplane /// source. The cache manager then will try to synchronize multiple instances of the same configuration. /// </para> /// </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="channelName">The pub sub channel name the backplane should use.</param> /// <returns>The builder instance.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="redisConfigurationKey"/> is null.</exception> public static ConfigurationBuilderCachePart WithRedisBackplane(this ConfigurationBuilderCachePart part, string redisConfigurationKey, string channelName) { Guard.NotNull(part, nameof(part)); return(part.WithBackplane(typeof(RedisCacheBackplane), redisConfigurationKey, channelName)); }
public static void UseMemoryCache(this ConfigurationBuilderCachePart cacheConfigurationBuilder) { cacheConfigurationBuilder.WithMicrosoftMemoryCacheHandle(); }
/// <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="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 instance.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="redisConfigurationKey"/> is null.</exception> public static ConfigurationBuilderCacheHandlePart WithRedisCacheHandle(this ConfigurationBuilderCachePart part, string redisConfigurationKey, bool isBackplaneSource = true) { Guard.NotNull(part, nameof(part)); return(part.WithHandle(typeof(RedisCacheHandle <>), redisConfigurationKey, isBackplaneSource)); }
public static ConfigurationBuilderCacheHandlePart WithParentCache <TCacheValue>(this ConfigurationBuilderCachePart config, ParentCache <TCacheValue> parent) => config.WithHandle(typeof(ParentCacheHandle <>), "PraentCache", false, parent);
/// <summary> /// Configures the cache manager to use the <code>NetJSON</code> based cache serializer with compression. /// </summary> /// <param name="part">The configuration part.</param> /// <param name="settings">The settings to be used during serialization/deserialization.</param> /// <returns>The builder instance.</returns> public static ConfigurationBuilderCachePart WithNetJSONJsonSerializer(this ConfigurationBuilderCachePart part, NetJSONSettings settings) { NotNull(part, nameof(part)); return(part.WithSerializer(typeof(GzNetJSONCacheSerializer), settings)); }