> I could use just the low level expression stuff which I can then
> traverse to build my own structure but can't find a tutorial on using
> this without extras of the serializer.

> Any tips?

>     public class PyTable
>     {
>         String id;
>         String name;
>         List<PyColumn> columns = new List<PyColumn>();
>         List<List<Object>> data = new List<List<Object>>();
>     }

>     public class PyColumn
>     {
>         const int TEXT = 0;
>         const int INTEGER = 1;
>         const int FLOAT = 2;
>         const int DATE = 3;

>         String id;
>         String name;
>         int typeId;
>     }

>     public class PyTableExpressionHandler : ObjectExpressionHandler
>     {

>         public override bool CanHandle(Type objectType)
>         {
>             return typeof(PyTable).IsAssignableFrom(objectType);
>         }

>         public override Expression GetExpression(object data, JsonPath
> currentPath, ISerializerHandler serializer)
>         {
>             ObjectExpression expression = (ObjectExpression)
> base.GetExpression(data, currentPath, serializer);
>             //TODO: Modify expression if necessary
>             return expression;
>         }

>         public override object Evaluate(Expression expression, object
> existingObject, IDeserializerHandler deserializer)
>         {
>             ObjectExpression objExpr = (ObjectExpression) expression;
>             ArrayExpression columns = (ArrayExpression) objExpr
> ["columns"]; //List<PyColumn> columns
>             ArrayExpression data = (ArrayExpression) objExpr
> ["data"]; //List<List<Object>> data
>             // Add type info to data via Cast
>             for (int i = 0; i < columns.Items.Count; i++) {
>                 // assume columns and data have same length
>                 Type dataType = null;
>                 // TODO: figure out data type from column info:
> ((ValueExpression)((ObjectExpression)columns[i])
> ["typeId"]).StringValue
>                ArrayExpression dataRow = (ArrayExpression) data.Items
> [i];
>                for (int j = 0; j < dataRow.Items.Count; j++) {
>                   dataRow.Items[j] = new CastExpression(dataType,
> dataRow.Items[i]);
>                }
>             }
>             return base.Evaluate(expression, existingObject,
> deserializer);
>         }

>     }

> Here is how to set it up in the serializer:
>             Serializer s = new Serializer(typeof(List<PyTable>));
>             s.Context.ExpressionHandlers.Insert(0, new
> PyTableExpressionHandler());

> If your object is really as simple as you've shown you could
> potentially evaluate some of it on your own and just put it in the
> final expression.  You can evaluate any expression by passing it to
> the IDeserializerHandler instance that gets passed into the Evaluate
> method.  You just need to set the ResultType property on the
> expression first.  If you do go this route, just make sure you remove
> any child expressions from the main expression that you've already
> evaluated before passing them to the base method, and then update the
> object that gets passed back to you.

> On Sep 10, 11:11 am, John <j...@jdiligence.com> wrote:

> > I need to override some elements and change the way they are
> > serialized depending on other fields within the object. Below the type
> > of object in the list of lists (data) depends on the column object
> > within the same object. How can I do this?

> > I could use just the low level expression stuff which I can then
> > traverse to build my own structure but can't find a tutorial on using
> > this without extras of the serializer.

> > Any tips?

> >     public class PyTable
> >     {
> >         String id;
> >         String name;
> >         List<PyColumn> columns = new List<PyColumn>();
> >         List<List<Object>> data = new List<List<Object>>();
> >     }

> >     public class PyColumn
> >     {
> >         const int TEXT = 0;
> >         const int INTEGER = 1;
> >         const int FLOAT = 2;
> >         const int DATE = 3;

> >         String id;
> >         String name;
> >         int typeId;
> >     }

> and the test is here (DataTableSerialize method at the bottom of the
> file):http://code.google.com/p/jsonexserializer/source/browse/trunk/JsonExS...

> On Sep 12, 11:33 pm, Ted Elliott <elliott....@gmail.com> wrote:

> > Here's an example of an Expression handler to get you started.  It
> > sounds like maybe you just need to tell the serializer what the data
> > types are during deserialization so I've left GetExpression (called
> > during serialization) not doing much.  Evaluate is called during
> > deserialization and I've put in some code there to get you started.
> > To set the type you basically need to wrap an expression in a
> > CastExpression passing in the appropriate data type.  Here is the wiki
> > page for the different expression types:http://code.google.com/p/jsonexserializer/wiki/Expressions,
> > sorry there's nothing yet on the handlers themselves.

