/// <summary>
/// LoadDataTypeFromSource to load data type from source.
/// </summary>
/// <param name="key">key of data type</param>
/// <param name="dataType">type of datatype</param>
/// <returns>It returns the ProviderDataTypeItem IEnerable</returns>
public ProviderDataTypeItem <IEnumerable> LoadDataTypeFromSource(string key, DistributedDataType dataType)
{
try
{
//Data structures are avaialable in ProviderDataTypeItem<IEnumerable>
return((ProviderDataTypeItem <IEnumerable>)PersistenceProvider.Get(new string[] { key })?[key]);
}
catch (Exception e)
{
Logger.LogError(e.Message);
throw e;
}
}
/// <summary>
/// Load from source for bulk for ProviderCacheItem
/// </summary>
/// <param name="keys">< collection of keys against ProviderCacheItems/param>
/// <returns>returns dictionary of ProviderCacheItem</returns>
public IDictionary <string, ProviderCacheItem> LoadFromSource(ICollection <string> keys)
{
try
{
IDictionary <string, ProviderCacheItem> providerCacheItems = new Dictionary <string, ProviderCacheItem>();
foreach (var providerItem in PersistenceProvider.Get(keys))
{
providerCacheItems.Add(providerItem.Key, (ProviderCacheItem)providerItem.Value);
}
return(providerCacheItems);
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
throw ex;
}
}
/// <summary>
/// Load From Source for provider cache item
/// </summary>
/// <param name="key">key of cacheItem</param>
/// <returns>returns ProviderCacheItem</returns>
public ProviderCacheItem LoadFromSource(string key)
{
try
{
var providerItems = PersistenceProvider.Get(new string[] { key });
if (providerItems.ContainsKey(key))
{
return((ProviderCacheItem)providerItems[key]);
}
return(null);
}
catch (Exception e)
{
Logger.LogError(e.Message);
throw e;
}
}
