GetEnumerator() 정적인 개인적인 메소드

Gets the IEnumerator interface of the object.
static private GetEnumerator ( object enumerable ) : IEnumerator
enumerable object Enumerable. It must be disposed by the caller.
리턴 IEnumerator
예제 #1
0
        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));
        }
예제 #2
0
        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);
        }
예제 #3
0
        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);
            }
        }