/// <summary> /// This method provides an implementation for an <see cref="IComposer{TTarget}"/> /// to handle this event. This checks the <see cref="Participant"/>, and the /// <see cref="Request"/>, and will invoke your <paramref name="composer"/> /// as specified. /// </summary> /// <typeparam name="T">Your <paramref name="composer"/> /// actual (covariant) type.</typeparam> /// <param name="composer">Not null.</param> /// <returns>True if any method was invoked on the <paramref name="composer"/>. /// False if not invoked.</returns> /// <exception cref="ArgumentNullException"></exception> public bool Handle <T>(IComposer <T> composer) where T : TTarget { if (composer == null) { throw new ArgumentNullException(nameof(composer)); } if (Participant == null) { return(false); } IComposer <TTarget> targetComposer = composer as IComposer <TTarget>; switch (Request) { case ParticipantRequest.Add: if (targetComposer != null) { targetComposer.Participate(Participant); return(true); } composer.ParticipateAs(Participant); return(true); case ParticipantRequest.AddOneTimeOnly: if (targetComposer != null) { targetComposer.Participate(Participant, true); return(true); } composer.ParticipateAs(Participant, true); return(true); case ParticipantRequest.Remove: if (targetComposer != null) { targetComposer.Remove(Participant); return(true); } composer.Remove(new VariantParticipant <TTarget, T>(Participant)); return(true); } return(false); }
/// <summary> /// Convenience method that constructs a new <see cref="IProvideParts{TTarget}"/> /// participant that will invoke your action, and participates it with this composer. /// Since this will construct a new participant, the new /// added instance is returned here. /// See also <see cref="DelegateComposerParticipant{TTarget}"/>. /// </summary> /// <typeparam name="TTarget">The type of the target handled /// by the specific <see cref="IComposer{TTarget}"/>.</typeparam> /// <param name="composer">Required.</param> /// <param name="provideParts">Required.</param> /// <param name="oneTimeOnly">Optional.</param> /// <returns>Not null: the added participant.</returns> /// <exception cref="ArgumentNullException"/> public static DelegateComposerParticipant <TTarget> ParticipatePartsDelegate <TTarget>( this IComposer <TTarget> composer, Action <ProvidePartsEventArgs <TTarget> > provideParts, bool oneTimeOnly = false) { if (composer == null) { throw new ArgumentNullException(nameof(composer)); } DelegateComposerParticipant <TTarget> delegateParticipant = new DelegateComposerParticipant <TTarget>(provideParts); composer.Participate(delegateParticipant, oneTimeOnly); return(delegateParticipant); }
/// <summary> /// Convenience method that constructs a new <see cref="IBootstrap{TTarget}"/> /// participant that will invoke your action, and participates it with this composer. /// Since this will construct a new participant, the new /// added instance is returned here. /// See also <see cref="DelegateComposerParticipant{TTarget}"/>. /// </summary> /// <typeparam name="TTarget">The type of the target handled /// by the specific <see cref="IComposer{TTarget}"/>.</typeparam> /// <param name="composer">Required.</param> /// <param name="bootstrap">Required.</param> /// <param name="oneTimeOnly">Optional.</param> /// <returns>Not null: the added participant.</returns> /// <exception cref="ArgumentNullException"/> public static DelegateComposerParticipant <TTarget> ParticipateBootstrapDelegate <TTarget>( this IComposer <TTarget> composer, Action <ComposerEventArgs <TTarget> > bootstrap, bool oneTimeOnly = false) { if (composer == null) { throw new ArgumentNullException(nameof(composer)); } DelegateComposerParticipant <TTarget> delegateParticipant = new DelegateComposerParticipant <TTarget>(null, bootstrap); composer.Participate(delegateParticipant, oneTimeOnly); return(delegateParticipant); }
/// <summary> /// Convenience method that constructs a new <see cref="IRequestComposition{TTarget}"/> /// participant that will raise the <see cref="IRequestComposition{TTarget}.CompositionRequested"/> /// event, and participates it with this composer. /// Since this will construct a new participant, the new /// added instance is returned here. /// See also <see cref="DelegateComposerParticipant{TTarget}"/>. /// </summary> /// <typeparam name="TTarget">The type of the target handled /// by the specific <see cref="IComposer{TTarget}"/>.</typeparam> /// <param name="composer">Required.</param> /// <param name="requestComposition">Will be set to an action that will /// raise the <see cref="IRequestComposition{TTarget}.CompositionRequested"/> /// event from the returned participant.</param> /// <param name="oneTimeOnly">Optional.</param> /// <returns>Not null: the added participant.</returns> /// <exception cref="ArgumentNullException"/> public static DelegateComposerParticipant <TTarget> ParticipateRequestCompositionDelegate <TTarget>( this IComposer <TTarget> composer, out Action <RequestCompositionEventArgs <TTarget> > requestComposition, bool oneTimeOnly = false) { if (composer == null) { throw new ArgumentNullException(nameof(composer)); } DelegateComposerParticipant <TTarget> delegateParticipant = new DelegateComposerParticipant <TTarget>(out requestComposition); composer.Participate(delegateParticipant, oneTimeOnly); return(delegateParticipant); }
/// <summary> /// This helper method will check and construct a new variant participant, that /// implements the composer's covariant type, and contributes all supported interfaces to /// the composer. Since this will construct a new participant, the actual /// added instance is returned here. /// </summary> /// <typeparam name="TSuper">The delegate's actual type.</typeparam> /// <typeparam name="TTarget">This composer's implemented type.</typeparam> /// <param name="composer">Required.</param> /// <param name="participant">Required.</param> /// <param name="oneTimeOnly">Optional.</param> /// <returns>The actual added instance.</returns> /// <exception cref="ArgumentNullException"/> public static VariantParticipant <TSuper, TTarget> ParticipateAs <TSuper, TTarget>( this IComposer <TTarget> composer, IComposerParticipant <TSuper> participant, bool oneTimeOnly = false) where TTarget : TSuper { if (composer == null) { throw new ArgumentNullException(nameof(composer)); } VariantParticipant <TSuper, TTarget> variantParticipant = new VariantParticipant <TSuper, TTarget>(participant); composer.Participate(variantParticipant, oneTimeOnly); return(variantParticipant); }
/// <summary> /// Convenience method that constructs a new /// <see cref="AggregateComposerParticipant{TTarget}"/> from the /// given list, and participates it with your composer. All interfaces /// implemented by your participants will be invoked. Since this /// will construct a new participant, the actual /// added instance is returned here. /// </summary> /// <typeparam name="TTarget">The type of the target handled /// by the specific <see cref="IComposer{TTarget}"/>.</typeparam> /// <param name="composer">Required.</param> /// <param name="participants">Required.</param> /// <param name="oneTimeOnly">Optional.</param> /// <param name="disposeParticipantsWithAggregate">Defaults to true: the participants /// will be disposed with this new aggregate participant.</param> /// <returns>Not null.</returns> /// <exception cref="ArgumentNullException"/> public static AggregateComposerParticipant <TTarget> Aggregate <TTarget>( this IComposer <TTarget> composer, IEnumerable <IComposerParticipant <TTarget> > participants, bool oneTimeOnly = false, bool disposeParticipantsWithAggregate = true) { if (composer == null) { throw new ArgumentNullException(nameof(composer)); } AggregateComposerParticipant <TTarget> aggregateParticipant = new AggregateComposerParticipant <TTarget>(participants) { DisposeParticipantsWithThis = disposeParticipantsWithAggregate }; composer.Participate(aggregateParticipant, oneTimeOnly); return(aggregateParticipant); }
/// <summary> /// Convenience method contributes each participant to your composer. /// </summary> /// <typeparam name="TTarget">The type of the target handled /// by the specific <see cref="IComposer{TTarget}"/>.</typeparam> /// <param name="composer">Required.</param> /// <param name="participants">Required.</param> /// <param name="oneTimeOnly">Optional.</param> /// <returns>Your composer.</returns> /// <exception cref="ArgumentNullException"/> public static IComposer <TTarget> ParticipateRange <TTarget>( this IComposer <TTarget> composer, IEnumerable <IComposerParticipant <TTarget> > participants, bool oneTimeOnly = false) { if (composer == null) { throw new ArgumentNullException(nameof(composer)); } if (participants == null) { throw new ArgumentNullException(nameof(participants)); } foreach (IComposerParticipant <TTarget> composerParticipant in participants) { composer.Participate(composerParticipant, oneTimeOnly); } return(composer); }