/// <summary> /// Unregisters a specific recipient for a specific message with the specified tag. /// </summary> /// <typeparam name="TMessage">The type of the message.</typeparam> /// <param name="recipient">The recipient to unregister.</param> /// <param name="handler">The handler method.</param> /// <param name="tag">The message tag.</param> /// <returns><c>true</c> if the handler is unregistered successfully; otherwise <c>false</c>.</returns> /// <remarks> /// A handler cannot be unregistered when it is not registered first. If a handler is unregistered while it /// is not registered, this method will return <c>false</c>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="handler"/> is <c>null</c>.</exception> public bool Unregister <TMessage>(object recipient, Action <TMessage> handler, object tag = null) { Argument.IsNotNull("handler", handler); lock (_lockObject) { var messageType = typeof(TMessage); if (_registeredHandlers.ContainsKey(messageType)) { var messageHandlers = _registeredHandlers[messageType]; for (int i = 0; i < messageHandlers.Count; i++) { var handlerInfo = messageHandlers[i]; var weakAction = (IWeakAction <TMessage>)handlerInfo.Action; if (TagHelper.AreTagsEqual(tag, handlerInfo.Tag) && AreEqualHandlers(handler, weakAction)) { messageHandlers.RemoveAt(i--); Log.Debug("Unregistered handler for message type '{0}' with tag '{1}'", messageType.Name, ObjectToStringHelper.ToString(tag)); return(true); } } } Log.Warning("Failed to unregister handler for message type '{0}' with tag '{1}' because handler was not registered", messageType.Name, ObjectToStringHelper.ToString(tag)); return(false); } }
/// <summary> /// Determines whether the specified <see cref="System.Object" /> is equal to this instance. /// </summary> /// <param name="obj">The <see cref="T:System.Object" /> to compare with the current <see cref="T:System.Object" />.</param> /// <returns><c>true</c> if the specified <see cref="System.Object" /> is equal to this instance; otherwise, <c>false</c>.</returns> public override bool Equals(object obj) { if (ReferenceEquals(null, obj)) { return(false); } if (ReferenceEquals(this, obj)) { return(true); } if (obj.GetType() != GetType()) { return(false); } var other = (TypeRequestInfo)obj; if (Type != other.Type) { return(false); } if (!TagHelper.AreTagsEqual(Tag, other.Tag)) { return(false); } return(true); }
/// <summary> /// Unregisters a specific recipient for all the (non-static) message the recipient is subscribed to. /// </summary> /// <param name="recipient">The recipient to unregister.</param> /// <param name="tag">The message tag.</param> /// <param name="ignoreTag">If set to <c>true</c>, tags are ignored.</param> /// <returns><c>true</c> if the handler is unregistered successfully; otherwise <c>false</c>.</returns> /// <exception cref="ArgumentNullException">The <paramref name="recipient"/> is <c>null</c>.</exception> /// <remarks>A handler cannot be unregistered when it is not registered first. If a handler is unregistered while it /// is not registered, this method will return <c>false</c>.</remarks> public bool UnregisterRecipient(object recipient, object tag, bool ignoreTag) { Argument.IsNotNull("recipient", recipient); lock (_lockObject) { int handlerCounter = 0; var keys = _registeredHandlers.Keys.ToList(); foreach (var key in keys) { var messageHandlers = _registeredHandlers[key]; for (int i = 0; i < messageHandlers.Count; i++) { var handlerInfo = messageHandlers[i]; var weakReference = (IWeakReference)handlerInfo.Action; if (ignoreTag || TagHelper.AreTagsEqual(tag, handlerInfo.Tag)) { if (ReferenceEquals(recipient, weakReference.Target)) { messageHandlers.RemoveAt(i--); handlerCounter++; Log.Debug("Unregistered handler for message type '{0}' with tag '{1}'", key.Name, ObjectToStringHelper.ToString(tag)); } } } } Log.Debug("Unregistered '{0}' handlers for the recipient with tag '{1}'", handlerCounter, ObjectToStringHelper.ToString(tag)); return(true); } }
/// <summary> /// Broadcasts a message to all message targets for a given message tag and passes a parameter. /// </summary> /// <typeparam name="TMessage">The type of the message.</typeparam> /// <param name="message">The message parameter.</param> /// <param name="tag">The message tag.</param> /// <returns> /// <c>true</c> if any handlers were invoked; otherwise <c>false</c>. /// </returns> /// <exception cref="ArgumentNullException">The <paramref name="message"/> is <c>null</c>.</exception> public bool SendMessage <TMessage>(TMessage message, object tag = null) { Argument.IsNotNull("message", message); Log.Debug("Sending message of type '{0}' with tag '{1}'", message.GetType().FullName, ObjectToStringHelper.ToString(tag)); int invokedHandlersCount = 0; lock (_lockObject) { var messageType = typeof(TMessage); if (_registeredHandlers.ContainsKey(messageType)) { // CTL-311: first convert to array, then handle messages var messageHandlers = _registeredHandlers[messageType].ToArray(); foreach (var handler in messageHandlers) { if (TagHelper.AreTagsEqual(tag, handler.Tag)) { if (handler.Action.ExecuteWithObject(message)) { invokedHandlersCount++; } } } } } Log.Debug("Sent message to {0} recipients", invokedHandlersCount); CleanUp(); return(invokedHandlersCount != 0); }
/// <summary> /// Processes the specified types to register. /// </summary> /// <param name="typesToRegister">The types to register.</param> /// <exception cref="System.ArgumentNullException">The <paramref name="typesToRegister" /> is <c>null</c>.</exception> public override void Process(IEnumerable <Type> typesToRegister) { Argument.IsNotNull("typesToRegister", typesToRegister); var typesToHandle = typesToRegister as Type[] ?? typesToRegister.ToArray(); var interfaceTypes = typesToHandle.Select(type => { if (type.IsInterfaceEx() && type.Name.StartsWith("I")) { var implementationType = typesToHandle.FirstOrDefault(row => TagHelper.AreTagsEqual(row.Name, type.Name.Replace("I", string.Empty).Trim()) && row.IsClassEx() && type.IsAssignableFromEx(row)); if (implementationType != null) { return(new { InterfaceType = type, ImplementationType = implementationType }); } } return(null); }).Where(type => type != null); interfaceTypes.ForEach(type => { Log.Debug("Applying '{0}' on '{1}'", GetType().Name, type.InterfaceType); Container.RegisterType(type.InterfaceType, type.ImplementationType, registrationType: RegistrationType); }); }
/// <summary> /// Determines whether the specified recipient is registered. /// </summary> /// <typeparam name="TMessage">The type of the message.</typeparam> /// <param name="recipient">The recipient.</param> /// <param name="handler">The handler.</param> /// <param name="tag">The tag.</param> /// <returns> /// <c>true</c> if the specified recipient is registered; otherwise, <c>false</c>. /// </returns> /// <exception cref="ArgumentNullException">The <paramref name="handler"/> is <c>null</c>.</exception> public bool IsRegistered <TMessage>(object recipient, Action <TMessage> handler, object tag = null) { Argument.IsNotNull("handler", handler); lock (_lockObject) { var messageType = typeof(TMessage); if (_registeredHandlers.ContainsKey(messageType)) { var messageHandlers = _registeredHandlers[messageType]; for (int i = 0; i < messageHandlers.Count; i++) { var handlerInfo = messageHandlers[i]; var weakAction = (IWeakAction <TMessage>)handlerInfo.Action; var target = weakAction.Target; if (target != null) { if (!ReferenceEquals(recipient, target)) { continue; } } if (TagHelper.AreTagsEqual(tag, handlerInfo.Tag) && AreEqualHandlers(handler, weakAction)) { return(true); } } } } return(false); }
/// <summary> /// Gets the document. /// </summary> /// <param name="docingManager">The docing manager .</param> /// <param name="viewType">Type of the view.</param> /// <param name="tag">The tag.</param> /// <returns> /// The found document or <c>null</c> if no document was found. /// </returns> /// <exception cref="ArgumentNullException">The <paramref name="docingManager" /> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">The <paramref name="docingManager" /> is <c>null</c>.</exception> public static LayoutAnchorable FindDocument(DockingManager docingManager, Type viewType, object tag = null) { Argument.IsNotNull("docingManager", docingManager); Argument.IsNotNull("viewType", viewType); LayoutAnchorable doc = null; var documents = docingManager.Layout.Descendents().OfType <LayoutAnchorable>(); foreach (var layoutAnchorable in documents) { var content = layoutAnchorable.Content as IDockingManagerContainer; if (content != null) { var nestedDockingManager = content; if (nestedDockingManager.IsActive) { doc = FindDocument(nestedDockingManager.DockingManager, viewType, tag); break; } } if (layoutAnchorable.Content.GetType() == viewType && TagHelper.AreTagsEqual(tag, ((IView)layoutAnchorable.Content).Tag)) { doc = layoutAnchorable; break; } } return(doc); }
public void ReturnsFalseForDifferentInstances() { var firstEntry = ModelBaseTestHelper.CreateIniEntryObject("A", "B", "C"); var secondEntry = ModelBaseTestHelper.CreateIniEntryObject("D", "E", "F"); Assert.IsFalse(TagHelper.AreTagsEqual(firstEntry, secondEntry)); }
/// <summary> /// Finds the anchorable with the specified name. /// </summary> /// <param name="name"> /// The name of the anchorable. /// </param> /// <param name="throwExceptionWhenNotFound"> /// If set to <c>true</c>, this method will throw an <see cref="InvalidOperationException"/> when the anchorable cannot be found. /// </param> /// <returns> /// The <see cref="LayoutAnchorable"/> or <c>null</c> if the anchorable cannot be found. /// </returns> /// <exception cref="ArgumentException"> /// The <paramref name="name"/> is <c>null</c> or whitespace. /// </exception> static private LayoutAnchorable FindAnchorable(string name, bool throwExceptionWhenNotFound = false) { Argument.IsNotNullOrWhitespace("name", name); var visibleAnchorable = (from child in DockingManager.Layout.Children where child is LayoutAnchorable && TagHelper.AreTagsEqual(((LayoutAnchorable)child).ContentId, name) select(LayoutAnchorable) child).FirstOrDefault(); if (visibleAnchorable != null) { return(visibleAnchorable); } var invisibleAnchorable = (from child in DockingManager.Layout.Hidden where TagHelper.AreTagsEqual((child).ContentId, name) select child).FirstOrDefault(); if (invisibleAnchorable != null) { return(invisibleAnchorable); } if (throwExceptionWhenNotFound) { string error = string.Format("Anchorable with name '{0}' cannot be found", name); Log.Error(error); throw new InvalidOperationException(error); } return(null); }
/// <summary> /// Gets the document. /// </summary> /// <param name="viewType">Type of the view.</param> /// <param name="tag">The tag.</param> /// <returns>The found document or <c>null</c> if no document was found.</returns> /// <exception cref="ArgumentNullException">The <paramref name="viewType"/> is <c>null</c>.</exception> public static CustomLayoutDocument FindDocument(Type viewType, object tag = null) { Argument.IsNotNull("viewType", viewType); return((from document in LayoutDocumentPane.Children where document is LayoutDocument && document.Content.GetType() == viewType && TagHelper.AreTagsEqual(tag, ((IView)document.Content).Tag) select document).Cast <CustomLayoutDocument>().FirstOrDefault()); }
/// <summary> /// Gets all the business rule validations with the specified tag. /// </summary> /// <param name="tag">The tag.</param> /// <returns> /// List of <see cref="IBusinessRuleValidationResult"/> items. /// </returns> public List <IBusinessRuleValidationResult> GetBusinessRuleValidations(object tag) { lock (_businessRuleValidations) { var list = (from validation in _businessRuleValidations where TagHelper.AreTagsEqual(validation.Tag, tag) select validation).ToList(); return(list); } }
/// <summary> /// Gets all the field validations with the specified tag. /// </summary> /// <param name="tag">The tag.</param> /// <returns>List of <see cref="IFieldValidationResult" /> items.</returns> public List <IFieldValidationResult> GetFieldValidations(object tag) { lock (_fieldValidations) { var list = (from validation in _fieldValidations where TagHelper.AreTagsEqual(validation.Tag, tag) select validation).ToList(); return(list); } }
public void ReturnsTrueForEqualInstances() { var firstEntry = ModelBaseTestHelper.CreateIniEntryObject("A", "B", "C"); var secondEntry = ModelBaseTestHelper.CreateIniEntryObject("A", "B", "C"); // References equal Assert.IsTrue(TagHelper.AreTagsEqual(firstEntry, firstEntry)); // Objects equal Assert.IsTrue(TagHelper.AreTagsEqual(firstEntry, secondEntry)); }
/// <summary> /// Determines whether the specified message type is registered. /// </summary> /// <param name="messageType">The type of the message.</param> /// <param name="tag">The tag.</param> /// <returns> /// <c>true</c> if the message type is registered; otherwise, <c>false</c>. /// </returns> /// <exception cref="ArgumentNullException">The <paramref name="messageType"/> is <c>null</c>.</exception> public bool IsMessageRegistered(Type messageType, object tag = null) { Argument.IsNotNull("messageType", messageType); lock (_lockObject) { if (_registeredHandlers.TryGetValue(messageType, out var messageHandlers)) { return(messageHandlers.Any(handlerInfo => TagHelper.AreTagsEqual(tag, handlerInfo.Tag))); } return(false); } }
public void MustExistsForRegisteredViewModels() { var firstvm = new TestViewModel(); var secondvm = new TestViewModel(); var vmManager = new ViewModelManager(); vmManager.RegisterViewModelInstance(firstvm); vmManager.RegisterViewModelInstance(secondvm); var vmList = vmManager.ActiveViewModels.ToList(); Assert.IsTrue(vmList.Any(vm => TagHelper.AreTagsEqual(vm.UniqueIdentifier, firstvm.UniqueIdentifier))); Assert.IsTrue(vmList.Any(vm => TagHelper.AreTagsEqual(vm.UniqueIdentifier, secondvm.UniqueIdentifier))); }
/// <summary> /// Gets all the field validations for the specified property name with the specified tag. /// </summary> /// <param name="propertyName">Name of the property.</param> /// <param name="tag">The tag.</param> /// <returns>List of <see cref="IFieldValidationResult" /> items.</returns> /// <exception cref="ArgumentException">The <paramref name="propertyName" /> is <c>null</c> or whitespace.</exception> public List <IFieldValidationResult> GetFieldValidations(string propertyName, object tag) { Argument.IsNotNullOrWhitespace("propertyName", propertyName); lock (_fieldValidations) { var list = (from validation in _fieldValidations where string.Equals(validation.PropertyName, propertyName, StringComparison.OrdinalIgnoreCase) && TagHelper.AreTagsEqual(validation.Tag, tag) select validation).ToList(); return(list); } }
/// <summary> /// Determines whether the specified message type is registered. /// </summary> /// <param name="messageType">The type of the message.</param> /// <param name="tag">The tag.</param> /// <returns> /// <c>true</c> if the message type is registered; otherwise, <c>false</c>. /// </returns> /// <exception cref="ArgumentNullException">The <paramref name="messageType"/> is <c>null</c>.</exception> public bool IsMessageRegistered(Type messageType, object tag = null) { Argument.IsNotNull("messageType", messageType); lock (_lockObject) { if (_registeredHandlers.ContainsKey(messageType)) { var messageHandlers = _registeredHandlers[messageType]; return(messageHandlers.Any(handlerInfo => TagHelper.AreTagsEqual(tag, handlerInfo.Tag))); } return(false); } }
/// <summary> /// Finds the anchorable with the specified name. /// </summary> /// <param name="name">The name of the anchorable.</param> /// <param name="throwExceptionWhenNotFound">if set to <c>true</c>, this method will throw an <see cref="InvalidOperationException"/> when the anchorable cannot be found.</param> /// <returns>The <see cref="LayoutAnchorable"/> or <c>null</c> if the anchorable cannot be found.</returns> /// <exception cref="ArgumentException">The <paramref name="name"/> is <c>null</c> or whitespace.</exception> private LayoutAnchorable FindAnchorable(string name, bool throwExceptionWhenNotFound = false) { Argument.IsNotNullOrWhitespace("name", name); var result = (from anchorable in dockingManager.AnchorablesSource.Cast <LayoutAnchorable>() where TagHelper.AreTagsEqual(anchorable.ContentId, name) select anchorable).FirstOrDefault(); if (throwExceptionWhenNotFound && result == null) { string error = string.Format("Anchorable with name '{0}' cannot be found", name); Log.Error(error); throw new InvalidOperationException(error); } return(result); }
/// <summary> /// Gets all the field and business rule validations with the specified tag. /// </summary> /// <param name="tag">The tag.</param> /// <returns> /// List of <see cref="IValidationResult"/> items. /// </returns> public List <IValidationResult> GetValidations(object tag) { var list = new List <IValidationResult>(); lock (_fieldValidations) { list.AddRange(from validation in _fieldValidations where TagHelper.AreTagsEqual(validation.Tag, tag) select validation as IValidationResult); } lock (_businessRuleValidations) { list.AddRange(from validation in _businessRuleValidations where TagHelper.AreTagsEqual(validation.Tag, tag) select validation as IValidationResult); } return(list); }
/// <summary> /// Determines whether the specified recipient is registered. /// </summary> /// <typeparam name="TMessage">The type of the message.</typeparam> /// <param name="recipient">The recipient.</param> /// <param name="handler">The handler.</param> /// <param name="tag">The tag.</param> /// <returns> /// <c>true</c> if the specified recipient is registered; otherwise, <c>false</c>. /// </returns> /// <exception cref="ArgumentNullException">The <paramref name="handler"/> is <c>null</c>.</exception> public bool IsRegistered <TMessage>(object recipient, Action <TMessage> handler, object tag = null) { Argument.IsNotNull("handler", handler); lock (_lockObject) { var messageType = typeof(TMessage); List <WeakActionInfo> messageHandlers; if (_registeredHandlers.TryGetValue(messageType, out messageHandlers)) { for (int i = messageHandlers.Count - 1; i >= 0; i--) { var handlerInfo = messageHandlers[i]; var weakAction = (IWeakAction <TMessage>)handlerInfo.Action; if (!weakAction.IsTargetAlive) { messageHandlers.RemoveAt(i); continue; } var target = weakAction.Target; if (target != null) { if (!ReferenceEquals(recipient, target)) { continue; } } if (TagHelper.AreTagsEqual(tag, handlerInfo.Tag) && AreEqualHandlers(handler, weakAction)) { return(true); } } } } return(false); }
/// <summary> /// Remove all registered instances. /// </summary> /// <param name="tag">The tag of the registered the service. The default value is <c>null</c>.</param> public void RemoveAllInstances(object tag = null) { lock (_syncObject) { if (tag == null) { _registeredInstances.Clear(); } else { for (int i = _registeredInstances.Count - 1; i >= 0; i--) { var serviceInfo = _registeredInstances.Keys.ElementAt(i); if (TagHelper.AreTagsEqual(serviceInfo.Tag, tag)) { _registeredInstances.Remove(serviceInfo); } } } } }
/// <summary> /// Determines whether the specified <see cref="System.Object" /> is equal to this instance. /// </summary> /// <param name="obj">The <see cref="System.Object" /> to compare with this instance.</param> /// <returns> /// <c>true</c> if the specified <see cref="System.Object" /> is equal to this instance; otherwise, <c>false</c>. /// </returns> public override bool Equals(object obj) { if (obj == null) { return(false); } var memberDefinition = obj as IMemberDefinition; if (memberDefinition == null) { return(false); } if (Parameters.Count != memberDefinition.Parameters.Count) { return(false); } return(!Parameters.Where((parameter, index) => !parameter.IsGenericParameter && parameter != memberDefinition.Parameters[index]).Any() && TagHelper.AreTagsEqual(MemberName, memberDefinition.MemberName)); }
public void ReturnsTrueForBothNull() { Assert.IsTrue(TagHelper.AreTagsEqual(null, null)); }
public void ReturnsTrueForEqualStrings() { Assert.IsTrue(TagHelper.AreTagsEqual("Catel", "Catel")); }
public void ReturnsFalseForDifferentCasingStrings() { Assert.IsFalse(TagHelper.AreTagsEqual("Catel", "catel")); }