MetaLinq - LINQ to Expressions

Commented Task: Move Type property to EditableExpression

ericksoa — Fri, 15 Aug 2008 03:48:34 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
Comments: ** Comment from web user: ericksoa **

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

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)?
Comments: ** Comment from web user: ericksoa **

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.

Source code checked in, #21919

idof — Tue, 12 Aug 2008 10:23:12 GMT

Source code checked in, #21917

idof — Tue, 12 Aug 2008 10:21:03 GMT

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

New Post: What's up with Funclet

idof — Mon, 11 Aug 2008 20:22:20 GMT

I didn't see this class in the .NET framework 3.5 SP1, I guess it was removed (checked it with Reflector to make sure).

New Post: EditableNewArrayExpression.set_NodeType

idof — Mon, 11 Aug 2008 20:18:12 GMT

We have found this to be a bug and it will be fixed on the next release, along with other fixes made to the NewArrayExpression

Updated Release: Serialization support

Mon, 11 Aug 2008 20:13:46 GMT

Add needed code and apply fixes to allow EditableExpression classes to be serialized.
This will enable passing expression trees between layers and persisting them to a DB

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

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

Created Issue: Create a test project for the serialization functionality

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

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

Created Issue: Create code for serializing reflection types

idof — Mon, 11 Aug 2008 19:45:51 GMT

Created Issue: Apply DataContract, DataMember attributes to all classes

idof — Mon, 11 Aug 2008 19:40:51 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

Patch Uploaded: #1656

idof — Mon, 11 Aug 2008 15:18:35 GMT

idof has uploaded a patch.

Description:
This is a sample (code not so clean) for enabling the MetaLinq project to serialize and deserialize expression trees using DataContractSerializer.

Also, the code contains a few bug fixes to MetaLinq (UnaryPlus, fixed NewArrayExpression & ListInitExpression etc...).

There is a demo that shows how it works for various lambda expressions

CREATED RELEASE: Update for Visual Studio 2008 Release (Feb 19, 2008)

Tue, 19 Feb 2008 19:43:40 GMT

Updated to handle changes that occured to the Expression namespace as of the public release of Visual Studio 2008

NEW POST: EditableNewArrayExpression.set_NodeType

francois_tanguay — Mon, 01 Oct 2007 04:20:02 GMT

After looking at the following statements:

if (_nodeType == ExpressionType.NewArrayInit || _nodeType == ExpressionType.NewArrayBounds)
_nodeType = value;
else
throw new InvalidOperationException("NodeType for NewArrayExpression must be ExpressionType.NewArrayInit or ExpressionType.NewArrayBounds");

I think the IF comparison should be performed on value keyword, not _nodeType

NEW POST: What's up with Funclet

francois_tanguay — Mon, 01 Oct 2007 01:00:23 GMT

Is this Pre-Beta2 stuff and it disappeared?

I can't seem to find this espression type anymore.

NEW POST: EditableExpression.CreateEditableExpression

francois_tanguay — Mon, 01 Oct 2007 00:58:24 GMT

Couldn't you simply have a single method?

public static EditableExpression CreateEditableExpression<T>(Expression<T> ex)
{
LambdaExpression lambEx = Expression.Lambda<T>(ex.Body, ex.Parameters);
return new EditableLambdaExpression(lambEx);
}

NEW POST: Good stuff!

francois_tanguay — Mon, 01 Oct 2007 00:38:35 GMT

Haven't looked at it in the details but so far... this rocks!