public static T Get <T>(
this IStorage storage,
IKeyBuilder key,
Func <T> callback,
ISerializer <T, string> serializer = null
)
{
serializer = serializer ?? GetDefaultSerializer <T>();
var serialized = storage
.Get(
key,
() =>
{
var item = callback();
if (item == null)
{
return(null);
}
return(serializer.Serialize(callback()));
}
);
if (serialized == null)
{
return(default(T));
}
return(serializer.Deserialize(serialized));
}
public static SqlServerKeyBuilder ForSqlServer <TKeyBuilder>(
[NotNull] this IKeyBuilder <TKeyBuilder> keyBuilder)
where TKeyBuilder : IKeyBuilder <TKeyBuilder>
{
Check.NotNull(keyBuilder, "keyBuilder");
return(new SqlServerKeyBuilder(keyBuilder.Metadata));
}
public static RelationalKeyBuilder ForRelational <TKeyBuilder>(
[NotNull] this IKeyBuilder <TKeyBuilder> keyBuilder)
where TKeyBuilder : IKeyBuilder <TKeyBuilder>
{
Check.NotNull(keyBuilder, "keyBuilder");
return(new RelationalKeyBuilder(keyBuilder.Metadata));
}
public DonutOutputCacheAttribute(IKeyBuilder keyBuilder)
: this(new KeyGenerator(keyBuilder),
new OutputCacheManager(OutputCache.Instance, keyBuilder),
new DonutHoleFiller(new EncryptingActionSettingsSerialiser(new ActionSettingsSerialiser(), new Encryptor())),
new CacheSettingsManager(),
new CacheHeadersHelper())
{
}
public IStorage Delete(IKeyBuilder key)
{
if (this.Exists(key))
{
this.memoryCache.Remove(key.ToString());
}
return(this);
}
public static TBuilder SharedNameExtension <TBuilder>(this IKeyBuilder <TBuilder> builder, string value)
where TBuilder : IKeyBuilder <TBuilder>
{
builder.Annotation("Annotation", value + ".Annotation");
builder.Metadata["Metadata"] = value + ".Metadata";
builder.Model["Model"] = value + ".Model";
return((TBuilder)builder);
}
public EpiServerDonutCacheAttribute(IKeyBuilder keyBuilder) :
this(
new OutputCacheManager(OutputCache.Instance, keyBuilder),
new EpiServerDonutHoleFiller(new EncryptingActionSettingsSerialiser(new ActionSettingsSerialiser(), new Encryptor())),
new CacheSettingsManager(),
new CacheHeadersHelper()
)
{
}
public KeyGenerator(IKeyBuilder keyBuilder)
{
if (keyBuilder == null)
{
throw new ArgumentNullException("keyBuilder");
}
_keyBuilder = keyBuilder;
}
public string Get(IKeyBuilder key)
{
if (this.Exists(key))
{
return(this.database.StringGet(key.ToString()));
}
return(null);
}
public KeyGenerator(IKeyBuilder keyBuilder)
{
if (keyBuilder == null)
{
throw new ArgumentNullException("keyBuilder");
}
_keyBuilder = keyBuilder;
}
public string Get(IKeyBuilder key)
{
if (this.Exists(key))
{
return(this.memoryCache[key.ToString()]
?.ToString());
}
return(null);
}
/// <summary>
/// Initializes a new instance of the <see cref="DonutOutputCacheAttribute"/> class.
/// </summary>
/// <param name="keyBuilder">The key builder.</param>
public DonutOutputCacheAttribute(IKeyBuilder keyBuilder) :
this(
new KeyGenerator(keyBuilder),
new OutputCacheManager(OutputCache.Instance, keyBuilder),
new DonutHoleFiller(HtmlHelperExtensions.Serialiser, HtmlHelperExtensions.PartialSerializer),
new CacheSettingsManager(),
new CacheHeadersHelper()
)
{
}
public DonutOutputCacheAttribute(IKeyBuilder keyBuilder)
{
_keyGenerator = new KeyGenerator(keyBuilder);
_outputCacheManager = new OutputCacheManager(OutputCache.Instance, keyBuilder);
_donutHoleFiller = new DonutHoleFiller(new EncryptingActionSettingsSerialiser(new ActionSettingsSerialiser(), new Encryptor()));
_cacheSettingsManager = new CacheSettingsManager();
_cacheHeadersHelper = new CacheHeadersHelper();
Duration = -1;
Location = (OutputCacheLocation)(-1);
Options = OutputCache.DefaultOptions;
}
public static TKeyBuilder ForRelational <TKeyBuilder>(
[NotNull] this IKeyBuilder <TKeyBuilder> keyBuilder,
[NotNull] Action <RelationalKeyBuilder> relationalKeyBuilder)
where TKeyBuilder : IKeyBuilder <TKeyBuilder>
{
Check.NotNull(keyBuilder, "keyBuilder");
Check.NotNull(relationalKeyBuilder, "relationalKeyBuilder");
relationalKeyBuilder(ForRelational(keyBuilder));
return((TKeyBuilder)keyBuilder);
}
public static T Get <T>(
this IStorageManager storageManager,
IKeyBuilder key,
FallbackPolicy fallbackPolicy,
ISerializer <T, string> serializer = null
)
{
var serialized = storageManager.Get(key, fallbackPolicy);
return((serializer ?? GetDefaultSerializer <T>())
.Deserialize(serialized));
}
public static TKeyBuilder KeyName <TKeyBuilder>(
[NotNull] this IKeyBuilder <TKeyBuilder> builder,
[NotNull] string keyName)
where TKeyBuilder : IKeyBuilder <TKeyBuilder>
{
Check.NotNull(builder, "builder");
Check.NotEmpty(keyName, "keyName");
builder.Annotation(Annotations.KeyName, keyName);
return((TKeyBuilder)builder);
}
public IStorage Add(IKeyBuilder key, string item)
{
if (item != null)
{
this.memoryCache.Add(
key.ToString(),
item,
DateTimeOffset.Now.Add(this.Expiry)
);
}
return(this);
}
protected void Test_Add_GetOk(
IKeyBuilder usingKey,
IStorage storage,
string expected
)
{
// Act
storage.Delete(usingKey).Add(usingKey, expected);
Thread.Sleep(100);
var actual = storage.Get(usingKey);
// Assert
Assert.AreEqual(expected, actual);
}
protected void Test_GetOrAdd_Success(
IKeyBuilder usingKey,
IStorage storage,
string expected
)
{
// Act
var actual = storage
.Delete(usingKey)
.Get(usingKey, () => expected);
// Assert
Assert.AreEqual(expected, actual);
}
protected void Test_ItemDelete_CannotGet(
IKeyBuilder usingKey,
IStorage storage
)
{
// Act
var actual = storage
.Delete(usingKey)
.Add(usingKey, Guid.NewGuid().ToString())
.Delete(usingKey)
.Get(usingKey);
// Assert
Assert.IsNull(actual);
}
public IStorage Add(IKeyBuilder key, string item)
{
if (!this.Exists(key))
{
var transaction = this.database.CreateTransaction();
transaction.AddCondition(Condition.KeyNotExists(key.ToString()));
transaction.StringSetAsync(
key.ToString(),
item,
this.Expiry
);
transaction.Execute();
}
return(this);
}
protected void Test_ItemExpired_ReturnNull(
IKeyBuilder usingKey,
IStorage storage,
TimeSpan expiry
)
{
// Act
storage
.Delete(usingKey)
.Add(usingKey, Guid.NewGuid().ToString());
Thread.Sleep((int)expiry.TotalMilliseconds + 1);
var actual = storage.Get(usingKey);
// Assert
Assert.IsNull(actual);
}
public static T Get <T>(
this IStorage storage,
IKeyBuilder key,
ISerializer <T, string> serializer = null
)
{
var serialized = storage.Get(key);
if (serialized == null)
{
return(default(T));
}
return((serializer ?? GetDefaultSerializer <T>())
.Deserialize(serialized));
}
public static IStorage Add <T>(
this IStorage storage,
IKeyBuilder key,
T value,
ISerializer <T, string> serializer = null
)
{
if (value == null)
{
return(storage);
}
var serialized = (serializer ?? GetDefaultSerializer <T>())
.Serialize(value);
return(storage.Add(key, serialized));
}
public static T Get <T>(
this IStorageManager storageManager,
IKeyBuilder key,
FallbackPolicy fallbackPolicy,
Func <T> callback,
ISerializer <T, string> serializer = null
)
{
serializer = serializer ?? GetDefaultSerializer <T>();
var item = default(T);
var serialized = storageManager.Get(key, fallbackPolicy);
if (serialized == null || (item = serializer.Deserialize(serialized)) == null)
{
item = callback();
serialized = serializer.Serialize(item);
storageManager.Add(key, serialized);
}
return(item);
}
public OutputCacheManager(OutputCacheProvider outputCacheProvider, IKeyBuilder keyBuilder)
{
_outputCacheProvider = outputCacheProvider;
_keyBuilder = keyBuilder;
}
public OutputCacheManager()
{
_outputCacheProvider = OutputCache.Instance;
_keyBuilder = new KeyBuilder();
}
public OutputCacheManager(OutputCacheProvider outputCacheProvider, IKeyBuilder keyBuilder)
{
_outputCacheProvider = outputCacheProvider;
_keyBuilder = keyBuilder;
}
public OutputCacheManager()
{
_outputCacheProvider = OutputCache.Instance;
_keyBuilder = new KeyBuilder();
}
public string Get(IKeyBuilder key, Func <string> callback)
{
return(this.Get(key) ?? this.Add(key, callback()).Get(key));
}
public S3Renderer WithKeyBuilder(IKeyBuilder builder)
{
this.keyBuilder = builder;
return this;
}
public void Serialize(DateTime key, IKeyBuilder builder)
{
builder.WriteBe(key.Ticks);
}
private bool Exists(IKeyBuilder key)
{
return(this.database.KeyExists(key.ToString()));
}
public HttpRuntimeCache(IKeyBuilder keyBuilder)
{
_keyBuilder = keyBuilder;
}
private bool Exists(IKeyBuilder key)
{
return(this.memoryCache.Contains(key.ToString()));
}
