metalinq Work Item Rss Feed

Created Issue: Nuget [22509]

mcintyre321 — Sat, 14 Apr 2012 12:44:21 GMT

Would you like to put this on to Nuget, or would you mind if I did so?

Commented Issue: Cannot serialize expressions that include captured variables [10990]

mwpowellnm — Sun, 04 Sep 2011 14:55:23 GMT

captured variables are compiled into private sealed classes and therefore cannot be serialized - trying to serializing such an expression fails
Comments: ** Comment from web user: mwpowellnm **

it's been awhile since this was last commented on. can you clarify what this means? if I understand it rightly, if I capture a local variable int i = 3 in my Lambda Expression prior to serializing, I should be unable to compile or necessarily invoke the same Lambda Expression when I deserialize it... unless I've also got an int i in the same scope as that? thank you... if so, it seems to me variables that can be "seen" is a reasonable "limitation" operating with Lambdas, and necessarily disciplines developers to make proper use of them.

Created Issue: Expression Constant comparing Nullable fails with InvalidOperationException [20253]

RobinHSanner — Thu, 17 Mar 2011 16:10:10 GMT

The exception below occurs when comparing an object property that is a Nullable<DateTime>. The attached file resolved the problem.

System.InvalidOperationException was unhandled
Message=The binary operator LessThanOrEqual is not defined for the types 'System.Nullable`1[System.DateTime]' and 'System.DateTime'.
Source=System.Core
StackTrace:
at System.Linq.Expressions.Expression.GetComparisonOperator(ExpressionType binaryType, String opName, Expression left, Expression right, Boolean liftToNull)
at System.Linq.Expressions.Expression.LessThanOrEqual(Expression left, Expression right, Boolean liftToNull, MethodInfo method)
at System.Linq.Expressions.Expression.MakeBinary(ExpressionType binaryType, Expression left, Expression right, Boolean liftToNull, MethodInfo method, LambdaExpression conversion)
at System.Linq.Expressions.Expression.MakeBinary(ExpressionType binaryType, Expression left, Expression right)
at ExpressionBuilder.EditableBinaryExpression.ToExpression() in D:\Visual Studio Projects\Deloitte - Innovation Center\Dev\Phase 1\TestApps\Diet.Expressions\ExpressionBuilder\Expressions\EditableBinaryExpression.cs:line 48
at ExpressionBuilder.EditableBinaryExpression.ToExpression() in D:\Visual Studio Projects\Deloitte - Innovation Center\Dev\Phase 1\TestApps\Diet.Expressions\ExpressionBuilder\Expressions\EditableBinaryExpression.cs:line 48
at ExpressionBuilder.EditableBinaryExpression.ToExpression() in D:\Visual Studio Projects\Deloitte - Innovation Center\Dev\Phase 1\TestApps\Diet.Expressions\ExpressionBuilder\Expressions\EditableBinaryExpression.cs:line 48
at ExpressionBuilder.EditableLambdaExpression.ToExpression() in D:\Visual Studio Projects\Deloitte - Innovation Center\Dev\Phase 1\TestApps\Diet.Expressions\ExpressionBuilder\Expressions\EditableLambdaExpression.cs:line 53

Created Issue: cannot serialize EditableMemeberInfoCollection [15760]

habmic — Thu, 07 Jan 2010 09:49:53 GMT

hello,
i am tring to cearte an expression, serialize it and then save it to my db.
the expression is like this:

Expression<Func<Person,List<Address>>> exp = (person) => person.HasAddress ? person.Addresses.ToList() : new List<Address>();

then i serialize it using DataContactSerializer.
up until now every thing is working fine.

i am deserializing it from the DB and save it in velocity cache,
then i am getting this expection:
"Type 'Address' cannot be serialized. Consider marking it with the DataContractAttribute attribute, and marking all of its members you want serialized with the DataMemberAttribute attribute"

any idea?
thanks!

Closed Issue: MethodCallExpression fails on handling static methods

idof — Fri, 27 Feb 2009 13:15:12 GMT

There's no check if the object property is null (in case it's a static method)

Created Issue: MethodCallExpression fails on handling static methods

idof — Fri, 27 Feb 2009 12:40:43 GMT

There's no check if the object property is null (in case it's a static method)

