public static IObserver CreateBindingSource(RelativeSourceInfo node, IDataContext context, [NotNull] object target, string pathEx)
{
if (target == null)
{
throw BindingExceptionManager.InvalidBindingTarget(node.Path);
}
string path = node.Path ?? string.Empty;
if (!string.IsNullOrEmpty(pathEx))
{
path = MergePath(path, pathEx);
}
if (node.Type != RelativeSourceInfo.SelfType)
{
if (node.Type == RelativeSourceInfo.ContextSourceType)
{
target = BindingServiceProvider.ContextManager.GetBindingContext(target);
}
else
{
target = new ParentSourceValue(target, node);
}
}
return(CreateBindingSource(context, path, target, 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);
}
internal static MethodData FindMethod(this ArgumentData target, string methodName, Type[] typeArgs,
IList <ArgumentData> args, IEnumerable <Type> knownTypes, bool staticAccess)
{
var type = target.Type;
const MemberFlags flags = MemberFlags.Public | MemberFlags.Static | MemberFlags.Instance;
var methods = new List <MethodInfo>();
foreach (var info in type.GetMethodsEx(flags))
{
if (info.Name == methodName && info.IsStatic == staticAccess)
{
methods.Add(info);
}
}
if (!staticAccess)
{
methods.AddRange(GetExtensionsMethods(methodName, knownTypes));
}
var method = FindBestMethod(target, methods, args, typeArgs);
if (method == null)
{
throw BindingExceptionManager.InvalidBindingMember(type, methodName);
}
return(method);
}
/// <summary>
/// Attempts to subscribe to the event.
/// </summary>
public static IDisposable TrySubscribe([NotNull] this IWeakEventManager eventManager, [NotNull] object target, string eventName, IEventListener listener,
IDataContext context = null)
{
Should.NotBeNull(eventManager, "eventManager");
Should.NotBeNull(target, "target");
var @event = target.GetType().GetEventEx(eventName, MemberFlags.Instance | MemberFlags.Public);
if (@event == null)
{
throw BindingExceptionManager.MissingEvent(target, eventName);
}
return(eventManager.TrySubscribe(target, @event, listener, context));
}
public static string GetMemberPath([NotNull] LambdaExpression expression, string separator = ".")
{
var ret = new StringBuilder();
Expression current = expression.Body;
while (current.NodeType != ExpressionType.Parameter)
{
// This happens when a value type gets boxed
if (current.NodeType == ExpressionType.Convert || current.NodeType == ExpressionType.ConvertChecked)
{
var ue = (UnaryExpression)current;
current = ue.Operand;
continue;
}
string memberName;
var methodCallExpression = current as MethodCallExpression;
if (methodCallExpression != null)
{
if (methodCallExpression.Method.Name != "get_Item")
{
throw BindingExceptionManager.InvalidBindingMemberExpression();
}
string s = string.Join(",", methodCallExpression.Arguments.Cast <ConstantExpression>().Select(e => e.Value));
memberName = "[" + s + "]";
current = methodCallExpression.Object;
}
else if (current.NodeType != ExpressionType.MemberAccess)
{
throw BindingExceptionManager.InvalidBindingMemberExpression();
}
else
{
var me = (MemberExpression)current;
memberName = me.Member.Name;
current = me.Expression;
}
if (ret.Length != 0)
{
ret.Insert(0, separator);
}
ret.Insert(0, memberName);
if (current == null)
{
break;
}
}
return(ret.ToString());
}
internal static void CheckDuplicateLambdaParameter(ICollection <string> parameters)
{
if (parameters.Count == 0)
{
return;
}
var strings = new HashSet <string>();
foreach (string parameter in parameters)
{
if (strings.Contains(parameter))
{
throw BindingExceptionManager.DuplicateLambdaParameter(parameter);
}
strings.Add(parameter);
}
}
internal static MemberInfo FindPropertyOrField(this Type type, string memberName, bool staticAccess, bool throwOnError)
{
var flags = MemberFlags.Public | (staticAccess ? MemberFlags.Static : MemberFlags.Instance);
PropertyInfo property = type.GetPropertyEx(memberName, flags);
if (property != null)
{
return(property);
}
FieldInfo field = type.GetFieldEx(memberName, flags);
if (field == null && throwOnError)
{
throw BindingExceptionManager.InvalidBindingMember(type, memberName);
}
return(field);
}
private static MethodData TryInferGenericMethod(MethodInfo method, IList <ArgumentData> args)
{
bool hasUnresolved;
var genericMethod = TryInferGenericMethod(method, args, out hasUnresolved);
if (genericMethod == null)
{
return(null);
}
if (hasUnresolved)
{
return(new MethodData(genericMethod, list =>
{
bool unresolved;
var m = TryInferGenericMethod(method, list, out unresolved);
if (unresolved)
{
throw BindingExceptionManager.InvalidBindingMember(genericMethod.DeclaringType, method.Name);
}
return m;
}));
}
return(new MethodData(genericMethod));
}
internal static bool TryGetMemberPath(Expression expression, string separator, bool throwOnError, out Expression lastExpression, out string path)
{
lastExpression = expression;
path = null;
if (expression == null)
{
return(false);
}
var ret = new StringBuilder();
bool error = false;
while (lastExpression.NodeType != ExpressionType.Parameter)
{
if (error)
{
if (throwOnError)
{
throw BindingExceptionManager.InvalidBindingMemberExpression();
}
path = ret.ToString();
return(false);
}
// This happens when a value type gets boxed
if (lastExpression.NodeType == ExpressionType.Convert ||
lastExpression.NodeType == ExpressionType.ConvertChecked)
{
var ue = (UnaryExpression)lastExpression;
lastExpression = ue.Operand;
continue;
}
string memberName;
var methodCallExpression = lastExpression as MethodCallExpression;
if (methodCallExpression != null)
{
var memberAttribute = methodCallExpression.Method
.GetAttributes()
.OfType <BindingSyntaxMemberAttribute>()
.FirstOrDefault();
if (memberAttribute != null)
{
if (methodCallExpression.Arguments.Count != 1 && methodCallExpression.Arguments.Count != 2)
{
error = true;
continue;
}
lastExpression = methodCallExpression.Arguments[0];
if (methodCallExpression.Arguments.Count == 2)
{
if (!methodCallExpression.Arguments[1].TryGetStaticValue(out memberName, false))
{
error = true;
continue;
}
}
else
{
memberName = memberAttribute.GetMemberName(methodCallExpression.Method);
}
}
else
{
if (methodCallExpression.Method.Name != "get_Item")
{
error = true;
continue;
}
var builder = new StringBuilder("[");
var args = methodCallExpression.Arguments;
for (int i = 0; i < args.Count; i++)
{
object value;
if (!args[i].TryGetStaticValue(out value, false))
{
error = true;
break;
}
if (i != 0)
{
builder.Append(",");
}
builder.Append(value.ToStringValue());
}
if (error)
{
continue;
}
builder.Append("]");
memberName = builder.ToString();
lastExpression = methodCallExpression.Object;
}
}
else if (lastExpression.NodeType != ExpressionType.MemberAccess)
{
error = true;
continue;
}
else
{
var me = (MemberExpression)lastExpression;
memberName = me.Member.Name;
lastExpression = me.Expression;
}
if (ret.Length != 0 && ret[0] != '[')
{
ret.Insert(0, separator);
}
ret.Insert(0, memberName);
if (lastExpression == null)
{
break;
}
}
path = ret.ToString();
return(true);
}
public static Exception DuplicateLambdaParameter(string parameterName)
{
return(BindingExceptionManager.DuplicateLambdaParameter(parameterName));
}
