/// <summary>
/// This constructor allows the creation of a feature but will automatically
/// add the feature to the parent featureset.
/// </summary>
/// <param name="geometry">The IBasicGeometry to use for this feature</param>
/// <param name="parent">The IFeatureSet to add this feature to.</param>
public Feature(IBasicGeometry geometry, IFeatureSet parent)
{
_basicGeometry = geometry;
_dataRow = parent.DataTable.NewRow();
_envelopSource = CacheTypes.Dynamic;
parent.Features.Add(this);
}
public static string GetProviderGroupCacheKey(this object item, CacheTypes cacheType)
{
if (item == null)
{
throw new ArgumentNullException();
}
IProviderGroupId providerGroupIdItem = item as IProviderGroupId;
if (providerGroupIdItem == null)
{
throw new InvalidOperationException($"Type [{item.GetType().Name}] does not implement IProviderGroupId");
}
string result = string.Empty;
switch (cacheType)
{
case CacheTypes.Item:
result = $"mc_{item.GetType().Name}_{providerGroupIdItem.ProviderGroupId}_{providerGroupIdItem.Id}";
break;
case CacheTypes.ItemList:
result = $"mc_{item.GetType().Name}_{providerGroupIdItem.ProviderGroupId}";
break;
}
return(result);
}
public object Get(CacheTypes t)
{
ObjectCache cache = MemoryCache.Default;
var data = cache.Get(t.ToString());
return(data);
}
/// <summary>
/// Creates a new instance of a feature, by specifying the feature type enumeration and a
/// set of coordinates that can be either a list or an array as long as it is enumerable.
/// </summary>
/// <param name="featureType">The feature type</param>
/// <param name="coordinates">The coordinates to pass</param>
public Feature(FeatureType featureType, IEnumerable <Coordinate> coordinates)
{
switch (featureType)
{
case FeatureType.Line:
_dataRow = null;
_basicGeometry = new LineString(coordinates);
_envelopSource = CacheTypes.Dynamic;
break;
case FeatureType.MultiPoint:
_dataRow = null;
_basicGeometry = new MultiPoint(coordinates);
_envelopSource = CacheTypes.Dynamic;
break;
case FeatureType.Point:
_dataRow = null;
_basicGeometry = new Point(coordinates.First());
_envelopSource = CacheTypes.Dynamic;
break;
case FeatureType.Polygon:
_dataRow = null;
_basicGeometry = new Polygon(coordinates);
_envelopSource = CacheTypes.Dynamic;
break;
}
}
public void Add(CacheTypes t, object o)
{
ObjectCache cache = MemoryCache.Default;
CacheItemPolicy policy = new CacheItemPolicy {
AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(30)
};
cache.Add(t.ToString(), o, policy);
}
/// <summary>
/// Возвращает конфигуратор
/// </summary>
/// <param name="p_CacheType">тип кэша</param>
/// <returns></returns>
public static CacheConfigurator GetConfigurationForType(CacheTypes p_CacheType)
{
DataRow[] dr = Config.Select(string.Format("{0} = '{1}'", CacheConfigurator.TypeNameColumnName,
Enum.GetName(typeof(CacheTypes), p_CacheType)));
if (dr != null && dr.Length > 0)
return new CacheConfigurator(dr[0]);
else
throw AssistLogger.Log<ExceptionHolder>(new CacheConfigurationNotFoundException(), AssistLogger.Category.Database);
}
public static string GetProviderCacheKey(this object item, CacheTypes cacheType)
{
if (item == null)
{
throw new ArgumentNullException();
}
string result = string.Empty;
switch (cacheType)
{
case CacheTypes.Item:
result = $"mc_{item.GetType().Name}_{item.GetProviderId()}_{item.GetId()}";
break;
case CacheTypes.ItemList:
result = $"mc_{item.GetType().Name}_{item.GetProviderId()}";
break;
}
return(result);
}
/// <summary>
/// </summary>
/// <param name="client"></param>
/// <param name="ctype">The type of Cache system to use for images.</param>
/// <param name="directory">The directory to use for disk based caching.</param>
private void Init(SecondLife client, CacheTypes ctype, string directory)
{
slClient = client;
// Setup Image Caching
CacheType = ctype;
if (ctype == CacheTypes.Disk)
{
if (directory != null)
{
CacheDirectory = directory;
}
try
{
if (!Directory.Exists(CacheDirectory))
{
Directory.CreateDirectory(CacheDirectory);
}
}
catch (Exception e)
{
slClient.Log("Disk Cache directory could not be established, defaulting to Memory Cache: " + Environment.NewLine +
e.ToString(), Helpers.LogLevel.Warning);
CacheType = CacheTypes.Memory;
}
}
// Image Packet Helpers
ImagePacketHelper = new ImagePacketHelpers(client);
// Image Callbacks
slClient.Network.RegisterCallback(PacketType.ImageData, new NetworkManager.PacketCallback(ImageDataCallbackHandler));
slClient.Network.RegisterCallback(PacketType.ImagePacket, new NetworkManager.PacketCallback(ImagePacketCallbackHandler));
slClient.Network.RegisterCallback(PacketType.ImageNotInDatabase, new NetworkManager.PacketCallback(ImageNotInDatabaseCallbackHandler));
}
/// <summary>
/// </summary>
/// <param name="client"></param>
/// <param name="ctype">The type of Cache system to use for images.</param>
/// <param name="directory">The directory to use for disk based caching.</param>
private void Init(SecondLife client, CacheTypes ctype, string directory)
{
slClient = client;
// Setup Image Caching
CacheType = ctype;
if (ctype == CacheTypes.Disk)
{
if (directory != null)
{
CacheDirectory = directory;
}
try
{
if (!Directory.Exists(CacheDirectory))
{
Directory.CreateDirectory(CacheDirectory);
}
}
catch (Exception e)
{
Console.WriteLine("ERROR: Disk Cache directory could not be established, defaulting to Memory Cache.");
Console.WriteLine(e.Message);
CacheType = CacheTypes.Memory;
}
}
// Image Packet Helpers
ImagePacketHelper = new ImagePacketHelpers(client);
// Image Callbacks
slClient.Network.RegisterCallback(PacketType.ImageData, new PacketCallback(ImageDataCallbackHandler));
slClient.Network.RegisterCallback(PacketType.ImagePacket, new PacketCallback(ImagePacketCallbackHandler));
slClient.Network.RegisterCallback(PacketType.ImageNotInDatabase, new PacketCallback(ImageNotInDatabaseCallbackHandler));
}
public async Task Invoke(HttpContext context)
{
//remove header set by end user directly.
context.Request.Headers.Remove("Cache-Enabled");
var originalBodyStream = context.Response.Body;
using (var memStream = new MemoryStream())
{
context.Response.Body = memStream;
await _next(context);
memStream.Position = 0;
var cacheEnabled = context.Request.Headers["Cache-Enabled"];
if (cacheEnabled == "true")
{
int minutes = 0;
int.TryParse(context.Request.Headers["Cache-Time-Minutes"], out minutes);
CacheTypes cacheType = (CacheTypes)Enum.Parse(typeof(CacheTypes), context.Request.Headers["Cache-Type"]);
var cacheProvider = context.RequestServices.GetService(typeof(IDistributedCache)) as IDistributedCache;
var cacheKeyProvider = context.RequestServices.GetService(typeof(ICacheKeyProvider)) as ICacheKeyProvider;
var key = cacheKeyProvider.CreateKey();
var cacheData = cacheProvider.Get(key);
if (cacheData == null)
{
var response = context.Response;
string responseBody = new StreamReader(memStream).ReadToEnd();
memStream.Position = 0;
var cacheItem = new CacheItem
{
ContentType = context.Response.ContentType,
Body = System.Text.ASCIIEncoding.ASCII.GetBytes(responseBody),
Headers = context.Response.Headers.ToDictionary(h => h.Key, v => v.Value.ToString()),
LastModifiedOn = DateTime.Now
};
switch (cacheType)
{
case CacheTypes.Absolute:
cacheProvider.Set(key, cacheKeyProvider.ToByteArray <CacheItem>(cacheItem), new DistributedCacheEntryOptions {
AbsoluteExpiration = System.DateTimeOffset.UtcNow.AddMinutes(minutes)
});
break;
case CacheTypes.Sliding:
cacheProvider.Set(key, cacheKeyProvider.ToByteArray <CacheItem>(cacheItem), new DistributedCacheEntryOptions {
SlidingExpiration = System.TimeSpan.FromMinutes(minutes)
});
break;
default:
break;
}
}
}
await memStream.CopyToAsync(originalBodyStream);
}
}
/// <summary>
/// </summary>
/// <param name="client"></param>
/// <param name="ctype">The type of Cache system to use for images.</param>
/// <param name="directory">The directory to use for disk based caching.</param>
public ImageManager(SecondLife client, CacheTypes ctype, String directory)
{
Init(client, ctype, directory);
}
/// <summary>
/// </summary>
/// <param name="client"></param>
/// <param name="ctype">The type of Cache system to use for images.</param>
/// <param name="directory">The directory to use for disk based caching.</param>
private void Init(SecondLife client, CacheTypes ctype, string directory)
{
slClient = client;
// Setup Image Caching
CacheType = ctype;
if (ctype == CacheTypes.Disk)
{
if (directory != null)
{
CacheDirectory = directory;
}
try
{
if (!Directory.Exists(CacheDirectory))
{
Directory.CreateDirectory(CacheDirectory);
}
}
catch (Exception e)
{
slClient.Log("Disk Cache directory could not be established, defaulting to Memory Cache: " + Environment.NewLine +
e.ToString(), Helpers.LogLevel.Warning);
CacheType = CacheTypes.Memory;
}
}
// Image Packet Helpers
ImagePacketHelper = new ImagePacketHelpers(client);
// Image Callbacks
slClient.Network.RegisterCallback(PacketType.ImageData, new NetworkManager.PacketCallback(ImageDataCallbackHandler));
slClient.Network.RegisterCallback(PacketType.ImagePacket, new NetworkManager.PacketCallback(ImagePacketCallbackHandler));
slClient.Network.RegisterCallback(PacketType.ImageNotInDatabase, new NetworkManager.PacketCallback(ImageNotInDatabaseCallbackHandler));
}
/// <summary>
/// </summary>
/// <param name="client"></param>
/// <param name="ctype">The type of Cache system to use for images.</param>
/// <param name="directory">The directory to use for disk based caching.</param>
private void Init(SecondLife client, CacheTypes ctype, string directory)
{
slClient = client;
// Setup Image Caching
CacheType = ctype;
if (ctype == CacheTypes.Disk)
{
if (directory != null)
{
CacheDirectory = directory;
}
try
{
if (!Directory.Exists(CacheDirectory))
{
Directory.CreateDirectory(CacheDirectory);
}
}
catch (Exception e)
{
Console.WriteLine("ERROR: Disk Cache directory could not be established, defaulting to Memory Cache.");
Console.WriteLine(e.Message);
CacheType = CacheTypes.Memory;
}
}
// Image Packet Helpers
ImagePacketHelper = new ImagePacketHelpers(client);
// Image Callbacks
slClient.Network.RegisterCallback(PacketType.ImageData, new PacketCallback(ImageDataCallbackHandler));
slClient.Network.RegisterCallback(PacketType.ImagePacket, new PacketCallback(ImagePacketCallbackHandler));
slClient.Network.RegisterCallback(PacketType.ImageNotInDatabase, new PacketCallback(ImageNotInDatabaseCallbackHandler));
}
/// <summary>
/// </summary>
/// <param name="client"></param>
/// <param name="ctype">The type of Cache system to use for images.</param>
public ImageManager(SecondLife client, CacheTypes ctype)
{
Init(client, ctype, null);
}
/// <summary>
/// </summary>
/// <param name="client"></param>
/// <param name="ctype">The type of Cache system to use for images.</param>
/// <param name="directory">The directory to use for disk based caching.</param>
public ImageManager(SecondLife client, CacheTypes ctype, String directory)
{
Init(client, ctype, directory);
}
/// <summary>
/// Constructs a new Feature
/// </summary>
public Feature()
{
_dataRow = null;
_basicGeometry = null;
_envelopSource = CacheTypes.Cached;
}
/// <summary>
/// </summary>
/// <param name="client"></param>
/// <param name="ctype">The type of Cache system to use for images.</param>
public ImageManager(SecondLife client, CacheTypes ctype)
{
Init(client, ctype, null);
}
public ICacheSettings GetCacheSettings(CacheTypes cacheType, string cacheEntry)
{
return(new CacheSettings());
}