> >     public class PyTableExpressionHandler : ObjectExpressionHandler
> >     {

> >         public override bool CanHandle(Type objectType)
> >         {
> >             return typeof(PyTable).IsAssignableFrom(objectType);
> >         }

> >         public override Expression GetExpression(object data, JsonPath
> > currentPath, ISerializerHandler serializer)
> >         {
> >             ObjectExpression expression = (ObjectExpression)
> > base.GetExpression(data, currentPath, serializer);
> >             //TODO: Modify expression if necessary
> >             return expression;
> >         }

> >         public override object Evaluate(Expression expression, object
> > existingObject, IDeserializerHandler deserializer)
> >         {
> >             ObjectExpression objExpr = (ObjectExpression) expression;
> >             ArrayExpression columns = (ArrayExpression) objExpr
> > ["columns"]; //List<PyColumn> columns
> >             ArrayExpression data = (ArrayExpression) objExpr
> > ["data"]; //List<List<Object>> data
> >             // Add type info to data via Cast
> >             for (int i = 0; i < columns.Items.Count; i++) {
> >                 // assume columns and data have same length
> >                 Type dataType = null;
> >                 // TODO: figure out data type from column info:
> > ((ValueExpression)((ObjectExpression)columns[i])
> > ["typeId"]).StringValue
> >                ArrayExpression dataRow = (ArrayExpression) data.Items
> > [i];
> >                for (int j = 0; j < dataRow.Items.Count; j++) {
> >                   dataRow.Items[j] = new CastExpression(dataType,
> > dataRow.Items[i]);
> >                }
> >             }
> >             return base.Evaluate(expression, existingObject,
> > deserializer);
> >         }

> >     }

> > Here is how to set it up in the serializer:
> >             Serializer s = new Serializer(typeof(List<PyTable>));
> >             s.Context.ExpressionHandlers.Insert(0, new
> > PyTableExpressionHandler());

> > If your object is really as simple as you've shown you could
> > potentially evaluate some of it on your own and just put it in the
> > final expression.  You can evaluate any expression by passing it to
> > the IDeserializerHandler instance that gets passed into the Evaluate
> > method.  You just need to set the ResultType property on the
> > expression first.  If you do go this route, just make sure you remove
> > any child expressions from the main expression that you've already
> > evaluated before passing them to the base method, and then update the
> > object that gets passed back to you.

> > On Sep 10, 11:11 am, John <j...@jdiligence.com> wrote:

> > > I need to override some elements and change the way they are
> > > serialized depending on other fields within the object. Below the type
> > > of object in the list of lists (data) depends on the column object
> > > within the same object. How can I do this?

> > > I could use just the low level expression stuff which I can then
> > > traverse to build my own structure but can't find a tutorial on using
> > > this without extras of the serializer.

> > > Any tips?

> > >     public class PyTable
> > >     {
> > >         String id;
> > >         String name;
> > >         List<PyColumn> columns = new List<PyColumn>();
> > >         List<List<Object>> data = new List<List<Object>>();
> > >     }

> > >     public class PyColumn
> > >     {
> > >         const int TEXT = 0;
> > >         const int INTEGER = 1;
> > >         const int FLOAT = 2;
> > >         const int DATE = 3;

> > >         String id;
> > >         String name;
> > >         int typeId;
> > >     }

> Thank you for your informative responses I will try them out and see
> what happens.

> The only concern I have is that when deserializing I cannot guarantee
> the order of the fields, so the data fields may appear before the
> column definitions that they rely on in the stream.

> Would this be a show stopper before I get stuck in later today?

> Thanks a lot. I got the desrialization working in the end. Will work
> on the other side of the coin today.

> In doing this I noticed it would be really useful to decouple the
> property resolution as between different languages there are different
> naming conventions for properties.

> I ended up renaming all my c sharp properties in ways that are not c
> sharp convention, in order to match the services supplying the json.

> If there was a pluggable property name resolver, this wouldn't be a
> problem. So for instance it could captialize the first letter if
> required etc

> Is there such a means in there already?

> JSON is used a lot to interchange between systems in different
> languages.
> XML is too bloat if the messages are big. In our system they can be
> huge.
> This is also a good argument for making JSON parsers work on streams
> rather
> than loading strings into memory and building intermediary objects.
> When
> you have over 100,000 records garbage collection can start to be an
> issue.
> Its a bitlate to take this approach with your parser but the property
> naming thing
> is pretty easy to change.

> The project I am working on is written in VBA, C sharp, java and
> python!

> Programmers in each have different conventions for naming properties
> and typcially follow them.

> Typically in java is camel case i.e. customerName
> Typically in python its underscored lower case i.e. customer_name
> Typically in C sharp its CustomerName

> By being able to plug your own strategy you can translate say
> customer_name into CustomerName

> So if you could add an interface IPropertyNameResolver or similar then
> people could override the
> default strategy when talking via JSON to another system written by
> developers using their own conventions.

> This is more flexible than simple case insensitivity but you could add
> a CaseInsensitiveProperyResolverImpl
> for people who want it.