// this method doesn't modify _handlerTable directly because this causes a race condition.
// two threads may call this method at the same time and one of calling loses the changes it made.
// but caller uses this method like a cache update so loosing change is acceptable.
internal void AddHandler(Type type, MessageHandlerItem handler)
{
var newTable = new Dictionary <Type, MessageHandlerItem>(_handlerTable);
newTable.Add(type, handler);
_handlerTable = newTable;
}
private void AddHandler(MethodInfo method, Type messageType, FilterChain filterChain, bool isSyncHandler, bool isReentrant)
{
if (method.IsGenericMethod == false)
{
if (isSyncHandler)
{
var item = new MessageHandlerItem
{
IsReentrant = isReentrant,
Handler = BuildHandler(_type, messageType, method, filterChain)
};
_table.Add(messageType, item);
}
else
{
var item = new MessageHandlerItem
{
IsReentrant = isReentrant,
AsyncHandler = BuildAsyncHandler(_type, messageType, method, filterChain)
};
_table.Add(messageType, item);
}
}
else
{
// because a generic method needs parameter types to construct handler
// so factory method is built to generate the handler when paramter types are ready
var defType = messageType.GetGenericTypeDefinition();
if (isSyncHandler)
{
_table.Add(defType, new MessageHandlerItem
{
IsReentrant = isReentrant,
IsGeneric = true,
GenericHandlerBuilder = t => new MessageHandlerItem
{
IsReentrant = isReentrant,
Handler = BuildGenericHandler(_type, t, method, filterChain)
}
});
}
else
{
_table.Add(defType, new MessageHandlerItem
{
IsReentrant = isReentrant,
IsGeneric = true,
GenericHandlerBuilder = t => new MessageHandlerItem
{
IsReentrant = isReentrant,
AsyncHandler = BuildGenericAsyncHandler(_type, t, method, filterChain)
}
});
}
}
}
private void AddHandler(MethodInfo method, Type messageType, FilterChain filterChain, bool isSyncHandler, bool isReentrant)
{
if (method.IsGenericMethod == false)
{
if (isSyncHandler)
{
var item = new MessageHandlerItem
{
IsReentrant = isReentrant,
Handler = BuildHandler(_type, messageType, method, filterChain)
};
_table.Add(messageType, item);
}
else
{
var item = new MessageHandlerItem
{
IsReentrant = isReentrant,
AsyncHandler = BuildAsyncHandler(_type, messageType, method, filterChain)
};
_table.Add(messageType, item);
}
}
else
{
// because a generic method needs parameter types to construct handler
// so factory method is built to generate the handler when paramter types are ready
var defType = messageType.GetGenericTypeDefinition();
if (isSyncHandler)
{
_table.Add(defType, new MessageHandlerItem
{
IsReentrant = isReentrant,
IsGeneric = true,
GenericHandlerBuilder = t => new MessageHandlerItem
{
IsReentrant = isReentrant,
Handler = BuildGenericHandler(_type, t, method, filterChain)
}
});
}
else
{
_table.Add(defType, new MessageHandlerItem
{
IsReentrant = isReentrant,
IsGeneric = true,
GenericHandlerBuilder = t => new MessageHandlerItem
{
IsReentrant = isReentrant,
AsyncHandler = BuildGenericAsyncHandler(_type, t, method, filterChain)
}
});
}
}
}
// this method doesn't modify _handlerTable directly because this causes a race condition.
// two threads may call this method at the same time and one of calling loses the changes it made.
// but caller uses this method like a cache update so loosing change is acceptable.
internal void AddHandler(Type type, MessageHandlerItem handler)
{
var newTable = new Dictionary<Type, MessageHandlerItem>(_handlerTable);
newTable.Add(type, handler);
_handlerTable = newTable;
}
