public static AspectF CacheRetry <TReturnType>(this AspectF aspect, ICache cacheResolver, ILogger logger, string key) { return(aspect.Combine(work => { try { Cache <TReturnType>(aspect, cacheResolver, key, work, cached => cached); } catch (Exception x) { logger.LogException(x); System.Threading.Thread.Sleep(1000); //Retry try { Cache <TReturnType>(aspect, cacheResolver, key, work, cached => cached); } catch (Exception ex) { logger.LogException(ex); throw; } } })); }
public static AspectF RunAsync(this AspectF aspect, Action compAspectFeCallback) { return(aspect.Combine(work => work.BeginInvoke(asyncresult => { work.EndInvoke(asyncresult); compAspectFeCallback(); }, null))); }
public static AspectF Delay(this AspectF aspect, int milliseconds) { return(aspect.Combine(work => { Thread.Sleep(milliseconds); work(); })); }
public static AspectF Timer(this AspectF aspect, string title) { return(aspect.Combine(work => { Stopwatch start = Stopwatch.StartNew(); work(); start.Stop(); Console.Out.WriteLine("{0}: {1}", title, start.Elapsed); })); }
public static AspectF Log(this AspectF aspect, ILogger logger, string[] categories, string logMessage, params object[] arg) { return(aspect.Combine(work => { logger.Log(categories, logMessage); work(); })); }
public static AspectF Log(this AspectF aspect, ILogger logger, string logMessage, params object[] arg) { return(aspect.Combine(work => { logger.Log(string.Format(logMessage, arg)); work(); })); }
public static AspectF While(this AspectF aspect, Func <bool> test) { return(aspect.Combine(work => { while (test()) { work(); } })); }
public static AspectF CacheList <TItemType, TListType>(this AspectF aspect, ICache cacheResolver, string listCacheKey, Func <TItemType, string> getItemKey) where TListType : IList <TItemType>, new() { return(aspect.Combine(work => { var workDelegate = aspect.WorkDelegate as Func <TListType>; // Replace the actual work delegate with a new delegate so that // when the actual work delegate returns a collection, each item // in the collection is stored in cache individually. Func <TListType> newWorkDelegate = () => { if (workDelegate != null) { TListType collection = workDelegate(); foreach (TItemType item in collection) { string key = getItemKey(item); cacheResolver.Set(key, item); } return collection; } return default(TListType); }; aspect.WorkDelegate = newWorkDelegate; // Get the collection from cache or real source. If collection is returned // from cache, resolve each item in the collection from cache Cache <TListType>(aspect, cacheResolver, listCacheKey, work, cached => { // Get each item from cache. If any of the item is not in cache // then discard the whole collection from cache and reload the // collection from source. var itemList = new TListType(); foreach (object cachedItem in cached.Select(item => cacheResolver.Get(getItemKey(item)))) { if (null != cachedItem) { itemList.Add((TItemType)cachedItem); } else { // One of the item is missing from cache. So, discard the // cached list. return default(TListType); } } return itemList; }); })); }
public static AspectF Until(this AspectF aspect, Func <bool> test) { return(aspect.Combine(work => { while (!test()) { ; } work(); })); }
public static AspectF WhenTrue(this AspectF aspect, params Func <bool>[] conditions) { return(aspect.Combine(work => { if (conditions.Any(condition => !condition())) { return; } work(); })); }
public static AspectF Log(this AspectF aspect, ILogger logger, string beforeMessage, string afterMessage) { return(aspect.Combine(work => { logger.Log(beforeMessage); work(); logger.Log(afterMessage); })); }
public static AspectF IgnoreExceptions(this AspectF aspect) { return(aspect.Combine(work => { try { work(); } catch { } })); }
public static AspectF IgnoreException <T>(this AspectF aspect) where T : Exception { return(aspect.Combine(work => { try { work(); } catch (T) { } })); }
public static AspectF TrapLog(this AspectF aspect, ILogger logger) { return(aspect.Combine(work => { try { work(); } catch (Exception x) { logger.LogException(x); } })); }
public static AspectF ReadLockUpgradable(this AspectF aspect, ReaderWriterLockSlim @lock) { return(aspect.Combine(work => { @lock.EnterUpgradeableReadLock(); try { work(); } finally { @lock.ExitUpgradeableReadLock(); } })); }
public static AspectF Expected <TException>(this AspectF aspect) where TException : Exception { return(aspect.Combine(work => { try { work(); } catch (TException x) { Debug.WriteLine(x.ToString()); } })); }
public static AspectF WriteLock(this AspectF aspect, ReaderWriterLockSlim @lock) { return(aspect.Combine(work => { @lock.EnterWriteLock(); try { work(); } finally { @lock.ExitWriteLock(); } })); }
public static AspectF MustBeNonNull(this AspectF aspect, params object[] args) { return(aspect.Combine(work => { for (int i = 0; i < args.Length; i++) { object arg = args[i]; if (arg.IsNull()) { throw new ArgumentException(string.Format("Parameter at index {0} is null", i)); } } work(); })); }
public static AspectF MustBeNonDefault <T>(this AspectF aspect, params T[] args) where T : IComparable { return(aspect.Combine(work => { T defaultvalue = default(T); for (int i = 0; i < args.Length; i++) { T arg = args[i]; if (arg.IsNull() || arg.Equals(defaultvalue)) { throw new ArgumentException(string.Format("Parameter at index {0} is null", i)); } } work(); })); }
public static AspectF HowLong(this AspectF aspect, ILogger logger, string startMessage, string endMessage) { return(aspect.Combine(work => { DateTime start = DateTime.Now; logger.Log(startMessage); work(); DateTime end = DateTime.Now.ToUniversalTime(); TimeSpan duration = end - start; logger.Log(string.Format(endMessage, duration.TotalMilliseconds, duration.TotalSeconds, duration.TotalMinutes, duration.TotalHours, duration.TotalDays)); })); }
public static AspectF CacheRetry <TReturnType>(this AspectF aspect, ICache cacheResolver, string key) { return(aspect.Combine(work => { try { Cache <TReturnType>(aspect, cacheResolver, key, work, cached => cached); } catch { Thread.Sleep(1000); //Retry Cache <TReturnType>(aspect, cacheResolver, key, work, cached => cached); } })); }
public static AspectF Retry(this AspectF aspects, int retryDuration, Action <Exception> errorHandler, ILogger logger) { return(aspects.Combine(work => Retry(retryDuration, 1, errorHandler, x => DoNothing(), work, logger))); }
public static AspectF RunAsync(this AspectF aspect) { return(aspect.Combine(work => work.BeginInvoke(work.EndInvoke, null))); }
public static AspectF Cache <TReturnType>(this AspectF aspect, ICache cacheResolver, string key) { return(aspect.Combine(work => Cache <TReturnType>(aspect, cacheResolver, key, work, cached => cached))); }
public static AspectF Retry(this AspectF aspects) { return(aspects.Combine(work => Retry(1000, 1, error => DoNothing(error), x => DoNothing(), work))); }
public static AspectF Retry(this AspectF aspects, int retryDuration, int retryCount, Action <Exception> errorHandler, Action <IEnumerable <Exception> > retryFailed) { return(aspects.Combine(work => Retry(retryDuration, retryCount, errorHandler, retryFailed, work))); }
public static AspectF Retry(this AspectF aspects, int retryDuration, int retryCount, Action <Exception> errorHandler) { return(aspects.Combine(work => Retry(retryDuration, retryCount, errorHandler, x => DoNothing(), work))); }
public static AspectF Retry(this AspectF aspects, int retryDuration) { return(aspects.Combine(work => Retry(retryDuration, 1, error => DoNothing(error), x => DoNothing(), work))); }
public static AspectF Retry(this AspectF aspects, Action <IEnumerable <Exception> > failHandler) { return(aspects.Combine(work => Retry(1000, 1, error => DoNothing(error), x => DoNothing(), work))); }