protected override IList <IEntityStateEntry> GetChanges(OrderModel entity) { var changes = new List <IEntityStateEntry>(base.GetChanges(entity)); List <ProductModel> selectedItems = GridViewModel .OriginalItemsSource .Where(wrapper => wrapper.IsSelected) .Select(wrapper => wrapper.Model) .ToList(); var oldLinks = new List <OrderProductModel>(_oldLinks ?? Empty.Array <OrderProductModel>()); //Adding new items that was selected. foreach (ProductModel selectedItem in selectedItems) { OrderProductModel oldItem = oldLinks.SingleOrDefault(model => model.IdOrder == selectedItem.Id); if (oldItem == null) { var productModel = new OrderProductModel { IdOrder = Entity.Id, IdProduct = selectedItem.Id }; changes.Add(new EntityStateEntry(EntityState.Added, productModel)); } else { oldLinks.Remove(oldItem); } } //Removing old items that was unselected. changes.AddRange(oldLinks.Select(model => new EntityStateEntry(EntityState.Deleted, model))); return(changes); }
/// <summary> /// Gets the collection of observers. /// </summary> public IList <object> GetObservers() { if (_handlerReferences.Count == 0) { return(Empty.Array <object>()); } var objects = new List <object>(_handlerReferences.Count); lock (_handlerReferences) { for (int index = 0; index < _handlerReferences.Count; index++) { var handler = (HandlerInfo)_handlerReferences[index].Target; if (handler == null) { _handlerReferences.RemoveAt(index); index--; } else { objects.Add(handler.Target); } } } return(objects); }
protected override void OnDetached() { EventHandler <IObserver, ValueChangedEventArgs> handler = OnBindingSourceValueChanged; var accessor = Binding.SourceAccessor as ISingleBindingSourceAccessor; if (accessor == null) { var sources = Binding.SourceAccessor.Sources; for (int index = 0; index < sources.Count; index++) { sources[index].ValueChanged -= handler; } } else { accessor.Source.ValueChanged -= handler; } UpdateSources(true); lock (_subscribers) { // Ensure that all concurrent adds have completed. } var context = new DataContext(Binding.Context); context.AddOrUpdate(BindingConstants.ClearErrors, true); UpdateErrors(Empty.Array <object>(), context); }
public virtual IList <KeyValuePair <string, object> > GetValues(object item, Func <string, object, bool> predicate) { Should.NotBeNull(item, "item"); LightDictionaryBase <string, object> dictionary = GetOrAddAttachedDictionary(item, false); if (dictionary == null) { return(Empty.Array <KeyValuePair <string, object> >()); } lock (dictionary) { if (predicate == null) { return(new List <KeyValuePair <string, object> >(dictionary)); } var list = new List <KeyValuePair <string, object> >(); foreach (var keyValue in dictionary) { if (predicate(keyValue.Key, keyValue.Value)) { list.Add(keyValue); } } return(list); } }
public IList <object> GetNotifiers() { if (!HasCanExecuteImpl) { return(Empty.Array <object>()); } var objects = new List <object>(); lock (_notifiers) { for (int i = 0; i < _notifiers.Count; i++) { var target = _notifiers[i].Key.Target; if (target == null) { _notifiers.RemoveAt(i); i--; } else { objects.Add(target); } } } return(objects); }
public virtual IList <ISubscriber> GetSubscribers() { if (_subscribers.Count == 0) { return(Empty.Array <ISubscriber>()); } lock (_subscribers) { var subscribers = new List <ISubscriber>(_subscribers.Count); for (int i = 0; i < _subscribers.Count; i++) { ISubscriber subscriber = _subscribers[i]; if (subscriber.IsAlive) { subscribers.Add(subscriber); } else { _subscribers.RemoveAt(i); --i; } } return(subscribers); } }
/// <summary> /// Sets errors for binding target. /// </summary> /// <param name="target">The binding target object.</param> /// <param name="senderKey">The source of the errors.</param> /// <param name="errors">The collection of errors</param> /// <param name="context">The specified context, if any.</param> public void SetErrors(object target, string senderKey, IList <object> errors, IDataContext context) { Should.NotBeNull(target, "target"); Should.NotBeNull(senderKey, "senderKey"); var dict = GetOrAddErrorsDictionary(target); if (errors == null || errors.Count == 0) { dict.Remove(senderKey); } else { dict[senderKey] = errors; } if (dict.Count == 0) { errors = Empty.Array <object>(); } else if (dict.Count == 1) { errors = dict.FirstOrDefault().Value; } else { errors = dict.SelectMany(list => list.Value).ToList(); } SetErrors(target, errors, context ?? DataContext.Empty); }
public void SetUp() { ServiceProvider.DesignTimeManager = DesignTimeManagerImpl.Instance; ServiceProvider.AttachedValueProvider = new AttachedValueProvider(); CanBeResolvedTypes = new List <Type> { typeof(IThreadManager), typeof(IViewModelSettings), typeof(IViewManager), typeof(IDisplayNameProvider), typeof(IViewModelProvider), typeof(IVisualStateManager), typeof(OperationCallbackManagerMock) }; OperationCallbackManager = new OperationCallbackManagerMock(); ViewManager = new ViewManagerMock(); ThreadManager = new ThreadManagerMock(); ServiceProvider.ThreadManager = ThreadManager; Settings = new ViewModelSettingsMock(); DisplayNameProvider = new DisplayNameProviderMock(); IocContainer = new IocContainerMock { GetFunc = GetFunc, CanResolveDelegate = CanResolve }; Tracer.TraceInformation = true; ServiceProvider.Tracer = new ConsoleTracer(); ViewModelProvider = new ViewModelProvider(IocContainer); OnInit(); var app = new UnitTestApp(this); app.Initialize(PlatformInfo.UnitTest, IocContainer, Empty.Array <Assembly>(), DataContext.Empty); }
private void UpdateValues() { if (_templateSelectorMember != null) { _templateSelector = _templateSelectorMember.GetValue(_container, Empty.Array <object>()) as TItem; } }
private static IList <IValidationResult> ValidateElements(ICollection <IValidationElement> elements, IValidationContext context) { if (elements.Count == 0) { return(Empty.Array <IValidationResult>()); } var results = new List <IValidationResult>(); foreach (IValidationElement validationElement in elements) { IEnumerable <IValidationResult> validationResults = validationElement.Validate(context); if (validationResults == null) { continue; } foreach (var result in validationResults) { if (result != null && !result.IsValid) { results.Add(result); } } } return(results); }
/// <summary> /// Clear the stored data. /// </summary> public void Clear() { if ((_data == null) || (_data.Length != 0)) { _data = Empty.Array <byte>(); } }
/// <summary> /// Tries to register type. /// </summary> protected override void RegisterType(Type type) { base.RegisterType(type); if (!typeof(IValueConverter).IsAssignableFrom(type) || !type.IsPublicNonAbstractClass()) { return; } #if NETFX_CORE || WINDOWSCOMMON var constructor = type.GetTypeInfo().DeclaredConstructors.FirstOrDefault(info => !info.IsStatic && info.GetParameters().Length == 0); #else var constructor = type.GetConstructor(Empty.Array <Type>()); #endif if (constructor == null || !constructor.IsPublic) { return; } var converter = (IValueConverter)constructor.InvokeEx(); string name = RemoveTail(RemoveTail(type.Name, "ValueConverter"), "Converter"); if (BindingServiceProvider.ResourceResolver.TryAddConverter(name, new ValueConverterWrapper(converter.Convert, converter.ConvertBack))) { Tracer.Info("The {0} converter is registered.", type); } }
AssemblyNameReference ImportAssemblyName(AssemblyNameReference name) { AssemblyNameReference reference; if (TryGetAssemblyNameReference(name, out reference)) { return(reference); } reference = new AssemblyNameReference(name.Name, name.Version) { Culture = name.Culture, HashAlgorithm = name.HashAlgorithm, }; var pk_token = !name.PublicKeyToken.IsNullOrEmpty() ? new byte [name.PublicKeyToken.Length] : Empty.Array <byte>(); if (pk_token.Length > 0) { Buffer.BlockCopy(name.PublicKeyToken, 0, pk_token, 0, pk_token.Length); } reference.PublicKeyToken = pk_token; module.AssemblyReferences.Add(reference); return(reference); }
public void empty_array_returns_empty_array() { var array = Empty.Array <int>(); array.ShouldNotBeNull(); array.ShouldBeEmpty(); }
protected override void RegisterType(Type type) { base.RegisterType(type); if (BindingServiceProvider.DisableConverterAutoRegistration) { return; } var typeInfo = type.GetTypeInfo(); if (!typeof(IValueConverter).GetTypeInfo().IsAssignableFrom(typeInfo) || !type.IsPublicNonAbstractClass()) { return; } var constructor = type.GetConstructor(Empty.Array <Type>()); if (constructor == null || !constructor.IsPublic) { return; } var converter = (IValueConverter)constructor.InvokeEx(); BindingServiceProvider.ResourceResolver.AddConverter(new ValueConverterWrapper(converter), type, true); if (Tracer.TraceInformation) { Tracer.Info("The {0} converter is registered.", type); } }
private static IList <object> ValidateElements(List <IValidationElement> elements, ValidationContext context) { if (elements.Count == 0) { return(Empty.Array <object>()); } var results = new List <object>(); for (int index = 0; index < elements.Count; index++) { var validationResults = elements[index].Validate(context); if (validationResults == null) { continue; } foreach (var result in validationResults) { if (result != null) { results.Add(result); } } } return(results); }
public void SetUp() { ServiceProvider.AttachedValueProvider = new AttachedValueProvider(); ServiceProvider.ViewModelSettingsFactory = model => new DefaultViewModelSettings(); ServiceProvider.ReflectionManager = new ExpressionReflectionManager(); CanBeResolvedTypes = new List <Type> { typeof(IThreadManager), typeof(IViewManager), typeof(IDisplayNameProvider), typeof(IViewModelProvider), typeof(OperationCallbackManagerMock), typeof(INavigationDispatcher), typeof(IViewModelPresenter) }; OperationCallbackManager = new OperationCallbackManagerMock(); NavigationDispatcher = new NavigationDispatcherMock(); ViewManager = new ViewManagerMock(); ThreadManager = new ThreadManagerMock(); ViewModelPresenter = new ViewModelPresenterMock(); ServiceProvider.ThreadManager = ThreadManager; DisplayNameProvider = new DisplayNameProviderMock(); IocContainer = new IocContainerMock { GetFunc = GetFunc, CanResolveDelegate = CanResolve }; Tracer.TraceInformation = true; ServiceProvider.Tracer = new ConsoleTracer(); ViewModelProvider = new ViewModelProvider(IocContainer); OnInit(); var app = new UnitTestApp(); app.Initialize(PlatformInfo.UnitTest, IocContainer, Empty.Array <Assembly>(), DataContext.Empty); }
public static string GenerateRestorationIdentifier(object item, bool checkRestoreMethodOverload) { Type type = item.GetType(); int value; lock (TypeToCounters) { if (!TypeToCounters.TryGetValue(type, out value)) { if (typeof(UIViewController).IsAssignableFrom(type) || typeof(UIView).IsAssignableFrom(type)) { var method = type.GetMethod("EncodeRestorableState", BindingFlags.Public | BindingFlags.Instance, null, CoderParameters, Empty.Array <ParameterModifier>()); if (method != null && (method.DeclaringType == typeof(UIViewController) || method.DeclaringType == typeof(UIView))) { value = int.MinValue; TypeToCounters[type] = value; } } } if (checkRestoreMethodOverload && value < 0) { Tracer.Warn("The item '{0}' not support the preservation of the state since it does not have overloaded methods (EncodeRestorableState, DecodeRestorableState).", type.Name); return(null); } TypeToCounters[type] = value + 1; } return(type.AssemblyQualifiedName + "~" + value.ToString(CultureInfo.InvariantCulture)); }
private void EnsureCapacity(int min) { if (_items.Length >= min) { return; } var value = _items.Length == 0 ? 2 : _items.Length + 1; if (value < _size) { throw ExceptionManager.CapacityLessThanCollection("Capacity"); } if (value == _items.Length) { return; } if (value > 0) { var objArray = new IBindingBehavior[value]; if (_size > 0) { Array.Copy(_items, 0, objArray, 0, _size); } _items = objArray; } else { _items = Empty.Array <IBindingBehavior>(); } }
internal static object[] GetIndexerValues(string path, IList <ParameterInfo> parameters = null, Type castType = null) { if (path.StartsWith("Item[", StringComparison.Ordinal)) { path = path.Substring(4); } if (!path.StartsWith("[", StringComparison.Ordinal)) { return(Empty.Array <object>()); } var args = path .RemoveBounds() .Split(CommaSeparator, StringSplitOptions.RemoveEmptyEntries); var result = new object[args.Length]; for (int i = 0; i < args.Length; i++) { var s = args[i]; if (parameters != null) { castType = parameters[i].ParameterType; } if (!string.IsNullOrEmpty(s) && s[0] == '\"' && s.EndsWith("\"")) { s = s.RemoveBounds(); } result[i] = s == "null" ? null : BindingServiceProvider.ValueConverter(BindingMemberInfo.Empty, castType, s); } return(result); }
protected override void RegisterType(Type type) { base.RegisterType(type); if (BindingServiceProvider.DisableConverterAutoRegistration) { return; } var typeInfo = type.GetTypeInfo(); if (!typeof(IValueConverter).GetTypeInfo().IsAssignableFrom(typeInfo) || !type.IsPublicNonAbstractClass()) { return; } var constructor = type.GetConstructor(Empty.Array <Type>()); if (constructor == null || !constructor.IsPublic) { return; } var converter = (IValueConverter)constructor.Invoke(Empty.Array <object>()); BindingServiceProvider.ResourceResolver.AddConverter(new ValueConverterWrapper(converter), type, true); ServiceProvider.BootstrapCodeBuilder?.Append(nameof(DataBindingModule), $"{typeof(BindingExtensions).FullName}.AddConverter(resolver, new {typeof(ValueConverterWrapper).FullName}(new {type.GetPrettyName()}()), typeof({type.GetPrettyName()}, true);"); if (Tracer.TraceInformation) { Tracer.Info("The {0} converter is registered.", type); } }
protected virtual IList <IOpenedViewModelInfo> GetOpenedViewModelsInternal([NotNull] NavigationType type, [NotNull] IDataContext context) { lock (OpenedViewModels) { List <WeakOpenedViewModelInfo> list; if (!OpenedViewModels.TryGetValue(type, out list)) { return(Empty.Array <IOpenedViewModelInfo>()); } var result = new List <IOpenedViewModelInfo>(); for (int i = 0; i < list.Count; i++) { var target = list[i].ToOpenedViewModelInfo(); if (target == null) { list.RemoveAt(i); --i; } else { result.Add(target); } } if (result.Count == 0) { OpenedViewModels.Remove(type); } return(result); } }
public OrderedListInternal() { KeysInternal = Empty.Array <TKey>(); ValuesInternal = Empty.Array <TValue>(); Size = 0; Comparer = Comparer <TKey> .Default; }
private void Cleanup() { var size = _size; _size = 0; _removedSize = 0; for (int i = 0; i < size; i++) { var reference = _listeners[i]; if (reference.EventListener.IsAlive) { _listeners[_size++] = reference; } } if (_size == 0) { _listeners = Empty.Array <WeakEventListenerWrapper>(); } else if (_listeners.Length / (float)_size > 2) { var listeners = new WeakEventListenerWrapper[_size + (_size >> 2)]; Array.Copy(_listeners, 0, listeners, 0, _size); _listeners = listeners; } }
private static Func <string> TryGetDisplayAttributeAccessor(MemberInfo memberInfo) { var accessor = TryGetDisplayNameAttributeAccessor(memberInfo); if (accessor != null) { return(accessor); } foreach (var attr in memberInfo.GetCustomAttributes(typeof(Attribute), true)) { Type attrType = attr.GetType(); if (attrType.Name != DisplayAttributeName) { continue; } MethodInfo methodInfo = attrType.GetMethodEx(GetNameMethodName, MemberFlags.Public | MemberFlags.Instance); if (methodInfo == null || !methodInfo.ReturnType.Equals(typeof(string)) || methodInfo.GetParameters().Length != 0) { continue; } Func <object, object[], object> methodDelegate = ServiceProvider.ReflectionManager.GetMethodDelegate(methodInfo); object value = attr; return(() => (string)methodDelegate(value, Empty.Array <object>())); } return(null); }
internal static void EnsureCapacity <T>(ref T[] listeners, int size, int min) { if (listeners.Length >= min) { return; } var length = listeners.Length; if (length <= 4) { ++length; } else { length = length + (length >> 2); } if (length > 0) { var objArray = new T[length]; if (size > 0) { Array.Copy(listeners, 0, objArray, 0, size); } listeners = objArray; } else { listeners = Empty.Array <T>(); } }
/// <summary> /// Initializes a new instance of the <see cref="IndexExpressionNode" /> class. /// </summary> public IndexExpressionNode(IExpressionNode obj, IList <IExpressionNode> args) : base(ExpressionNodeType.Index) { _arguments = args == null?Empty.Array <IExpressionNode>() : args.ToArrayEx(); _object = obj; }
private static Action <IBindingBuilder>[] ConvertInternal(LambdaExpression expression, IBindingBuilder builder, bool ignoreCallback) { Expression lastExpression; string path; if (BindingExtensions.TryGetMemberPath(expression.Body, ".", false, out lastExpression, out path) && expression.Parameters[0] == lastExpression) { if (ignoreCallback) { builder.GetOrAddBindingSources().Add(context => BindingExtensions.CreateBindingSource(context, path, null)); return(Empty.Array <Action <IBindingBuilder> >()); } return(new Action <IBindingBuilder>[] { b => b.GetOrAddBindingSources().Add(context => BindingExtensions.CreateBindingSource(context, path, null)) }); } var visitor = new LambdaExpressionToBindingExpressionConverter(expression); visitor.ConvertInternal(expression); var actions = visitor._callbacks.ToArray(); visitor._members = null; visitor._sourceExpression = null; visitor._currentExpression = null; visitor._methodExpression = null; visitor._callbacks = null; return(actions); }
internal static bool TryGetStaticValue <T>(this Expression expression, out T value, bool throwOnError) { try { object v; var exp = expression as ConstantExpression; if (exp == null) { v = Expression.Lambda(expression, Empty.Array <ParameterExpression>()) .Compile() .DynamicInvoke(Empty.Array <object>()); } else { v = exp.Value; } value = (T)BindingServiceProvider.ValueConverter(BindingMemberInfo.Empty, typeof(T), v); return(true); } catch (Exception e) { value = default(T); if (throwOnError) { throw ExceptionManager.ExpressionShouldBeStaticValue(expression, e); } return(false); } }
internal static MethodData FindIndexer(this ArgumentData target, IList <ArgumentData> args, bool staticAccess) { var type = target.Type; var methods = new List <MethodInfo>(); foreach (var property in type.GetPropertiesEx(MemberFlags.Public | MemberFlags.Instance)) { if (property.GetIndexParameters().Length == args.Count) { var m = property.GetGetMethod(true); if (m != null && m.IsStatic == staticAccess) { methods.Add(m); } } } var method = FindBestMethod(target, methods, args, Empty.Array <Type>()); if (method == null) { throw BindingExceptionManager.InvalidBindingMember(type, "Item[]"); } return(method); }