/// <summary>
/// Configures the component instance. This method should set <see cref="IsConfigured" />.
/// </summary>
/// <param name="applicationConfiguration">The application configuration.</param>
public void Configure(ApplicationConfigurationBase applicationConfiguration)
{
if (_IsConfigured)
{
return;
}
applicationConfiguration.CompositionContainer.ComposeExportedValue <IManageEvents>(this);
_CompositionContainer = applicationConfiguration.CompositionContainer;
_ConditionalEventHandlers = _CompositionContainer.GetExportTypesThatImplement <IConditionallyHandleEvents>().ToList();
_IsConfigured = true;
}
public static ScimServerConfiguration WithTypeDefinitions(this ScimServerConfiguration serverConfiguration)
{
var compositionContainer =
new CompositionContainer(
new AggregateCatalog(
new AssemblyCatalog(Assembly.GetExecutingAssembly()),
new AssemblyCatalog(Assembly.GetAssembly(typeof(ScimServerConfiguration))),
new AssemblyCatalog(Assembly.GetAssembly(typeof(ScimUser2)))));
// discover and register all type definitions
var owinScimAssembly = Assembly.GetExecutingAssembly();
var typeDefinitions = compositionContainer.GetExportTypesThatImplement <IScimTypeDefinition>();
foreach (var typeDefinition in typeDefinitions)
{
Type distinctTypeDefinition;
var typeDefinitionTarget = GetTargetDefinitionType(typeDefinition); // the type of object being defined (e.g. User, Group, Name)
if (serverConfiguration.TypeDefinitionRegistry.TryGetValue(typeDefinitionTarget, out distinctTypeDefinition))
{
// already have a definition registered for the target type
// let's favor non-Owin.Scim definitions over built-in defaults
if (distinctTypeDefinition.Assembly == owinScimAssembly && typeDefinition.Assembly != owinScimAssembly)
{
serverConfiguration.TypeDefinitionRegistry[typeDefinitionTarget] = typeDefinition;
}
continue;
}
// register type definition
serverConfiguration.TypeDefinitionRegistry[typeDefinitionTarget] = typeDefinition;
}
var enumerator = serverConfiguration.TypeDefinitionRegistry.Values.GetEnumerator();
while (enumerator.MoveNext())
{
// creating type definitions may be expensive due to reflection
// when a type definition is instantiated, it may implicitly instantiate/register other type
// definitions for complex attributes, therefore, no need to re-create the same definition more than once
if (serverConfiguration.ContainsTypeDefinition(enumerator.Current))
{
continue;
}
var typeDefinition = (IScimTypeDefinition)enumerator.Current.CreateInstance(serverConfiguration);
serverConfiguration.AddTypeDefiniton(typeDefinition);
}
return(serverConfiguration);
}
private static async Task <Object> RaiseEventInternal <TEvent>(TEvent @event)
{
IEnumerable <Type> handlerTypes;
if (_EventHandlerCache.ContainsKey(typeof(TEvent)))
{
handlerTypes = _EventHandlerCache[typeof(TEvent)];
}
else
{
if (_CompositionContainer == null)
{
// not configured correctly, do not attempt to raise event
return(null);
}
handlerTypes = _EventHandlerCache.GetOrAdd(
typeof(TEvent),
_CompositionContainer.GetExportTypesThatImplement <IHandleEvent <TEvent> >()
.Concat(_CompositionContainer.GetExportTypesThatImplement <IHandleEventAsync <TEvent> >()).ToList());
}
var tcs = new TaskCompletionSource <Object>();
var exceptions = new ConcurrentBag <Exception>();
var completeHandlerTypes = handlerTypes.Concat(_ConditionalEventHandlers).ToList();
await ForEachAsync(
completeHandlerTypes,
completeHandlerTypes.Count > Environment.ProcessorCount
?Environment.ProcessorCount
: completeHandlerTypes.Count,
async handlerType =>
{
try
{
var handler = _ActivationProvider.CreateInstance <TEvent>(handlerType);
if (handler == null)
{
throw new Exception(String.Format("Activation provider could not create an instance of event handler: {0}.", handlerType.Name));
}
try
{
if (handlerType.Implements <IConditionallyHandleEvents>())
{
var conditionalHandler = (IConditionallyHandleEvents)handler;
if (conditionalHandler.CanHandle(@event))
{
await conditionalHandler.Handle(@event);
}
}
else if (handlerType.Implements <IHandleEventAsync <TEvent> >())
{
await((IHandleEventAsync <TEvent>)handler).Handle(@event);
}
else
{
((IHandleEvent <TEvent>)handler).Handle(@event);
}
}
catch (Exception ex)
{
if (handler.GetType().Implements <IGracefullyHandleEvent <TEvent> >())
{
((IGracefullyHandleEvent <TEvent>)handler).HandleException(@event, ex);
return;
}
exceptions.Add(ex);
}
}
catch (Exception ex)
{
exceptions.Add(ex);
}
});
if (exceptions.Any())
{
tcs.SetException(new AggregateException(exceptions));
}
else
{
tcs.SetResult(null);
}
return(await tcs.Task);
}
