How may value types in LINQ/lambdas/expression trees be checked at compile time?

.net c# expression-trees lambda linq

Question

I'm using the following code to set Control properties in a thread-safe manner:

private delegate void SetPropertyThreadSafeDelegate<TPropertyType>(Control @this, Expression<Func<TPropertyType>> property, TPropertyType value);

public static void SetPropertyThreadSafe<TPropertyType>(this Control @this, Expression<Func<TPropertyType>> property, TPropertyType value)
{
  var propertyInfo = (property.Body as MemberExpression ?? (property.Body as UnaryExpression).Operand as MemberExpression).Member as PropertyInfo;

  if (propertyInfo == null ||
      !propertyInfo.ReflectedType.IsAssignableFrom(@this.GetType()) ||
      @this.GetType().GetProperty(propertyInfo.Name, propertyInfo.PropertyType) == null)
  {
    throw new ArgumentException("The lambda expression 'property' must reference a valid property on this Control.");
  }

  if (propertyInfo.PropertyType.IsValueType &&
      !propertyInfo.PropertyType.IsAssignableFrom(typeof(TPropertyType)))
  {
    throw new ArgumentException(string.Format("Attempted to assign incompatible value type: expecting {0}, got {1}.", propertyInfo.PropertyType, typeof(TPropertyType)));
  }

  if (@this.InvokeRequired)
  {
    @this.Invoke(new SetPropertyThreadSafeDelegate<TPropertyType>(SetPropertyThreadSafe), new object[] { @this, property, value });
  }
  else
  {
    @this.GetType().InvokeMember(propertyInfo.Name, BindingFlags.SetProperty, null, @this, new object[] { value });
  }
}

It's called like so:

downloadProgressBar.SetPropertyThreadSafe(() => downloadProgressBar.Step, 32);

The reason for doing this is to get compile-time checking of property names and type assignments. It works perfectly for standard objects, but everything goes a bit pear-shaped with value types because the compiler is happy to accept the following, which of course bombs at runtime:

downloadProgressBar.SetPropertyThreadSafe(() => downloadProgressBar.Step, 'c');
downloadProgressBar.SetPropertyThreadSafe(() => downloadProgressBar.Step, long.MaxValue);

I've already modified the SetPropertyThreadSafe method to handle the case when value types are used, and throw an exception if the incorrect type is used as an argument, but what I'm really loooking for is the ability to get this method to perform compile-time type checking for 100% of cases, i.e. objects and value types. Is this even possible and if so how would I need to modify my code to do this?

1
1
4/15/2011 7:58:06 PM

Fastest Entity Framework Extensions

Bulk Insert
Bulk Delete
Bulk Update
Bulk Merge

Accepted Answer

Change the contract to:

public static void SetPropertyThreadSafe<TPropertyType, TValue>(
        this Control self,
        Expression<Func<TPropertyType>> property,
        TValue value)
        where TValue : TPropertyType

Note that with this you no longer need to do the IsAssignableFrom check since the compiler will enforce it.

The reasons your example compiled is because the compiler made a guess as to what the type parameter was. Here is what the compiler turns those calls into:

progBar.SetPropertyThreadSafe<int>(() => progBar.Step, 'c');
progBar.SetPropertyThreadSafe<long>(() => progBar.Step, long.MaxValue);

Notice how the first one is int, that's because ProgressBar.Step is an int and 'c' is a char which has an implicit conversion to int. Same with the next example, int has an implicit conversion to long, and the second one is long, so the compiler guesses that it is long.

If you want inheritance and conversions like those to work, don't make the compiler guess. Your two solutions are:

  1. Always specify the type perameter. In this case, you would have noticed that the second one is long, and fixed the problem.

Of course this is less than ideal, because then you are basically hard coding in the type of the Func. What you really want to do is let the compiler determine both types and tell you if they are compatible.

  1. Provide a different type for both so that the compiler can figure it out for you.

NOTE: Below is the code that I would use, which is entirely different from yours:

    public static void SetPropertyThreadSafe<TControl>(this TControl self, Action<TControl> setter)
        where TControl : Control
    {
        if (self.InvokeRequired)
        {
            var invoker = (Action)(() => setter(self));
            self.Invoke(invoker);
        }
        else
        {
            setter(self);
        }
    }

    public static void Example()
    {
        var progBar = new ProgressBar();
        progBar.SetPropertyThreadSafe(p => p.Step = 3);
    }
3
4/25/2011 11:56:24 AM

Popular Answer

You just need to make some minor changes to your generic and expression:

public static void SetPropertyThreadSafe<TSource, TPropertyType>(this TSource source, Expression<Func<TSource, TPropertyType>> property, TPropertyType value)

