| public static PropertyOrField ( Expression expression, string propertyOrFieldName ) : MemberExpression | ||
| expression | Expression | The containing object of the member. This can be null for static members. |
| propertyOrFieldName | string | The member to be accessed. |
| return | MemberExpression | |
public static Expression SelectPropertyValue(Type type, string property, List <string> values, QueryFilterExpressionCollection queryFilter)
{
var valueType = GetPropertyType(type, property);
var parsedValuesAsObjects = values.Select(v => TryConvert(v, valueType)).ToList();
var parsedValues = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(valueType));
foreach (var parsedValueAsObject in parsedValuesAsObjects)
{
parsedValues.Add(parsedValueAsObject);
}
var param = Expression.Parameter(type, "i");
Expression propertyExpression = param;
foreach (var member in property.Split('.'))
{
propertyExpression = Expression.PropertyOrField(propertyExpression, member);
}
var expression = queryFilter.GetQueryFilterExpression(GetPropertyInfo(type, property));
return(typeof(Lambda)
.GetMethod(nameof(Convert), BindingFlags.Static | BindingFlags.NonPublic)
.MakeGenericMethod(valueType, type)
.Invoke(null, new object[] { expression, parsedValues, propertyExpression, param })
as Expression);
}
public LambdaExpression CreateLambda(Type from, Type to)
{
var fromParameters = from.GetTypeInfo().GenericTypeArguments;
var toParameters = to.GetTypeInfo().GenericTypeArguments;
var converters = fromParameters
.Zip(toParameters, (f, t) => Ref.GetLambda(f, t))
.ToArray();
var input = Ex.Parameter(from, "input");
var res = toParameters.Select(t => Ex.Parameter(typeof(ConversionResult <>).MakeGenericType(t))).ToArray();
var conversion = res.Select((r, i) =>
Ex.Assign(res[i], converters[i].ApplyTo(Ex.PropertyOrField(input, $"Item{i + 1}")))).ToArray();
var conversionSuccesful = Enumerable.Aggregate(res, (Ex)Ex.Constant(true),
(c, p) => Ex.MakeBinary(Et.AndAlso, c, Ex.Property(p, nameof(IConversionResult.IsSuccessful))));
var block = Ex.Block(res,
Ex.Block(conversion),
Ex.Condition(conversionSuccesful,
Result(to,
Ex.Call(Creator(to), Enumerable.Select(res, p => Ex.Property(p, nameof(IConversionResult.Result))))),
NoResult(to)));
var lambda = Ex.Lambda(block, input);
return(lambda);
}
// ALT: http://forums.asp.net/post/5109977.aspx
// NOTE: for properties, it's possible they're write only. I'm not going to validate that extreme edge case.
// If you're trying to wrap such a property then you don't deserve to be using these APIs :P
/// <summary>Generate a specific member getter for a specific type</summary>
/// <typeparam name="T">The type which contains the member</typeparam>
/// <typeparam name="TResult">The member's actual type</typeparam>
/// <param name="memberName">The member's name as defined in <typeparamref name="T"/></param>
/// <returns>A compiled lambda which can access (get) the member</returns>
/// <remarks>Generates a method similar to this:
/// <code>
/// TResult GetMethod(T @this)
/// {
/// return @this.memberName;
/// }
/// </code>
/// </remarks>
public static Func <T, TResult> GenerateMemberGetter <T, TResult>(string memberName)
{
Contract.Requires <ArgumentException>(!string.IsNullOrEmpty(memberName));
Contract.Ensures(Contract.Result <Func <T, TResult> >() != null);
var param = Expr.Parameter(typeof(T), kThisName);
var member = Expr.PropertyOrField(param, memberName); // basically 'this.memberName'
var lambda = Expr.Lambda <Func <T, TResult> >(member, param);
return(lambda.Compile());
}
/// <summary>Generate a specific member getter for a specific type</summary>
/// <typeparam name="TResult">The member's actual type</typeparam>
/// <param name="type">The type which contains the member</param>
/// <param name="memberName">The member's name as defined in <paramref name="type"/></param>
/// <returns>A compiled lambda which can access (get) the member</returns>
/// <remarks>Generates a method similar to this:
/// <code>
/// TResult GetMethod(object @this)
/// {
/// return ((type)@this).memberName;
/// }
/// </code>
/// </remarks>
public static Func <object, TResult> GenerateMemberGetter <TResult>(Type type, string memberName)
{
Contract.Requires <ArgumentNullException>(type != null);
Contract.Requires <ArgumentException>(!type.IsGenericTypeDefinition);
Contract.Requires <ArgumentException>(!string.IsNullOrEmpty(memberName));
Contract.Ensures(Contract.Result <Func <object, TResult> >() != null);
var param = Expr.Parameter(typeof(object), kThisName);
var cast_param = Expr.Convert(param, type); // '((type)this)'
var member = Expr.PropertyOrField(cast_param, memberName); // basically 'this.memberName'
var lambda = Expr.Lambda <Func <object, TResult> >(member, param);
return(lambda.Compile());
}
/// <summary>
/// Creates an action to set the named control property.
/// </summary>
/// <typeparam name="TEntity">The type of the class owning the property.</typeparam>
/// <typeparam name="TProperty">The type of the property.</typeparam>
/// <param name="controlName">The control name.</param>
/// <param name="propertyName">The property name.</param>
/// <returns>A setter Action for the control property.</returns>
public static Action <TEntity, TProperty> CreateControlPropertySetterByName <TEntity, TProperty>(string controlName, string propertyName)
{
ParameterExpression targetParameter = LExpression.Parameter(typeof(MainWindow), "x");
var controlExp = LExpression.PropertyOrField(targetParameter, controlName);
MemberExpression targetPropertyExp = LExpression.Property(controlExp, propertyName);
ParameterExpression paramExp = LExpression.Parameter(typeof(TEntity), "y");
var targetExp = LExpression.Lambda <Func <TEntity, TProperty> >(targetPropertyExp, new ParameterExpression[] { paramExp });
PropertyInfo propertyInfo = GetProperty(targetExp);
ParameterExpression instance = LExpression.Parameter(typeof(TEntity), "instance");
ParameterExpression parameter = LExpression.Parameter(typeof(TProperty), "parameter");
var body = LExpression.Call(instance, propertyInfo.GetSetMethod(), parameter);
var parameters = new ParameterExpression[] { instance, parameter };
return(LExpression.Lambda <Action <TEntity, TProperty> >(body, parameters).Compile());
}
/// <summary>Generate a specific member setter for a specific reference type</summary>
/// <typeparam name="T">The type which contains the member</typeparam>
/// <typeparam name="TValue">The member's actual type</typeparam>
/// <param name="memberName">The member's name as defined in <typeparamref name="T"/></param>
/// <returns>A compiled lambda which can access (set) the member</returns>
/// <exception cref="MemberAccessException"><paramref name="memberName"/> is readonly</exception>
/// <remarks>Generates a method similar to this:
/// <code>
/// void SetMethod(T @this, TValue value)
/// {
/// @this.memberName = value;
/// }
/// </code>
/// </remarks>
public static ReferenceTypeMemberSetterDelegate <T, TValue> GenerateReferenceTypeMemberSetter <T, TValue>(string memberName)
where T : class
{
Contract.Requires <ArgumentException>(!string.IsNullOrEmpty(memberName));
Contract.Ensures(Contract.Result <ReferenceTypeMemberSetterDelegate <T, TValue> >() != null);
var param_this = Expr.Parameter(typeof(T), kThisName);
var param_value = Expr.Parameter(typeof(TValue), kValueName); // the member's new value
var member = Expr.PropertyOrField(param_this, memberName); // i.e., 'this.memberName'
ValidateMemberForGenerateSetter(member.Member);
var assign = Expr.Assign(member, param_value); // i.e., 'this.memberName = value'
var lambda = Expr.Lambda <ReferenceTypeMemberSetterDelegate <T, TValue> >(
assign, param_this, param_value);
return(lambda.Compile());
}
/// <summary>Generate a specific member setter for a specific reference type</summary>
/// <typeparam name="TValue">The member's actual type</typeparam>
/// <param name="type">The type which contains the member</param>
/// <param name="memberName">The member's name as defined in <paramref name="type"/></param>
/// <returns>A compiled lambda which can access (set) the member</returns>
/// <exception cref="MemberAccessException"><paramref name="memberName"/> is readonly</exception>
/// <remarks>Generates a method similar to this:
/// <code>
/// void SetMethod(object @this, TValue value)
/// {
/// ((type)@this).memberName = value;
/// }
/// </code>
/// </remarks>
public static ReferenceTypeMemberSetterDelegate <object, TValue> GenerateReferenceTypeMemberSetter <TValue>(Type type, string memberName)
{
Contract.Requires <ArgumentNullException>(type != null);
Contract.Requires <ArgumentException>(!type.IsGenericTypeDefinition);
Contract.Requires <ArgumentException>(!string.IsNullOrEmpty(memberName));
Contract.Requires <ArgumentException>(!type.IsValueType, "Type must be a reference type");
Contract.Ensures(Contract.Result <ReferenceTypeMemberSetterDelegate <object, TValue> >() != null);
var param_this = Expr.Parameter(typeof(object), kThisName);
var param_value = Expr.Parameter(typeof(TValue), kValueName); // the member's new value
var cast_this = Expr.Convert(param_this, type); // i.e., '((type)this)'
var member = Expr.PropertyOrField(cast_this, memberName); // i.e., 'this.memberName'
ValidateMemberForGenerateSetter(member.Member);
var assign = Expr.Assign(member, param_value); // i.e., 'this.memberName = value'
var lambda = Expr.Lambda <ReferenceTypeMemberSetterDelegate <object, TValue> >(
assign, param_this, param_value);
return(lambda.Compile());
}
/// <summary>Generate a specific member setter for a specific value type</summary>
/// <typeparam name="T">The type which contains the member</typeparam>
/// <typeparam name="TValue">The member's actual type</typeparam>
/// <param name="memberName">The member's name as defined in <typeparamref name="T"/></param>
/// <returns>A compiled lambda which can access (set) the member</returns>
/// <remarks>Generates a method similar to this:
/// <code>
/// void SetMethod(ref T @this, TValue value)
/// {
/// @this.memberName = value;
/// }
/// </code>
/// </remarks>
public static ValueTypeMemberSetterDelegate <T, TValue> GenerateValueTypeMemberSetter <T, TValue>(string memberName)
where T : struct
{
Contract.Requires <ArgumentException>(!string.IsNullOrEmpty(memberName));
Contract.Ensures(Contract.Result <ValueTypeMemberSetterDelegate <T, TValue> >() != null);
// Get a "ref type" of the value-type we're dealing with
// Eg: Guid => "System.Guid&"
var this_ref = typeof(T).MakeByRefType();
var param_this = Expr.Parameter(this_ref, kThisName);
var param_value = Expr.Parameter(typeof(TValue), kValueName); // the member's new value
var member = Expr.PropertyOrField(param_this, memberName); // i.e., 'this.memberName'
ValidateMemberForGenerateSetter(member.Member);
var assign = Expr.Assign(member, param_value); // i.e., 'this.memberName = value'
var lambda = Expr.Lambda <ValueTypeMemberSetterDelegate <T, TValue> >(
assign, param_this, param_value);
return(lambda.Compile());
}
public static Ex Field(this Ex me, string field) => Ex.PropertyOrField(me, field);
/// <summary>
/// BindComboBox creates reactive combo box bindings for the items source, selected item,
/// text, and selected index.
/// </summary>
/// <typeparam name="TParameter">The type of the property bound to in the view model.</typeparam>
/// <typeparam name="TTargetClass">The type of the view model that owns the bound properties.</typeparam>
/// <param name="comboName">The name of the combo box.</param>
/// <param name="targetClassName">The name of the view model that owns the bound properties.</param>
/// <param name="targetPropertyName">The name of the property bound to in the view model.</param>
/// <param name="targetItemsName">The name of the items property bound to in the view model.</param>
/// <param name="windowClass">The main window class instance. (Pass "this")</param>
public static void BindComboBox <TParameter, TTargetClass>(
string comboName,
string targetClassName,
string targetPropertyName,
string targetItemsName,
MainWindow windowClass)
{
ComboBox control = (ComboBox)windowClass.FindName(comboName);
ParameterExpression mainWindowParameterExp = LExpression.Parameter(typeof(MainWindow), "x");
MemberExpression mainVMRefExp = LExpression.Property(mainWindowParameterExp, "MainViewModel");
MemberExpression viewModelExp = LExpression.Property(mainVMRefExp, targetClassName);
// Bind combo box Items source.
MemberExpression itemsExp = LExpression.Property(viewModelExp, targetItemsName);
Expression <Func <MainWindow, IEnumerable> > targetItemsParameterExp =
LExpression.Lambda <Func <MainWindow, IEnumerable> >(
itemsExp,
new ParameterExpression[] { mainWindowParameterExp });
Action <ComboBox, IEnumerable> controlItemsSetterAction =
CreateControlPropertySetterByName <ComboBox, IEnumerable>(
comboName,
"ItemsSource");
windowClass.DisposeCollection.Add(
windowClass.WhenAnyValue(targetItemsParameterExp)
.Subscribe(delegate(IEnumerable x)
{
controlItemsSetterAction(control, x);
}));
// Bind combo box SelectedItem.
MemberExpression controlExp = LExpression.PropertyOrField(mainWindowParameterExp, comboName);
MemberExpression controlSelectedItemExp = LExpression.Property(controlExp, "SelectedItem");
Expression <Func <MainWindow, object> > controlSelectedItemParameterExp =
LExpression.Lambda <Func <MainWindow, object> >(
controlSelectedItemExp,
new ParameterExpression[] { mainWindowParameterExp });
PropertyInfo targetClassPropertyInfo = windowClass.MainViewModel.GetType().GetProperty(targetClassName);
TTargetClass targetClassInstance = (TTargetClass)targetClassPropertyInfo.GetGetMethod().Invoke(windowClass.MainViewModel, null);
ParameterExpression targetViewModelParameter = LExpression.Parameter(typeof(TTargetClass), "viewModel");
MemberExpression targetViewModelPropertyExp = LExpression.Property(targetViewModelParameter, targetPropertyName);
Expression <Func <TTargetClass, TParameter> > targetBindingPropertyExp =
LExpression.Lambda <Func <TTargetClass, TParameter> >(
targetViewModelPropertyExp,
new ParameterExpression[] { targetViewModelParameter });
windowClass.DisposeCollection.Add(
windowClass.WhenAnyValue(controlSelectedItemParameterExp)
.Where(x => x != null)
.BindTo(targetClassInstance, targetBindingPropertyExp));
// Bind the combo box text to the target property. Numeric.
MemberExpression controlTextPropertyExp = LExpression.Property(controlExp, "Text");
Expression <Func <MainWindow, string> > controlTextParameterExp =
LExpression.Lambda <Func <MainWindow, string> >(
controlTextPropertyExp,
new ParameterExpression[] { mainWindowParameterExp });
// Get the appropriate Regex string from the parameter type.
string regexTest = string.Empty;
if (targetViewModelPropertyExp.Type == typeof(double))
{
regexTest = RegexFloat;
}
else if (targetViewModelPropertyExp.Type == typeof(int))
{
regexTest = RegexInteger;
}
windowClass.DisposeCollection.Add(
windowClass.WhenAnyValue(controlTextParameterExp)
.Where(x => System.Text.RegularExpressions.Regex.IsMatch(x, regexTest) == true)
.BindTo(targetClassInstance, targetBindingPropertyExp));
// Bind the combo box selected index to the target property.
MemberExpression targetPropertyExp = LExpression.Property(viewModelExp, targetPropertyName);
Expression <Func <MainWindow, TParameter> > targetParameterExp =
LExpression.Lambda <Func <MainWindow, TParameter> >(
targetPropertyExp,
new ParameterExpression[] { mainWindowParameterExp });
Action <ComboBox, int> controlIndexSetterAction =
CreateControlPropertySetterByName <ComboBox, int>(
comboName,
"SelectedIndex");
windowClass.DisposeCollection.Add(
windowClass.WhenAnyValue(targetParameterExp)
.Subscribe(delegate(TParameter x)
{
controlIndexSetterAction(control, control.Items.IndexOf(x));
}));
}
/// <summary>
/// Binds a Halcon window to a View Roi Manager.
/// </summary>
/// <param name="manager">The View Roi Manager.</param>
/// <param name="halconWindow">The Halcon window.</param>
/// <param name="imageBorderName">The name of the Border Control containing the Halcon window control.</param>
/// <param name="loadImageViewModelName">The name of the load image view model to use.</param>
/// <param name="windowClass">The main window class instance. (Pass "this")</param>
public static void BindHalconWindow(
ViewROIManager manager,
HWindowControlWPF halconWindow,
string imageBorderName,
string loadImageViewModelName,
MainWindow windowClass)
{
windowClass.DisposeCollection.Add(windowClass.Events().ContentRendered.Subscribe(_ =>
{
manager.LocHWindowControl = halconWindow;
manager.LocHWindowControl.ContextMenu.ItemsSource = windowClass.MainViewModel.MenuItems;
// Set the data template.
manager.LocHWindowControl.ContextMenu.ItemTemplate = windowClass.ContextMenuDataTemplate;
// Set the ItemsPanelTemplate.
manager.LocHWindowControl.ContextMenu.ItemsPanel = windowClass.ContextMenuItemsPanelTemplate;
}));
windowClass.DisposeCollection.Add(windowClass.MainViewModel.MenuItems.ItemsAdded
.Where(_ => manager.LocHWindowControl != null)
.Subscribe(
_ =>
{
manager.LocHWindowControl.ContextMenu.ItemsSource = windowClass.MainViewModel.MenuItems;
// Set the data template.
manager.LocHWindowControl.ContextMenu.ItemTemplate = windowClass.ContextMenuDataTemplate;
// Set the ItemsPanelTemplate.
manager.LocHWindowControl.ContextMenu.ItemsPanel = windowClass.ContextMenuItemsPanelTemplate;
}));
windowClass.DisposeCollection.Add(windowClass.Events().LayoutUpdated
.Select(_ => System.Reactive.Unit.Default)
.InvokeCommand(manager.AdjustAspectCommand));
ParameterExpression targetParameter = LExpression.Parameter(typeof(MainWindow), "x");
MemberExpression mainVMExp = LExpression.Property(targetParameter, "MainViewModel");
MemberExpression viewModelExp = LExpression.Property(mainVMExp, loadImageViewModelName);
MemberExpression imageHeightExp = LExpression.Property(viewModelExp, "ImageHeight");
MemberExpression imageWidthExp = LExpression.Property(viewModelExp, "ImageWidth");
Expression <Func <MainWindow, int> > imageHeightTargetExp = LExpression.Lambda <Func <MainWindow, int> >(imageHeightExp, new ParameterExpression[] { targetParameter });
Expression <Func <MainWindow, int> > imageWidthTargetExp = LExpression.Lambda <Func <MainWindow, int> >(imageWidthExp, new ParameterExpression[] { targetParameter });
// Using Subscribe here because BindTo sets up a two-way binding which is not wanted.
windowClass.DisposeCollection.Add(windowClass.WhenAnyValue(imageHeightTargetExp)
.Subscribe(x => manager.ImageHeight = x));
windowClass.DisposeCollection.Add(windowClass.WhenAnyValue(imageWidthTargetExp)
.Subscribe(x => manager.ImageWidth = x));
MemberExpression borderExp = LExpression.PropertyOrField(targetParameter, imageBorderName);
MemberExpression actualHeightExp = LExpression.Property(borderExp, "ActualHeight");
MemberExpression actualWidthExp = LExpression.Property(borderExp, "ActualWidth");
Expression <Func <MainWindow, double> > actualHeightTargetExp = LExpression.Lambda <Func <MainWindow, double> >(actualHeightExp, new ParameterExpression[] { targetParameter });
Expression <Func <MainWindow, double> > actualWidthTargetExp = LExpression.Lambda <Func <MainWindow, double> >(actualWidthExp, new ParameterExpression[] { targetParameter });
windowClass.DisposeCollection.Add(windowClass.WhenAnyValue(actualHeightTargetExp)
.Subscribe(x => manager.ContainerHeight = x));
windowClass.DisposeCollection.Add(windowClass.WhenAnyValue(actualWidthTargetExp)
.Subscribe(x => manager.ContainerWidth = x));
}
public ILoadService <T> Include <TProperty>(Expression <Func <T, TProperty> > path)
where TProperty : class
{
var properties = path.Body.ToString().Split('.').Where(p => !p.StartsWith("Select")).Select(p => p.TrimEnd(')')).ToArray();
if (properties.Length == 2)
{
if (typeof(IEnumerable).IsAssignableFrom(typeof(TProperty)))
{
((IQueryable <T>)_fetchMany.Invoke(null, new object[] { _query, path })).ToFuture();
}
else
{
_query.Fetch(path).ToFuture();
}
}
else if (properties.Length > 2)
{
var current = typeof(T);
IQueryable <T> query = null;
for (var i = 1; i < properties.Length; i++)
{
if (i == 1)
{
if (typeof(IEnumerable).IsAssignableFrom(typeof(TProperty)))
{
query = (IQueryable <T>)_fetchMany.Invoke(null, new object[] { _query, path });
current = typeof(TProperty).GetGenericArguments()[0];
}
else
{
query = _query.Fetch(path);
current = typeof(TProperty);
}
}
else
{
var property = current.GetProperty(properties[i]);
if (property == null)
{
break;
}
var propertyType = property.PropertyType;
var parameter = Expression.Parameter(current);
var body = Expression.Convert(Expression.PropertyOrField(parameter, properties[i]), propertyType);
var selector = Expression.Lambda(body, parameter);
if (typeof(IEnumerable).IsAssignableFrom(propertyType))
{
query = (IQueryable <T>)_thenFetchMany.Invoke(null, new object[] { query, selector });
current = propertyType.GetGenericArguments()[0];
}
else
{
query = (IQueryable <T>)_thenFetch.Invoke(null, new object[] { query, selector });
current = propertyType;
}
}
}
query.ToFuture();
}
return(this);
}
/// <summary>
/// Binds a Halcon window to a View Roi Manager.
/// </summary>
/// <param name="manager">The View Roi Manager.</param>
/// <param name="halconWindow">The Halcon window.</param>
/// <param name="imageBorderName">
/// The name of the Border Control containing the Halcon window control.
/// </param>
/// <param name="loadImageViewModelName">The name of the load image view model to use.</param>
/// <param name="windowClass">The main window class instance. (Pass "this")</param>
public static void BindHalconWindow(
ViewROIManager manager,
HSmartWindowControlWPF halconWindow,
string imageBorderName,
string loadImageViewModelName,
MainWindow windowClass)
{
windowClass.DisposeCollection.Add(windowClass.Events().ContentRendered.Subscribe(_ =>
{
// At initialization, the HSmartWindowWPF sometimes shows Width and Height = NaN
// until reset with second image or a zoom.
// This code sets them to actual size before the first use.
halconWindow.Width = halconWindow.ActualWidth;
halconWindow.Height = halconWindow.ActualHeight;
manager.LocHWindowControl = halconWindow;
manager.LocHWindowControl.HZoomContent = HSmartWindowControlWPF.ZoomContent.Off;
manager.LocHWindowControl.ContextMenu.ItemsSource = windowClass.MainViewModel.MenuItems;
// Set the data template.
manager.LocHWindowControl.ContextMenu.ItemTemplate = windowClass.ContextMenuDataTemplate;
// Set the ItemsPanelTemplate.
manager.LocHWindowControl.ContextMenu.ItemsPanel = windowClass.ContextMenuItemsPanelTemplate;
windowClass.DisposeCollection.Add(Observable.FromEventPattern <HSmartWindowControlWPF.HMouseEventArgsWPF>(manager.LocHWindowControl, "HMouseDoubleClick")
.Subscribe(a =>
{
manager.ZoomScale = 0;
windowClass.comboboxZoom.SelectedIndex =
windowClass.comboboxZoom.Items.IndexOf(
windowClass.comboboxZoom.Items.OfType <ComboBoxItem>()
.FirstOrDefault(x => x.Content.ToString() == "Fit"));
}));
}));
windowClass.DisposeCollection.Add(windowClass.MainViewModel.MenuItems.ItemsAdded
.Where(_ => manager.LocHWindowControl != null)
.Subscribe(
_ =>
{
manager.LocHWindowControl.ContextMenu.ItemsSource = windowClass.MainViewModel.MenuItems;
// Set the data template.
manager.LocHWindowControl.ContextMenu.ItemTemplate = windowClass.ContextMenuDataTemplate;
// Set the ItemsPanelTemplate.
manager.LocHWindowControl.ContextMenu.ItemsPanel = windowClass.ContextMenuItemsPanelTemplate;
}));
windowClass.DisposeCollection.Add(windowClass.Events().LayoutUpdated
.Select(_ => System.Reactive.Unit.Default)
.InvokeCommand(manager.AdjustAspectCommand));
ParameterExpression targetParameter = LExpression.Parameter(typeof(MainWindow), "x");
MemberExpression mainVMExp = LExpression.Property(targetParameter, "MainViewModel");
MemberExpression viewModelExp = LExpression.Property(mainVMExp, loadImageViewModelName);
MemberExpression imageHeightExp = LExpression.Property(viewModelExp, "ImageHeight");
MemberExpression imageWidthExp = LExpression.Property(viewModelExp, "ImageWidth");
Expression <Func <MainWindow, int> > imageHeightTargetExp = LExpression.Lambda <Func <MainWindow, int> >(imageHeightExp, new ParameterExpression[] { targetParameter });
Expression <Func <MainWindow, int> > imageWidthTargetExp = LExpression.Lambda <Func <MainWindow, int> >(imageWidthExp, new ParameterExpression[] { targetParameter });
// Using Subscribe here because BindTo sets up a two-way binding which is not wanted.
windowClass.DisposeCollection.Add(windowClass.WhenAnyValue(imageHeightTargetExp)
.Subscribe(x => manager.ImageHeight = x));
windowClass.DisposeCollection.Add(windowClass.WhenAnyValue(imageWidthTargetExp)
.Subscribe(x => manager.ImageWidth = x));
MemberExpression borderExp = LExpression.PropertyOrField(targetParameter, imageBorderName);
MemberExpression actualHeightExp = LExpression.Property(borderExp, "ActualHeight");
MemberExpression actualWidthExp = LExpression.Property(borderExp, "ActualWidth");
Expression <Func <MainWindow, double> > actualHeightTargetExp = LExpression.Lambda <Func <MainWindow, double> >(actualHeightExp, new ParameterExpression[] { targetParameter });
Expression <Func <MainWindow, double> > actualWidthTargetExp = LExpression.Lambda <Func <MainWindow, double> >(actualWidthExp, new ParameterExpression[] { targetParameter });
windowClass.DisposeCollection.Add(windowClass.WhenAnyValue(actualHeightTargetExp)
.Subscribe(x => manager.ContainerHeight = x));
windowClass.DisposeCollection.Add(windowClass.WhenAnyValue(actualWidthTargetExp)
.Subscribe(x => manager.ContainerWidth = x));
}
public static Ex Field <T>(this TEx <T> tex, string field) => Ex.PropertyOrField(tex, field);
public LambdaExpression CreateLambda(Type from, Type to)
{
var input = Ex.Parameter(from, "input");
var eType = to.GetElementType();
var res = Ex.Parameter(typeof(ConversionResult <>).MakeGenericType(eType).MakeArrayType(), "res");
var end = Ex.Label(typeof(ConversionResult <>).MakeGenericType(to), "end");
var fromParameters = from.GetTypeInfo().GenericTypeArguments;
var converters = fromParameters.Select(t => new { Lambda = Ref.GetLambda(t, eType), Input = t }).ToArray();
var block = Ex.Block(new[] { res },
Ex.Assign(res, Ex.NewArrayBounds(typeof(ConversionResult <>).MakeGenericType(eType), Ex.Constant(fromParameters.Length))),
Ex.Block(converters.Select((con, i) =>
Ex.Block(
Ex.Assign(Ex.ArrayAccess(res, Ex.Constant(i)), con.Lambda.ApplyTo(Ex.PropertyOrField(input, $"Item{i + 1}"))),
Ex.IfThen(Ex.Not(Ex.Property(Ex.ArrayIndex(res, Ex.Constant(i)), nameof(IConversionResult.IsSuccessful))),
Ex.Goto(end, NoResult(to)))))),
Ex.Label(end, Result(to,
Ex.NewArrayInit(eType,
Enumerable.Range(0, fromParameters.Length)
.Select(idx => Ex.Property(Ex.ArrayIndex(res, Ex.Constant(idx)), nameof(IConversionResult.Result)))))));
var lambda = Ex.Lambda(block, input);
return(lambda);
}
