Exemple #1
0
        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);
        }
Exemple #4
0
        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);
            }
        }
Exemple #5
0
        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);
        }
Exemple #9
0
 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);
        }
Exemple #11
0
 /// <summary>
 /// Clear the stored data.
 /// </summary>
 public void Clear()
 {
     if ((_data == null) || (_data.Length != 0))
     {
         _data = Empty.Array <byte>();
     }
 }
Exemple #12
0
        /// <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);
            }
        }
Exemple #13
0
        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);
        }
Exemple #14
0
        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);
            }
        }
Exemple #16
0
        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);
        }
Exemple #17
0
        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);
        }
Exemple #21
0
        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;
 }
Exemple #24
0
        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;
            }
        }
Exemple #25
0
        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);
        }
Exemple #26
0
        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>();
            }
        }
Exemple #27
0
        /// <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;
        }
Exemple #28
0
        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);
        }
Exemple #29
0
 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);
        }