Created Issue: Converting Expressions with static method calls back into System.Linq Expressions

Liqdfire — Thu, 26 Feb 2009 14:52:37 GMT

When converting methods back into System.Linq expressions via the ToExpression() method call, if the original expression had a static method call a null reference exception would occur in the ToExpression() method of the EditableMethodCallExpression class. The issue comes from the following line
"return Expression.Call(Object.ToExpression(), Method, Arguments.GetExpressions().ToArray<Expression>());" the property Object is null for static (Shared in VB) method calls. According to the MSDN Documentation for the Expression.Call method, the first parameter needs to be null for static method calls. Therefore, changing the method body tot he following resolves the issue:

// Methods
public override Expression ToExpression()
{
if (Object == null)
{
return Expression.Call(null, Method, Arguments.GetExpressions().ToArray<Expression>());
}
else
{
return Expression.Call(Object.ToExpression(), Method, Arguments.GetExpressions().ToArray<Expression>());
}
}

Closed Issue: Apply DataContract, DataMember attributes to all classes

idof — Thu, 09 Oct 2008 10:20:23 GMT

DataContract is needed to allow serialization of the classes with DataContractSerializer.
Indeed, we can use the serializer without putting the attributes, but in some of the classes we'll use serialization that is not the default (such as not serializing public properties) so we'll add the attribute to generalize the solution approach

Closed Task: Add xml serializer attributes to support serialization with XmlSerializer

idof — Thu, 09 Oct 2008 10:20:22 GMT

Add XmlIgnore elements where needed

Created Task: Add xml serializer attributes to support serialization with XmlSerializer

idof — Tue, 07 Oct 2008 20:02:04 GMT

Add XmlIgnore elements where needed

Closed Task: Create a test project for the serialization functionality

idof — Sun, 05 Oct 2008 15:20:34 GMT

Create a test project that executes different lambda expressions serialization back-and-forth

Closed Task: Move Type property to EditableExpression

idof — Sun, 05 Oct 2008 15:20:32 GMT

Expression class holds a Type property, while in MetaLinq, only a few EditableExpression classes have a Type property.

It's preferable to move the Type property to the base class, so it will match the structure of the Expression classes. Furthermore, it's possible Type properties will be needed in other EditableExpression classes, so moving the property from the start will allow simpler fixes on the long run

Closed Issue: Create code for serializing reflection types

idof — Sun, 05 Oct 2008 14:53:03 GMT

Expression types holds properties of reflection type (Type, MemberInfo, ConstructorInfo...) and these types cannot be serialized.

Consider adding a wrap property on reflection types that can be serialized and deserialized to the reflected type.

Idea - save the type qualified name (including assembly) + member identifier (MetadataToken)?

Closed Issue: Not all possible overloades are covered by the Editable classes

idof — Sun, 05 Oct 2008 14:53:01 GMT

UnaryExpression and BinaryExpression are missing some of the properties of the immutable expression classes. Check when they are used and how they can be implemented in the muttable expression classes

Commented Task: Move Type property to EditableExpression

ericksoa — Fri, 15 Aug 2008 03:48:34 GMT

Agree. Some of the code reflects what the Expression namespace was doing as early as beta 1 and earlier, so there is bound to be some old cruft that could be refactored out

Commented Issue: Cannot serialize expressions that include captured variables

ericksoa — Fri, 15 Aug 2008 03:47:15 GMT

captured variables are compiled into private sealed classes and therefore cannot be serialized - trying to serializing such an expression fails
Comments: ** Comment from web user: ericksoa **

I think for now we just have to accept this as a limitation.

Commented Issue: Create code for serializing reflection types

ericksoa — Fri, 15 Aug 2008 03:45:49 GMT

I think that is about the best we can do for now... this was one of the serialization scenarios that has been stumping me for awhile - have not had time to really think it through though.

Created Issue: Cannot serialize expressions that include captured variables

idof — Tue, 12 Aug 2008 10:13:05 GMT

captured variables are compiled into private sealed classes and therefore cannot be serialized - trying to serializing such an expression fails

Created Task: Move Type property to EditableExpression

idof — Mon, 11 Aug 2008 19:55:07 GMT

Created Issue: Not all possible overloades are covered by the Editable classes

idof — Mon, 11 Aug 2008 19:50:48 GMT