/// <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); }