/// <summary>
/// Creates a new indirect property binding using the specified <paramref name="propertyName"/>.
/// </summary>
/// <remarks>
/// This supports single and multiple levels of property accessors in the model.
/// </remarks>
/// <example>
/// Use this like so:
/// <code>
/// public class MyChild { public SomeChildProperty { get; set; } }
/// public class MyModel {
/// public ChildObject { get; set; }
/// public int IntProperty { get; set; }
/// }
///
/// // direct property binding
/// Binding.Property("IntProperty");
///
/// // bind to a property of a child object of the view model
/// Binding.Property("ChildObject.SomeChildProperty");
/// </code>
/// </example>
/// <param name="propertyName">Name of the property to bind to.</param>
/// <param name="ignoreCase">True to ignore case of the property name, false to match the property name exactly.</param>
/// <typeparam name="TValue">The type of the property.</typeparam>
public static IndirectBinding <TValue> Property <TValue>(string propertyName, bool ignoreCase)
{
if (propertyName.IndexOf('.') > 0)
{
var props = propertyName.Split('.');
IndirectBinding <object> prop = null;
for (int i = 0; i < props.Length - 1; i++)
{
var pp = new PropertyBinding <object>(props[i], ignoreCase);
prop = prop?.Child(pp) ?? pp;
}
return(prop.Child(new PropertyBinding <TValue>(props[props.Length - 1], ignoreCase)));
}
return(new PropertyBinding <TValue>(propertyName, ignoreCase));
}
/// <summary>
/// Creates a new indirect property binding using the specified <paramref name="propertyExpression"/>.
/// </summary>
/// <remarks>
/// This supports single and multiple levels of property accessors in the model.
/// </remarks>
/// <example>
/// Use this like so:
/// <code>
/// public class MyChild { public SomeChildProperty { get; set; } }
/// public class MyModel {
/// public ChildObject { get; set; }
/// public int IntProperty { get; set; }
/// }
///
/// // direct property binding
/// Binding.Property((MyModel m) => m.IntProperty);
///
/// // bind to a property of a child object of the view model
/// Binding.Property((MyModel m) => m.ChildObject.SomeChildProperty);
/// </code>
/// </example>
/// <param name="propertyExpression">Expression of the property to bind to.</param>
/// <typeparam name="T">The type of the model.</typeparam>
/// <typeparam name="TValue">The property value type.</typeparam>
public static IndirectBinding <TValue> Property <T, TValue>(Expression <Func <T, TValue> > propertyExpression)
{
var memberInfo = propertyExpression.GetMemberInfo();
if (memberInfo == null)
{
// not a direct property expression, use a delegate to get value (but there will not be a way to set the value)
var getValue = propertyExpression.Compile();
return(Delegate(getValue));
}
var parentMember = memberInfo.Expression as MemberExpression;
if (parentMember != null)
{
// go up parent heirarchy to get all the members
var props = new List <MemberExpression>();
do
{
props.Add(parentMember);
var current = parentMember.Expression;
if (current.NodeType != ExpressionType.MemberAccess && current.NodeType != ExpressionType.Parameter)
{
return(Delegate(propertyExpression.Compile()));
}
parentMember = current as MemberExpression;
} while (parentMember != null);
props.Reverse();
IndirectBinding <object> prop = null;
foreach (var p in props)
{
var pp = new PropertyBinding <object>(p.Member.Name);
prop = prop?.Child(pp) ?? pp;
}
// support multiple property access, e.g. m => m.Child.Property
return(prop.Child(new PropertyBinding <TValue>(memberInfo.Member.Name)));
}
// not using the parameter of the expression
if (memberInfo.Expression.NodeType != ExpressionType.Parameter)
{
return(Delegate(propertyExpression.Compile()));
}
return(new PropertyBinding <TValue>(memberInfo.Member.Name));
}