| static private GetEnumerator ( object enumerable ) : IEnumerator | ||
| enumerable | object | Enumerable. It must be disposed by the caller. |
| return | IEnumerator | |
private Array CoerceArray(Type elementType, IEnumerable value)
{
ArrayList target = new ArrayList();
var enumerator = TypeCoercionUtility.GetEnumerator(value);
if (enumerator == null)
{
throw new JsonTypeCoercionException(string.Format("Requested to get an IEnumerator of a value that doesn't implement the IEnumerable interface.\nValue: {0}\nValue's type: {1}", value, value.GetType().FullName));
}
while (enumerator.MoveNext())
{
object item = enumerator.Current;
target.Add(this.CoerceType(elementType, item));
}
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
return(target.ToArray(elementType));
}
protected internal virtual void WriteArray(IEnumerable value)
{
bool appendDelim = false;
this.Writer.Write(JsonReader.OperatorArrayStart);
this.depth++;
if (this.depth > this.settings.MaxDepth)
{
throw new JsonSerializationException(String.Format(JsonWriter.ErrorMaxDepth, this.settings.MaxDepth));
}
try
{
var enumerator = TypeCoercionUtility.GetEnumerator(value);
if (enumerator == null)
{
throw new JsonTypeCoercionException(string.Format("Requested to get an IEnumerator of a value that doesn't implement the IEnumerable interface.\nValue: {0}\nValue's type: {1}", value, value.GetType().FullName));
}
while (enumerator.MoveNext())
{
object item = enumerator.Current;
if (appendDelim)
{
this.WriteArrayItemDelim();
}
else
{
appendDelim = true;
}
this.WriteLine();
this.WriteArrayItem(item);
}
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
finally
{
this.depth--;
}
if (appendDelim)
{
this.WriteLine();
}
this.Writer.Write(JsonReader.OperatorArrayEnd);
}
private object CoerceList(Type targetType, Type arrayType, IEnumerable value)
{
if (targetType.IsArray)
{
return(this.CoerceArray(targetType.GetElementType(), value));
}
// targetType serializes as a JSON array but is not an array
// assume is an ICollection / IEnumerable with AddRange, Add,
// or custom Constructor with which we can populate it
// many ICollection types take an IEnumerable or ICollection
// as a constructor argument. look through constructors for
// a compatible match.
ConstructorInfo[] ctors = targetType.GetConstructors();
ConstructorInfo defaultCtor = null;
foreach (ConstructorInfo ctor in ctors)
{
ParameterInfo[] paramList = ctor.GetParameters();
if (paramList.Length == 0)
{
// save for in case cannot find closer match
defaultCtor = ctor;
continue;
}
if (paramList.Length == 1 &&
paramList[0].ParameterType.IsAssignableFrom(arrayType))
{
try
{
// invoke first constructor that can take this value as an argument
return(ctor.Invoke(
new object[] { value }
));
}
catch
{
// there might exist a better match
continue;
}
}
}
if (defaultCtor == null)
{
throw new JsonTypeCoercionException(
String.Format(TypeCoercionUtility.ErrorDefaultCtor, targetType.FullName));
}
object collection;
try
{
// always try-catch Invoke() to expose real exception
collection = defaultCtor.Invoke(null);
}
catch (TargetInvocationException ex)
{
if (ex.InnerException != null)
{
throw new JsonTypeCoercionException(ex.InnerException.Message, ex.InnerException);
}
throw new JsonTypeCoercionException("Error instantiating " + targetType.FullName, ex);
}
// many ICollection types have an AddRange method
// which adds all items at once
MethodInfo method = targetType.GetMethod("AddRange");
ParameterInfo[] parameters = (method == null) ?
null : method.GetParameters();
Type paramType = (parameters == null || parameters.Length != 1) ?
null : parameters[0].ParameterType;
if (paramType != null &&
paramType.IsAssignableFrom(arrayType))
{
try
{
// always try-catch Invoke() to expose real exception
// add all members in one method
method.Invoke(
collection,
new object[] { value });
}
catch (TargetInvocationException ex)
{
if (ex.InnerException != null)
{
throw new JsonTypeCoercionException(ex.InnerException.Message, ex.InnerException);
}
throw new JsonTypeCoercionException("Error calling AddRange on " + targetType.FullName, ex);
}
return(collection);
}
else
{
// many ICollection types have an Add method
// which adds items one at a time
method = targetType.GetMethod("Add");
parameters = (method == null) ?
null : method.GetParameters();
paramType = (parameters == null || parameters.Length != 1) ?
null : parameters[0].ParameterType;
if (paramType != null)
{
var enumerator = TypeCoercionUtility.GetEnumerator(value);
if (enumerator == null)
{
throw new JsonTypeCoercionException(string.Format("Requested to get an IEnumerator of a value that doesn't implement the IEnumerable interface.\nValue: {0}\nValue's type: {1}", value, value.GetType().FullName));
}
while (enumerator.MoveNext())
{
// loop through adding items to collection
object item = enumerator.Current;
try
{
// always try-catch Invoke() to expose real exception
method.Invoke(
collection,
new object[] {
this.CoerceType(paramType, item)
});
}
catch (TargetInvocationException ex)
{
if (ex.InnerException != null)
{
throw new JsonTypeCoercionException(ex.InnerException.Message, ex.InnerException);
}
throw new JsonTypeCoercionException("Error calling Add on " + targetType.FullName, ex);
}
}
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
return(collection);
}
}
try
{
// fall back to basics
return(Convert.ChangeType(value, targetType));
}
catch (Exception ex)
{
throw new JsonTypeCoercionException(String.Format("Error converting {0} to {1}", value.GetType().FullName, targetType.FullName), ex);
}
}