private static List <IAopHandler> GetHandlers(MethodInfo method, Type innerType, out bool hasExcpetions)
{
var types = method.GetParameters().Select(x => x.ParameterType).ToArray();
var mi = innerType.GetMethod(method.Name, types);
var baseHandlers = innerType.GetCustomAttributes <AopHandler>().ToList();
var hanlders = mi?.GetCustomAttributes <AopHandler>().ToList() ?? new List <AopHandler>();
foreach (var baseHandler in baseHandlers)
{
if (hanlders.All(x => x.GetType() != baseHandler.GetType()))
{
hanlders.Add(baseHandler);
}
}
hasExcpetions = false;
foreach (var attr in hanlders)
{
var type = attr.GetType();
if (type.GetMethod("OnException").DeclaringType == type)
{
hasExcpetions = true;
}
var key = attr.GetType().GetHashCode() ^ attr.GetHashCode();
HandlerCache.Add(key, attr);
}
return(hanlders.OrderBy(x => x.Order).OfType <IAopHandler>().ToList());
}
protected override void Given()
{
var container = new Container();
container.Register <IAttributePipelineOperator <BaseAttribute>, BaseAttributePO>();
container.Register <IAttributePipelineOperator <DerivedAttribute>, DerivedAttributePO>();
this.handlerCache = new HandlerCache(container);
}
public void Get_WhenTypeIsAValueTypeAndIsMissing_ReturnsDefault()
{
var sut = new HandlerCache();
var result = sut.Get(typeof(int));
Assert.AreEqual(0, result);
}
public void Get_WhenTypeIsAReferenceTypeAndIsMissing_ReturnsNull()
{
var sut = new HandlerCache();
var result = sut.Get(typeof(string));
Assert.IsNull(result);
}
public virtual void OnAction()
{
IAction[] actions = HandlerCache <IAction> .GetAction(this);
foreach (var action in actions)
{
action.Execute();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="HandlerProcessor"/> class.
/// </summary>
/// <param name="methodCache">The method cache.</param>
/// <param name="handlerCache">The handler cache.</param>
/// <param name="handlers">The handlers.</param>
public HandlerProcessor(MethodCache methodCache, HandlerCache handlerCache, IList<object> handlers)
{
if (methodCache == null) { throw new ArgumentNullException("methodCache"); }
if (handlerCache == null) { throw new ArgumentNullException("handlerCache"); }
if (handlers == null) { throw new ArgumentNullException("handlers"); }
this.methodCache = methodCache;
this.handlerCache = handlerCache;
this.handlers = handlers;
}
public void Get_WhenTypeIsAValueTypeAndIsCached_ReturnsValueMatchingType()
{
var value = 1;
var sut = new HandlerCache();
sut.Set(value);
var result = sut.Get(typeof(int));
Assert.AreEqual(value, result);
}
public void GetMissing_WhenValueIsNull_ThrowsArgumentNullException()
{
TestHelper.Act(
() =>
{
var sut = new HandlerCache();
sut.GetMissing = null;
})
.ExpectArgumentNullException("value");
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public IEnumerable <ClientRefInfo> GetClients()
{
var cacheKey = string.Concat(this.GetType().Name, "GetClients");
return(HandlerCache.Get <List <ClientRefInfo> >(cacheKey, () =>
{
return _clientRepos
.TableNoTracking
.ToList();
}));
}
public void Get_WhenTypeIsAReferenceTypeAndIsCached_ReturnsValueMatchingType()
{
var value = "hello, world!";
var sut = new HandlerCache();
sut.Set(value);
var result = sut.Get(typeof(string));
Assert.AreEqual(value, result);
}
public override void SetParams()
{
ID = 1;
DataMove = HandlerCache <DataMove> .SetData <Move>(this, new DataMove(20));
ActionMove = new ActionMove();
ActionMove.SetBot(this);
HandlerCache <ActionMove> .SetAction <Move>(this, ActionMove);
}
public void Process_WhenMultipleHandlersAreCalled_CallsEachHandler()
{
var handlerCache = new HandlerCache();
var message = "message";
var sut =
new HandlerProcessor(
new MethodCache(),
handlerCache,
new object[] { new MessageHandler(message), new ConvertToUpperCaseHandler() });
sut.Process();
Assert.AreEqual("MESSAGE", ((Result)handlerCache.Get(typeof(Result))).Value);
}
public void Bootstrap()
{
Container.Global.RunAllTypeProcessors();
Container.Global.RunAllRegistries();
Container.Global.RemoveAllRegistrationsAndInstancesOf <IHandlerCache>();
Container.Global.Register <IHandlerCache>(c =>
{
var cache = new HandlerCache(Container.Global);
var types = this.GetType().Assembly.GetTypes().Where(t => typeof(IHandler).IsAssignableFrom(t)).ToArray();
cache.Warm(types);
return(cache);
});
BinderCollection.Initialize(Container.Global);
}
public void Get_WhenTypeIsMissingAndGetMissingIsSpecified_ReturnsValueFromGetMissing()
{
TestHelper.Theory("type", new[] { typeof(int), typeof(string) })
.Act(
type =>
{
var value = new object();
var sut = new HandlerCache();
sut.GetMissing = missingType => value;
var result = sut.Get(type);
Assert.AreEqual(value, result);
})
.Verify();
}
public void Processes_WhenCalledMultipleTimes_RegistersEachHandlerType()
{
const string instanceName = "empty";
var handlerCache = new HandlerCache();
handlerCache.Set(0);
var sut = new Registry();
sut.Register(instanceName)
.Processes<CounterHandler>()
.Processes<CounterHandler>();
var container = new Container(sut);
HandlerProcessor processor = container.With(handlerCache).GetInstance<HandlerProcessor>(instanceName);
processor.Process();
Assert.AreEqual(2, handlerCache.Get(typeof(int)));
}
public void Processes_WhenHandlerTypeHasProcessMethod_RegistersHandlerType()
{
const string instanceName = "empty";
var handlerCache = new HandlerCache();
var sut = new Registry();
sut.Register(instanceName)
.Processes<EmptyHandler>();
var container = new Container(sut);
HandlerProcessor processor = container.With(handlerCache).GetInstance<HandlerProcessor>(instanceName);
processor.Process();
Assert.IsTrue(container.Model.For<HandlerProcessor>().HasImplementations(), "Missing implementations.");
Assert.IsNotNull(container.Model.Find<HandlerProcessor>(instanceName));
Assert.AreEqual("message", handlerCache.Get(typeof(string)));
}
private HandlerCache GetCacheInstance(string queue)
{
if (string.IsNullOrWhiteSpace(queue))
{
throw new ArgumentException("Queue name cannot be empty");
}
if (_cache.ContainsKey(queue))
{
return(_cache[queue]);
}
else
{
var serviceConnection = _connectionBuilder.GetServiceConnection(queue);
if (serviceConnection == null)
{
throw new ArgumentException($"No service connection found for queue {queue}");
}
var cache = new HandlerCache(queue, serviceConnection);
_cache[queue] = cache;
return(cache);
}
}
public void Get_WhenTypeIsReferenceTypeAndValueIsNull_ReturnsValueOfGetMissingFunction()
{
var value = new object();
var sut = new HandlerCache();
sut.GetMissing = missingType => value;
sut.Set<string>(null);
var result = sut.Get(typeof(string));
Assert.AreEqual(value, result);
}
/// <summary>
/// Clears the cache
/// </summary>
public void Clear()
{
HandlerCache.Clear();
TimeoutCache.Clear();
}