public void Subscribe <T>(object subscriber, Action <T> action, SubscriptionKind subscriptionKind) { lock (_sync) { EnsureSubscribersList <T>(); _subscribers[typeof(T)].Add(new WeakDelegate(subscriber, action)); } }
// Note since the Target and Method are not set, the default IEquatable implementation does not produce // accurate results. // DRM: Acutally the IEquatable implementation should be ok -- but need to create unit test to be sure. // TODO: Create unit test to verify that the IEquatable implementation for SubscriptionKeyForBinding produces accurate result. // Creates a new Binding Request. protected SubscriptionKeyGen( ExKeyT ownerPropId, Type propertyType, LocalBindingInfo bindingInfo, SubscriptionKind kind, SubscriptionPriorityGroup subscriptionPriorityGroup, Func <ISubscriptionKeyGen, PSAccessServiceInterface, ISubscription> bindingFactory) { OwnerPropId = ownerPropId; // The binding is created on the target, we will go find the source of the events to listen. PropertyType = PropertyType; SubscriptionKind = kind; SubscriptionPriorityGroup = subscriptionPriorityGroup; //SubscriptionTargetKind = SubscriptionTargetKind.GlobalPropId; //GenDoWhenChanged = null; //Action = null; Target_Wrk = WeakRefKey.Empty; Method = null; SubscriptionFactory = null; BindingFactory = bindingFactory; HasBeenUsed = false; // Properties unique to Binding Subscriptions BindingInfo = bindingInfo; }
// Target and Method. Also used for TypeDelegate and TypedAction. public SubscriptionKeyGen(ExKeyT sourcePropId, Type propertyType, object target, MethodInfo method, SubscriptionKind kind, SubscriptionPriorityGroup subscriptionPriorityGroup, bool keepRef, Func <ISubscriptionKeyGen, IProvideHandlerDispatchDelegateCaches, ISubscription> subscriptionFactory) { OwnerPropId = sourcePropId; PropertyType = propertyType; SubscriptionKind = kind; SubscriptionPriorityGroup = subscriptionPriorityGroup; //SubscriptionTargetKind = GetKindOfTarget(target, keepRef); //GenDoWhenChanged = null; //Action = null; if (target == null) { throw new ArgumentNullException(nameof(target)); } Target_Wrk = new WeakRefKey(target); Method = method ?? throw new ArgumentNullException(nameof(method)); SubscriptionFactory = subscriptionFactory ?? CreateSubscriptionGen; BindingFactory = null; HasBeenUsed = false; }
public MethodSubscriptionKind(MethodInfo method, SubscriptionKind subscriptionKind) : this() { Method = method ?? throw new ArgumentNullException(nameof(method)); SubscriptionKind = subscriptionKind; DelegateType = GetDelegateType(method); _hashCode = ComputeHashCode(); }
public PropDoWhenChangedField(object target, MethodInfo method, SubscriptionKind subscriptionKind, SubscriptionPriorityGroup priorityGroup, bool methodIsLocal, Type declaringType, string fullClassName, string instanceKey) { Target = target; // ?? throw new ArgumentNullException(nameof(target)); Method = method ?? throw new ArgumentNullException(nameof(method)); SubscriptionKind = subscriptionKind; PriorityGroup = priorityGroup; MethodIsLocal = methodIsLocal; DeclaringType = declaringType; // ?? throw new ArgumentNullException(nameof(declaringType)); FullClassName = fullClassName; // ?? throw new ArgumentNullException(nameof(fullClassName)); InstanceKey = instanceKey; // ?? throw new ArgumentNullException(nameof(instanceKey)); MethodName = method.Name; }
public SubscriptionViewModel(IViewContext clientViewContext, Guid subscriptionId, SubscriptionKind kind, string paramUri) { _viewContext = new EntileViewContext(clientViewContext); _subscriptionId = subscriptionId; _viewContext.SetValue("SubscriptionId", _subscriptionId); RegisterLinkAction("Unsubscribe", l => { var action = new UnsubscribeCommand(_viewContext, l.Uri); UnsubscribeCommand = action; }); _kind = kind; _paramUri = paramUri; }
//public Func<object, EventHandler<PcGenEventArgs>> GetTheDoWhenChangedGenHandlerGetter(PropDoWhenChangedField pdwcf, Type propertyType) //{ // Type declaringType = pdwcf.DeclaringType ?? throw new ArgumentNullException(nameof(declaringType)); // string methodName = pdwcf.MethodName ?? throw new ArgumentNullException(nameof(methodName)); // GetGenHandlerRefDelegate GenHandlerRefGetter = GetTheGetGenHandlerDelegate(propertyType); // // Return a function that takes a single input object and returns a reference to the clients EventHandler action. // // The caller does not need to supply the declaringType, nor the methodName, since these are enclosed in the // // new custom function. // return GetTheDoWhenChangedDelegate; // // The declaring type and method name are being enclosed in this nested function, // // which calls the custom delegate: 'GenHandlerRefGetter' just created (or read from the cache.) // EventHandler<PcGenEventArgs> GetTheDoWhenChangedDelegate(object host) // { // EventHandler<PcGenEventArgs> result = GenHandlerRefGetter(host, declaringType, methodName); // return result; // } //} public MethodInfo GetMethodAndSubKind(PropDoWhenChangedField pdwcf, Type propertyType, string propertyName, out SubscriptionKind subscriptionKind) { MethodInfo mi = GetMethodInfo(pdwcf.DeclaringType, pdwcf.MethodName); if (HasPcGenEventHandlerSignature(mi)) { subscriptionKind = SubscriptionKind.GenHandler; return(mi); } else if (HasPcTypedEventHandlerSignature(mi)) { subscriptionKind = SubscriptionKind.TypedHandler; return(mi); } else { throw new ArgumentException($"The method: {mi.Name} on class: {mi.DeclaringType.FullName} doesn't match any of the supported signatures."); } }