/// <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);
}
