/// <summary>
/// Constructs a new lookup table controller.
/// </summary>
/// <param name="errorList">An error list for the current errors.</param>
/// <param name="errorParser">An injected error parser.</param>
/// <param name="cacheProvider">An injected instance of the cache provider.</param>
public LookupTableController(ErrorList errorList, ErrorParser errorParser, ILookupCacheProvider cacheProvider)
: base(errorList, errorParser)
{
if (cacheProvider == null)
{
throw new ArgumentNullException(nameof(cacheProvider));
}
globalCache = cacheProvider.GetLookupCache(LookupCache.Global);
}
/// <summary>
/// Gets an instance of a lookup cache of the specified type.
/// Typically either <see cref="Global"/> or <see cref="User"/> constants are used as a cache type.
/// </summary>
/// <param name="serviceProvider">Service provider to use.</param>
/// <param name="cacheType">Cache type.</param>
/// <returns>An instance of a lookup cache of the specified type or <c>null</c> if no cache can be found.</returns>
public static LookupCache Get(IServiceProvider serviceProvider, string cacheType)
{
ILookupCacheProvider cacheProvider = serviceProvider.GetService <ILookupCacheProvider>();
if (cacheProvider == null)
{
Trace.TraceWarning("No ILookupCacheProvider service is configured. Using default SingletonLookupCacheProvider.");
cacheProvider = new DefaultLookupCacheProvider(serviceProvider);
}
return(cacheProvider.GetLookupCache(cacheType));
}
public static T GetFromCache <T>(ILookupCacheProvider cache, int lookupId) where T : LookupItem
{
LookupItem item;
Type lookupType = typeof(T);
if (lookupType == typeof(CatchType))
{
item = cache.CatchTypes.Where(i => i.Id == lookupId).SingleOrDefault();
}
else
{
item = cache.Advertisers.Where(i => i.Id == lookupId).SingleOrDefault();
}
return((T)Activator.CreateInstance(typeof(T), new object[] { item.Id, item.Name }));
}
public AdvertFactory(ILookupCacheProvider cache)
{
_cache = cache;
}
/// <summary>
/// Gets an instance of a lookup cache of the specified type.
/// Typically either <see cref="LookupCache.Global"/> or <see cref="LookupCache.User"/> constants are used as a cache type.
/// </summary>
/// <param name="cacheType">Cache type.</param>
/// <returns>An instance of a lookup cache of the specified type or <c>null</c> if no cache can be found.</returns>
public static LookupCache Get(string cacheType)
{
if (cacheProvider == null)
{
#if SILVERLIGHT
cacheProvider = new SingletonLookupCacheProvider();
#else
Type t = typeof(ILookupCacheProvider);
string cacheProviderClass = ConfigurationManager.AppSettings[t.FullName];
if (string.IsNullOrEmpty(cacheProviderClass))
{
Trace.TraceWarning("No lookup cache provider is supplied in the configuration. Using default SingletonLookupCacheProvider.");
t = typeof(SingletonLookupCacheProvider);
}
else t = Type.GetType(cacheProviderClass);
cacheProvider = Activator.CreateInstance(t) as ILookupCacheProvider;
if (cacheProvider == null) throw new Exception(
"Invalid type supplied in the application configuration for the lookup cache provider: " + cacheProviderClass);
#endif
}
LookupCache res = cacheProvider.GetLookupCache(cacheType);
if (res != null) res.CacheType = cacheType;
return res;
}
