public static void JsonResponse(HttpResponse response, Action<JsonWriter> writeAction)
{
response.ClearHeaders();
response.ClearContent();
JsonWriter writer = new JsonWriter(response.Output);
writeAction(writer);
writer.Flush();
}
protected abstract void WriteResult(JsonWriter writer);
private void SerializeDictionary(JsonWriter writer, IDictionary values)
{
writer.WriteStartObject();
foreach (DictionaryEntry entry in values)
{
writer.WritePropertyName(entry.Key.ToString());
SerializeValue(writer, entry.Value);
}
writer.WriteEndObject();
}
public virtual void WriteJson(JsonWriter writer, object value)
{
JsonSerializer serializer = new JsonSerializer();
serializer.Serialize(writer, value);
}
private void SerializeCollection(JsonWriter writer, ICollection values)
{
object[] collectionValues = new object[values.Count];
values.CopyTo(collectionValues, 0);
SerializeList(writer, collectionValues);
}
private void SerializeList(JsonWriter writer, IList values)
{
writer.WriteStartArray();
for (int i = 0; i < values.Count; i++)
{
SerializeValue(writer, values[i]);
}
writer.WriteEndArray();
}
private void SerializeObject(JsonWriter writer, object value)
{
Type objectType = value.GetType();
TypeConverter converter = TypeDescriptor.GetConverter(objectType);
// use the objectType's TypeConverter if it has one and can convert to a string
if (converter != null && !(converter is ComponentConverter) && converter.GetType() != typeof(TypeConverter))
{
if (converter.CanConvertTo(typeof(string)))
{
writer.WriteValue(converter.ConvertToInvariantString(value));
return;
}
}
writer.SerializeStack.Add(value);
writer.WriteStartObject();
if (_serializeFullObject)
{
List<MemberInfo> members = ReflectionUtils.GetFieldsAndProperties(objectType, BindingFlags.Public | BindingFlags.Instance);
foreach (MemberInfo member in members)
{
if (ReflectionUtils.CanReadMemberValue(member) && !member.IsDefined(typeof(JsonIgnoreAttribute), true))
WriteMemberInfoProperty(writer, value, member);
}
}
else
{
List<PropertyInfo> members = ReflectionUtils.GetProperties(objectType, BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
foreach (PropertyInfo member in members)
{
if (ReflectionUtils.CanReadMemberValue(member) &&
!member.IsDefined(typeof(System.Xml.Serialization.XmlIgnoreAttribute), true))
WritePropertyInfo(writer, value, member);
}
}
writer.WriteEndObject();
writer.SerializeStack.Remove(value);
}
private void WritePropertyInfo(JsonWriter writer, object value, PropertyInfo member)
{
if (!ReflectionUtils.IsIndexedProperty(member))
{
object memberValue = ((PropertyInfo)member).GetValue(value, null);
if (writer.SerializeStack.IndexOf(memberValue) != -1)
{
switch (_referenceLoopHandling)
{
case ReferenceLoopHandling.Error:
throw new Exception("Self referencing loop");
case ReferenceLoopHandling.Ignore:
// return from method
return;
case ReferenceLoopHandling.Serialize:
// continue
break;
default:
throw new InvalidOperationException(string.Format("Unexpected ReferenceLoopHandling value: '{0}'", _referenceLoopHandling));
}
}
writer.WritePropertyName(member.Name);
SerializeValue(writer, memberValue);
}
}
private void SerializeValue(JsonWriter writer, object value)
{
JsonConverter converter;
if (value == null)
{
writer.WriteNull();
}
else if (HasMatchingConverter(value.GetType(), out converter))
{
converter.WriteJson(writer, value);
}
else if (value is IConvertible)
{
IConvertible convertible = value as IConvertible;
switch (convertible.GetTypeCode())
{
case TypeCode.String:
writer.WriteValue((string)convertible);
break;
case TypeCode.Char:
writer.WriteValue((char)convertible);
break;
case TypeCode.Boolean:
writer.WriteValue((bool)convertible);
break;
case TypeCode.SByte:
writer.WriteValue((sbyte)convertible);
break;
case TypeCode.Int16:
writer.WriteValue((short)convertible);
break;
case TypeCode.UInt16:
writer.WriteValue((ushort)convertible);
break;
case TypeCode.Int32:
writer.WriteValue((int)convertible);
break;
case TypeCode.Byte:
writer.WriteValue((byte)convertible);
break;
case TypeCode.UInt32:
writer.WriteValue((uint)convertible);
break;
case TypeCode.Int64:
writer.WriteValue((long)convertible);
break;
case TypeCode.UInt64:
writer.WriteValue((ulong)convertible);
break;
case TypeCode.Single:
writer.WriteValue((float)convertible);
break;
case TypeCode.Double:
writer.WriteValue((double)convertible);
break;
case TypeCode.DateTime:
//if (_serializeFullObject)
//writer.WriteValue((DateTime)convertible);
//else
writer.WriteValue(((DateTime)convertible).ToString("s"));
break;
case TypeCode.Decimal:
writer.WriteValue((decimal)convertible);
break;
default:
SerializeObject(writer, value);
break;
}
}
else if (value is IList)
{
if (_serializeFullObject)
{
SerializeList(writer, (IList)value);
}
else
{
writer.SerializeStack.Add(value);
writer.WriteStartObject();
Type instanceType = value.GetType().UnderlyingSystemType.DeclaringType;
if (value.GetType().UnderlyingSystemType.DeclaringType != typeof(IList))
{
List<PropertyInfo> members = ReflectionUtils.GetProperties(value.GetType(), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
if (members.Count > 0)
{
foreach (PropertyInfo member in members)
{
if (member.CanRead &&
!member.IsDefined(typeof(System.Xml.Serialization.XmlIgnoreAttribute), true))
{
WritePropertyInfo(writer, value, member);
}
}
}
}
if (!(value is ArrayList))
{
writer.WritePropertyName("List");
}
SerializeList(writer, (IList)value);
writer.WriteEndObject();
writer.SerializeStack.Remove(value);
}
}
else if (value is IDictionary)
{
SerializeDictionary(writer, (IDictionary)value);
}
else if (value is ICollection)
{
SerializeCollection(writer, (ICollection)value);
}
else if (value is Identifier)
{
writer.WriteRaw(value.ToString());
}
else
{
//Type valueType = value.GetType();
SerializeObject(writer, value);
}
writer.Flush();
}
/// <summary>
/// Serializes the specified <see cref="Object"/> and writes the Json structure
/// to a <c>Stream</c> using the specified <see cref="JsonWriter"/>.
/// </summary>
/// <param name="jsonWriter">The <see cref="JsonWriter"/> used to write the Json structure.</param>
/// <param name="value">The <see cref="Object"/> to serialize.</param>
public void Serialize(JsonWriter jsonWriter, object value)
{
_serializeFullObject = true;
if (jsonWriter == null)
throw new ArgumentNullException("jsonWriter");
if (value == null)
throw new ArgumentNullException("value");
SerializeValue(jsonWriter, value);
}
public static string Serialize(object value, bool serializeFull)
{
if (value == null)
{
return String.Empty;
}
_serializeFullObject = serializeFull;
using (System.IO.StringWriter sw = new System.IO.StringWriter())
{
using (JsonWriter jsonWriter = new JsonWriter(sw))
{
_singleInstance.SerializeValue(jsonWriter, value);
}
return sw.ToString();
}
}