Then you supply a lambda like so:

var someObject = new /*Your Object*/

someObject.SetPropertyThreadSafe(x => x.SomeProperty, /* Your Value */);

The value you specify must be covariant to the type of SomeProperty, and this is checked at compile time. Let me know if I'm misunderstanding something. If you need to constrain it to Control, you simply change the signature to 

this Control source

or 

where TSource : Control
Tejs

Related Questions

Obtaining a parameterExpression's run-time value in an expression tree

I am missing the obvious: How do I access the value of a parameter inside a lambda expression expression tree? ...Scenario: For a delegate x I dynamically create a lambda expression with an expression tree body which has the same signature as the delegate x. Inside the lamdba's body, I do some validation, checking, logging stuff (this is just testi...
c# c#-4.0 delegates expression-trees lambda
asked by dalo

Scoping resolution - expression tree - compile inner lambda in outer lambda

With help from Balazs Tihanyi I found solution that works for me exactly as I need it. It is a bit more work because I had to create binders, but I my main project I already had them, so I created dummy binders for this example to work....This is my final solution:...using System; using System.Collections.Generic; using System.Linq; using System.T...
c# dynamic-language-runtime expression-trees scope
asked by del-boy

Unable to cast object of type 'System.Linq.Expressions.UnaryExpression' to type 'System.Linq.Expressions.MemberExpression'

This is ...apparently... related to boxing/unboxing. Lambda expressions returning value types that require boxing will be represented as UnaryExpressions whereas those that return reference types will be represented as MemberExpressions.
c# exception-handling expression-trees linq
asked by Scott Munro

Use lambda return value for expression tree

I try to play a bit with expression trees. I have an object with a ...List<string>... and I want to build an expression tree that add a value to this property, but I want to specify the value to add through a ...Func.... Currently I try this......public static Action<T> CreateMethodAddObjectToList<T, C>(this Type type, string property, Func<C> ctor...
c# expression-trees lambda
asked by Sebastian

Evaluate Lambda Expression as part of Expression Tree

So, if I understand you correctly, you want to create a lambda (expression) which uses your passed function and does some additional work around it. So you essentially just want to use this function inside of an expression....At this point, allow me to suggest that you don’t even use expressions. You could just create a function that takes a ...F...
c# expression-trees lambda
asked by poke

How do I create a Linq expression tree with an F# lambda?

Here's what can be done in C# -...var two = 2; System.Linq.Expressions.Expression<System.Func<int, int>> expr = x => x * two; expr.Compile().Invoke(4); // returns 8 ...I wish to do the precise equivalent in F#. Here's what I tried, but did not compile -...let two = 2 let expr = (fun x -> x * two) : System.Linq.Expressions.Expression<System.Func<int...
c# expression-trees f# linq
asked by Bryan Edds

How to call a lambda using LINQ expression trees in C# / .NET

I want to use expression trees to dynamically create a method to call a lambda. The following code runs fine for the first call to the ComposeLambda function, but the second call fails with the following error message....Incorrect number of arguments supplied for call to method 'Int32 lambda_method(System.Runtime.CompilerServices.Closure, Int32)'...
.net c# expression-trees lambda linq
asked by Philipp Kramer

Best way to check if value is null in Expression Tree

What is the best way to check if constant is null in Expression Trees?...// Method to call (Regex.IsMatch) MethodInfo isMatchMethod = typeof(Regex).GetMethod("IsMatch", new[] { typeof(string), typeof(string), typeof(RegexOptions) }); // The member you want to evaluate: (x => x.<property_name>) var member = Expression.Property(param, propertyName);...
c# expression-trees
asked by Vitone

Create Lambda Expression Selector For New Class Using Expression Tree

Related To:...Create Expression Tree For Selector...Create a Lambda Expression With 3 conditions...Convert Contains To Expression Tree...Convert List.Contains to Expression Tree...I want to Create ...Selector... expression using ...Expression Tree... for new class. Please Consider this code:...s => new Allocation { Id = s.Id, ...
c# c#-6.0 expression-trees lambda linq
asked by Arian

How do I create a lambda expression using return value from another lambda expression?

Neither the question nor the answer is the same as the question "Convert Linq expression “obj => obj.Prop” into “parent => parent.obj.Prop”".... The only duplicate I've found on here lately is the number of duplicate mods with control issues....I'm attempting to make a extension method for Entity Framework that will add a "Contains" call o...
c# entity-framework expression-trees lambda linq-expressions
asked by TheSoftwareJedi

Fastest Entity Framework Extensions

Bulk Insert
Bulk Delete
Bulk Update
Bulk Merge
View more on Stack Overflow

Prime Library

Performance

Expression Evaluator

More Projects...
Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow
Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow