protected virtual Expression GetExpression(IEnumerable Items, Type ItemType, JsonPath CurrentPath, ISerializerHandler serializer) { int index = 0; ArrayExpression expression = new ArrayExpression(); foreach (object value in Items) { Expression itemExpr = serializer.Serialize(value, CurrentPath.Append(index)); if (value != null && !ReflectionUtils.AreEquivalentTypes(value.GetType(), ItemType)) { itemExpr = new CastExpression(value.GetType(), itemExpr); } expression.Add(itemExpr); index++; } return expression; }
public void VisitCast(CastExpression Cast) { Visit(Cast.Expression); }
/// <summary> /// Parses a type cast. Will also parse the expression that the cast applies to. /// The result will be the expression following the cast with the ResultType set to /// the type of the cast. /// </summary> /// <returns>casted expression</returns> private Expression ParseCast() { Token tok = ReadToken(); Debug.Assert(tok == LParenToken, "Invalid starting token for ParseCast: " + tok); Type desiredType = ParseTypeSpecifier(); CastExpression cast = new CastExpression(desiredType); tok = ReadToken(); RequireToken(RParenToken, tok, "Invalid Type Cast Syntax"); cast.Expression = ParseExpression(); return cast; }
/// <summary> /// Creates an json object expression from object data. /// </summary> /// <param name="data">the data to serialize</param> /// <param name="currentPath">current path to the object</param> /// <param name="serializer">serializer instance used to serialize key values</param> /// <returns>json object expression</returns> public override Expression GetExpression(object data, JsonPath currentPath, ISerializerHandler serializer) { TypeData handler = Context.GetTypeHandler(data.GetType()); ObjectExpression expression = new ObjectExpression(); foreach (IPropertyData prop in handler.Properties) { object value = prop.GetValue(data); Expression valueExpr; if (prop.HasConverter) { valueExpr = serializer.Serialize(value, currentPath.Append(prop.Name), prop.TypeConverter); } else { valueExpr = serializer.Serialize(value, currentPath.Append(prop.Name)); } if (value != null && !ReflectionUtils.AreEquivalentTypes(value.GetType(), prop.PropertyType)) { valueExpr = new CastExpression(value.GetType(), valueExpr); } expression.Add(prop.Name, valueExpr); } return expression; }
/// <summary> /// Serialize the given object /// </summary> /// <param name="value">object to serialize</param> public void Serialize(object value) { //if (value != null && _context.OutputTypeComment) //{ // string comment = ""; // comment += "/*" + "\r\n"; // comment += " Created by JsonExSerializer" + "\r\n"; // comment += " Assembly: " + value.GetType().Assembly.ToString() + "\r\n"; // comment += " Type: " + value.GetType().FullName + "\r\n"; // comment += "*/" + "\r\n"; // this.WriteComment(comment); //} Expression expr = Serialize(value, new JsonPath(), null); if (value != null && !ReflectionUtils.AreEquivalentTypes(value.GetType(), _serializedType)) { expr = new CastExpression(value.GetType(), expr); } ExpressionWriter.Write(this, _context, expr); }
/// <summary> /// Serialize an object implementing IDictionary. The serialized data is similar to a regular /// object, except that the keys of the dictionary are used instead of properties. /// </summary> /// <param name="data">the dictionary object</param> /// <param name="currentPath">object's path</param> /// <param name="serializer">the serializer instance, used to serialize keys and values</param> public override Expression GetExpression(object data, JsonPath currentPath, ISerializerHandler serializer) { IDictionary dictionary = (IDictionary)data; Type itemType = typeof(object); Type genericDictionary = null; if ((genericDictionary = dictionary.GetType().GetInterface(typeof(IDictionary<,>).Name)) != null) { itemType = genericDictionary.GetGenericArguments()[1]; } ObjectExpression expression = new ObjectExpression(); foreach (DictionaryEntry pair in dictionary) { //may not work in all cases object value = pair.Value; Expression valueExpr = serializer.Serialize(value, currentPath.Append(pair.Key.ToString())); if (value != null && !ReflectionUtils.AreEquivalentTypes(value.GetType(), itemType)) { valueExpr = new CastExpression(value.GetType(), valueExpr); } expression.Add(pair.Key.ToString(), valueExpr); } return expression; }
/// <summary> /// Serializes the data into a json array expression. /// </summary> /// <param name="data">the data to serialize</param> /// <param name="currentPath">the current path to the data</param> /// <param name="serializer">serializer instance to use to serialize list items</param> /// <returns>a json array expression representation</returns> public override Expression GetExpression(object data, JsonPath currentPath, ISerializerHandler serializer) { TypeData handler = Context.GetTypeHandler(data.GetType()); CollectionHandler collectionHandler = handler.GetCollectionHandler(); Type elemType = collectionHandler.GetItemType(handler.ForType); int index = 0; ArrayExpression expression = new ArrayExpression(); foreach (object value in collectionHandler.GetEnumerable(data)) { Expression itemExpr = serializer.Serialize(value, currentPath.Append(index)); if (value != null && !ReflectionUtils.AreEquivalentTypes(value.GetType(), elemType)) { itemExpr = new CastExpression(value.GetType(), itemExpr); } expression.Add(itemExpr); index++; } return expression; }