/// <inheritdoc /> IDistributedDictionary <TKey, TValue> IGridion.GetDictionary <TKey, TValue>(string name) { Should.NotBeNullOrEmpty(name, nameof(name)); Should.NotBeNullOrWhitespace(name, nameof(name)); return(this.node.GetOrCreateDictionary <TKey, TValue>(name)); }
/// <summary> /// Creates a series of instances of <see cref="IDataBinding" />. /// </summary> /// <param name="target">The specified binding target.</param> /// <param name="bindingExpression">The specified binding expression.</param> /// <param name="sources">The specified sources, if any.</param> /// <returns>An instance of <see cref="IDataBinding" />.</returns> public IList <IDataBinding> CreateBindingsFromString(object target, string bindingExpression, IList <object> sources = null) { Should.NotBeNull(target, "target"); Should.NotBeNullOrWhitespace(bindingExpression, "bindingExpression"); try { IList <IDataContext> parserResult = Parser.Parse(bindingExpression, (sources == null || sources.Count == 0) ? DataContext.Empty : new DataContext(1) { { BindingBuilderConstants.RawSources, sources } }); var result = new IDataBinding[parserResult.Count]; for (int index = 0; index < parserResult.Count; index++) { IDataContext dataContext = parserResult[index]; dataContext.Add(BindingBuilderConstants.Target, target); result[index] = BuildBinding(dataContext); } return(result); } catch (Exception exception) { return(new[] { CreateInvalidDataBinding(new InvalidOperationException(exception.Message, exception)) }); } }
/// <summary> /// Gets an instance of <see cref="IBindingResourceObject" /> by the specified name. /// </summary> /// <param name="name">The specified name.</param> /// <param name="context">The specified data context, if any.</param> /// <param name="throwOnError"> /// true to throw an exception if the type cannot be found; false to return null. Specifying /// false also suppresses some other exception conditions, but not all of them. /// </param> /// <returns>An instance of <see cref="IBindingResourceMethod" />.</returns> public virtual IBindingResourceObject ResolveObject(string name, IDataContext context, bool throwOnError) { Should.NotBeNullOrWhitespace(name, "name"); lock (_objects) { IBindingResourceObject value; if (!_objects.TryGetValue(name, out value) && throwOnError) { if ("root".Equals(name, StringComparison.OrdinalIgnoreCase) || "rootElement".Equals(name, StringComparison.OrdinalIgnoreCase)) { var target = TryGetTarget(context); if (target != null) { var rootMember = BindingServiceProvider.VisualTreeManager.GetRootMember(target.GetType()); if (rootMember != null) { return(new RootResourceObject(target, rootMember)); } } } throw BindingExceptionManager.CannotResolveInstanceByName(this, "resource object", name); } return(value); } }
/// <inheritdoc /> IDistributedSet <T> IGridion.GetSet <T>(string name) { Should.NotBeNullOrEmpty(name, nameof(name)); Should.NotBeNullOrWhitespace(name, nameof(name)); return(this.node.GetOrCreateSet <T>(name)); }
/// <summary> /// Initializes a new instance of the <see cref="AttachedBindingMemberInfo{TTarget,TType}" /> class. /// </summary> public AttachedBindingMemberInfo(string path, Type type, Action <TTarget, MemberAttachedEventArgs> memberAttachedHandler, Func <IBindingMemberInfo, TTarget, IEventListener, IDisposable> observeMemberDelegate, Func <IBindingMemberInfo, TTarget, object[], TType> getValue, Func <IBindingMemberInfo, TTarget, TType> getValueSimple, Func <IBindingMemberInfo, TTarget, object[], object> setValue, Action <IBindingMemberInfo, TTarget, TType> setValueSimple, MemberInfo member, BindingMemberType memberType = null) { Should.NotBeNullOrWhitespace(path, "path"); Should.NotBeNull(type, "type"); if (getValue == null) { _getValueSimple = getValueSimple ?? GetValueThrow <TTarget, TType>; } else { _getValue = getValue; } if (setValue == null) { _setValueSimple = setValueSimple ?? SetValueThrow; } else { _setValue = setValue; } _path = path; _memberAttachedHandler = memberAttachedHandler; _observeMemberDelegate = observeMemberDelegate; _type = type ?? typeof(object); _member = member; _memberType = memberType ?? BindingMemberType.Attached; _canRead = getValue != null || getValueSimple != null; _canWrite = setValue != null || setValueSimple != null; _id = MemberPrefix + Interlocked.Increment(ref _counter).ToString() + "." + path; }
/// <summary> /// Creates a series of instances of <see cref="IBindingBuilder" />. /// </summary> /// <param name="target">The specified binding target.</param> /// <param name="bindingExpression">The specified binding expression.</param> /// <param name="sources">The specified sources, if any.</param> /// <returns>An instance of <see cref="IBindingBuilder" />.</returns> public IList <IBindingBuilder> CreateBuildersFromString(object target, string bindingExpression, IList <object> sources = null) { Should.NotBeNull(target, "target"); Should.NotBeNullOrWhitespace(bindingExpression, "bindingExpression"); try { var parserResult = Parser.Parse(bindingExpression, sources.IsNullOrEmpty() ? DataContext.Empty : new DataContext(1) { { BindingBuilderConstants.RawSources, sources } }); var result = new IBindingBuilder[parserResult.Count]; for (int index = 0; index < parserResult.Count; index++) { var builder = new BindingBuilder(parserResult[index]); builder.Add(BindingBuilderConstants.Target, target); builder.Add(BindingBuilderConstants.BuildDelegate, _buildDelegate); result[index] = builder; } return(result); } catch (Exception exception) { exception = new InvalidOperationException(exception.Message, exception); var builder = new BindingBuilder(); builder.Add(BindingBuilderConstants.Target, target); builder.Add(ProviderConstant, this); builder.Add(ExceptionConstant, exception); builder.Add(BindingBuilderConstants.BuildDelegate, CreateInvalidaDataBindingDelegate); return(new IBindingBuilder[] { builder }); } }
public virtual ViewResult Create(string name, Context context, IAttributeSet attrs) { Should.NotBeNullOrWhitespace(name, "name"); Type type = TypeCache <View> .Instance.GetTypeByName(name, true, true); return(Create(type, context, attrs)); }
/// <summary> /// Initializes a new instance of the <see cref="RelativeSourceExpressionNode" /> class. /// </summary> public RelativeSourceExpressionNode([NotNull] string elementName, string path) : base(ExpressionNodeType.RelativeSource) { Should.NotBeNullOrWhitespace(elementName, "elementName"); _type = ElementSourceType; _elementName = elementName; _path = path; }
/// <summary> /// Initializes a new instance of the <see cref="RelativeSourceExpressionNode" /> class. /// </summary> public RelativeSourceExpressionNode([NotNull] string type, uint level, string path) : base(ExpressionNodeType.RelativeSource) { Should.NotBeNullOrWhitespace(type, "type"); _type = type; _level = level; _path = path; }
public static IBindingToSyntax Bind([NotNull] this IBindingBuilder builder, [NotNull] object target, [NotNull] string targetPath) { Should.NotBeNull(builder, "builder"); Should.NotBeNull(target, "target"); Should.NotBeNullOrWhitespace(targetPath, "targetPath"); builder.Add(BindingBuilderConstants.Target, target); builder.Add(BindingBuilderConstants.TargetPath, BindingPath.Create(targetPath)); return(builder.GetOrAddSyntaxBuilder()); }
public static IBindingToSyntax <TTarget, TSource> Bind <TTarget, TSource>([NotNull] this IBindingBuilder builder, [NotNull] TTarget targetGeneric, [NotNull] string targetPath) where TTarget : class { Should.NotBeNull(builder, "builder"); Should.NotBeNull(targetGeneric, "targetGeneric"); Should.NotBeNullOrWhitespace(targetPath, "targetPath"); builder.Add(BindingBuilderConstants.Target, targetGeneric); builder.Add(BindingBuilderConstants.TargetPath, BindingServiceProvider.BindingPathFactory(targetPath)); return(new SyntaxBuilder <TTarget, TSource>(builder)); }
public virtual IBindingValueConverter ResolveConverter(string name, IDataContext context, bool throwOnError) { Should.NotBeNullOrWhitespace(name, "name"); lock (_converters) { IBindingValueConverter value; if (!_converters.TryGetValue(name, out value) && throwOnError) { throw BindingExceptionManager.CannotResolveInstanceByName(this, "converter", name); } return(value); } }
public virtual IBindingResourceMethod ResolveMethod(string name, IDataContext context, bool throwOnError) { Should.NotBeNullOrWhitespace(name, "name"); lock (_dynamicMethods) { IBindingResourceMethod value; if (!_dynamicMethods.TryGetValue(name, out value) && throwOnError) { throw BindingExceptionManager.CannotResolveInstanceByName(this, "dynamic method", name); } return(value); } }
/// <summary> /// Tries to find element by it's name. /// </summary> public virtual object FindByName(object target, string elementName) { Should.NotBeNull(target, "target"); Should.NotBeNullOrWhitespace(elementName, "elementName"); var member = BindingServiceProvider .MemberProvider .GetBindingMember(target.GetType(), AttachedMemberConstants.FindByNameMethod, false, false); if (member == null) { return(null); } return(member.GetValue(target, new object[] { elementName })); }
public virtual void AddBehavior(string name, Func <IDataContext, IList <object>, IBindingBehavior> getBehavior, bool rewrite) { Should.NotBeNullOrWhitespace(name, nameof(name)); Should.NotBeNull(getBehavior, nameof(getBehavior)); lock (_behaviors) { if (rewrite) { _behaviors[name] = getBehavior; } else { _behaviors.Add(name, getBehavior); } } }
/// <summary> /// Adds the specified object. /// </summary> public virtual void AddObject(string name, IBindingResourceObject obj, bool rewrite) { Should.NotBeNullOrWhitespace(name, "name"); Should.NotBeNull(obj, "obj"); lock (_objects) { if (rewrite) { _objects[name] = obj; } else { _objects.Add(name, obj); } } }
public virtual void AddType(string name, Type type, bool rewrite) { Should.NotBeNullOrWhitespace(name, nameof(name)); Should.NotBeNull(type, nameof(type)); lock (_types) { if (rewrite) { _types[name] = type; } else { _types.Add(name, type); } } }
public virtual void AddMethod(string name, IBindingResourceMethod method, bool rewrite) { Should.NotBeNullOrWhitespace(name, nameof(name)); Should.NotBeNull(method, nameof(method)); lock (_dynamicMethods) { if (rewrite) { _dynamicMethods[name] = method; } else { _dynamicMethods.Add(name, method); } } }
/// <summary> /// Adds the specified converter. /// </summary> public virtual void AddConverter(string name, IBindingValueConverter converter, bool rewrite) { Should.NotBeNullOrWhitespace(name, "name"); Should.NotBeNull(converter, "converter"); lock (_converters) { if (rewrite) { _converters[name] = converter; } else { _converters.Add(name, converter); } } }
public virtual void AddObject(string name, ISourceValue obj, bool rewrite) { Should.NotBeNullOrWhitespace(name, nameof(name)); Should.NotBeNull(obj, nameof(obj)); DynamicResourceObject value; lock (_objects) { if (!_objects.TryGetValue(name, out value)) { value = new DynamicResourceObject(); _objects[name] = value; } } value.SetValue(obj, name, rewrite); }
public virtual IBindingBehavior ResolveBehavior(string name, IDataContext context, IList <object> args, bool throwOnError) { Should.NotBeNullOrWhitespace(name, "name"); Func <IDataContext, IList <object>, IBindingBehavior> value; lock (_behaviors) { if (!_behaviors.TryGetValue(name, out value)) { if (throwOnError) { throw BindingExceptionManager.CannotResolveInstanceByName(this, "binding behavior", name); } return(null); } } return(value(context, args)); }
public virtual void AddConverter(string name, IBindingValueConverter converter, bool rewrite) { Should.NotBeNullOrWhitespace(name, nameof(name)); Should.NotBeNull(converter, nameof(converter)); lock (_converters) { if (rewrite) { _converters[name] = converter; } else { _converters.Add(name, converter); } if (name == "ViewModelToViewConverter") { _converters["GetView"] = converter; } } }
/// <summary> /// Tries to find relative source. /// </summary> public virtual object FindRelativeSource(object target, string typeName, uint level) { Should.NotBeNull(target, "target"); Should.NotBeNullOrWhitespace(typeName, "typeName"); object fullNameSource = null; object nameSource = null; uint fullNameLevel = 0; uint nameLevel = 0; target = FindParent(target); while (target != null) { bool shortNameEqual; bool fullNameEqual; TypeNameEqual(target.GetType(), typeName, out shortNameEqual, out fullNameEqual); if (shortNameEqual) { nameSource = target; nameLevel++; } if (fullNameEqual) { fullNameSource = target; fullNameLevel++; } if (fullNameSource != null && fullNameLevel == level) { return(fullNameSource); } if (nameSource != null && nameLevel == level) { return(nameSource); } target = FindParent(target); } return(null); }
public IList <IDataBinding> CreateBindingsFromString(object target, string bindingExpression, IList <object> sources = null) { Should.NotBeNull(target, "target"); Should.NotBeNullOrWhitespace(bindingExpression, "bindingExpression"); try { IList <IDataContext> parserResult = Parser.Parse(bindingExpression, DataContext.Empty, target, sources); var result = new IDataBinding[parserResult.Count]; for (int index = 0; index < parserResult.Count; index++) { result[index] = BuildBinding(parserResult[index]); } return(result); } catch (Exception exception) { return(new[] { CreateInvalidDataBinding(new InvalidOperationException(exception.Message, exception)) }); } }
public virtual ISourceValue ResolveObject(string name, IDataContext context, bool throwOnError) { Should.NotBeNullOrWhitespace(name, "name"); if (context != null && BindingSourceResourceName.Equals(name, StringComparison.Ordinal)) { object src; if (context.TryGetData(BindingBuilderConstants.Source, out src)) { return(src as ISourceValue ?? new ConstResourceObject(src)); } object target = null; IDataBinding binding; if (context.TryGetData(BindingConstants.Binding, out binding)) { WeakReference srcWeak; if (binding.Context.TryGetData(BindingConstants.Source, out srcWeak)) { return(new ConstResourceObject(srcWeak)); } target = binding.TargetAccessor.Source.GetActualSource(false); } if (target == null) { target = context.GetData(BindingBuilderConstants.Target); } if (target != null) { return(BindingServiceProvider.ContextManager.GetBindingContext(target)); } } var targetResourceObject = GetTargetResourceObject(name, context); if (targetResourceObject == null) { return(GetOrAddDynamicResource(name, true)); } return(targetResourceObject); }
public ModelPropertyAttribute([NotNull] string modelProperty) { Should.NotBeNullOrWhitespace("model", modelProperty); _property = modelProperty; }
public MetadataTypeAttribute([NotNull] Type metadataType, [NotNull] string methodName) { Should.NotBeNull(metadataType, "metadataType"); Should.NotBeNullOrWhitespace(methodName, "methodName"); _accessor = FindAccessor(methodName, metadataType); }
public MetadataTypeAttribute([NotNull] string methodName) { Should.NotBeNullOrWhitespace(methodName, "methodName"); _methodName = methodName; }
public DisplayNameAttribute([NotNull] Type resourceType, [NotNull] string resourceName) { Should.NotBeNull(resourceType, nameof(resourceType)); Should.NotBeNullOrWhitespace(resourceName, nameof(resourceName)); _resourceAccessor = FindResourceAccessor(resourceName, resourceType); }