Code Coverage Statistics for Source File

Newtonsoft.Json\Utilities\ReflectionUtils.cs

Symbol Coverage: 76.99% (271 of 352)

Branch Coverage: 75.81% (141 of 186)

Cyclomatic Complexity Avg: 2.71 Max:9

Code Lines: 335

Symbol Coverage Trend

View:


#region License
// Copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
#endregion

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Collections;
using System.Linq;
using System.Globalization;
using System.Runtime.Serialization.Formatters;

namespace Newtonsoft.Json.Utilities
{
  internal static class ReflectionUtils
  {
    public static Type GetObjectType(object v)
    {
      return (v != null) ? v.GetType() : null;
    }

    public static string GetTypeName(Type t, FormatterAssemblyStyle assemblyFormat)
    {
      switch (assemblyFormat)
      {
        case FormatterAssemblyStyle.Simple:
          return t.FullName + ", " + t.Assembly.GetName().Name;
        case FormatterAssemblyStyle.Full:
          return t.AssemblyQualifiedName;
        default:
          throw new ArgumentOutOfRangeException();
      }
    }

    public static bool IsInstantiatableType(Type t)
    {
      ValidationUtils.ArgumentNotNull(t, "t");

      if (t.IsAbstract || t.IsInterface || t.IsArray || t.IsGenericTypeDefinition || t == typeof(void))
        return false;

      if (!HasDefaultConstructor(t))
        return false;

      return true;
    }

    public static bool HasDefaultConstructor(Type t)
    {
      return HasDefaultConstructor(t, false);
    }

    public static bool HasDefaultConstructor(Type t, bool nonPublic)
    {
      ValidationUtils.ArgumentNotNull(t, "t");

      if (t.IsValueType)
        return true;

      return (GetDefaultConstructor(t, nonPublic) != null);
    }

    public static ConstructorInfo GetDefaultConstructor(Type t)
    {
      return GetDefaultConstructor(t, false);
    }

    public static ConstructorInfo GetDefaultConstructor(Type t, bool nonPublic)
    {
      BindingFlags accessModifier = BindingFlags.Public;
      
      if (nonPublic)
        accessModifier = accessModifier | BindingFlags.NonPublic;

      return t.GetConstructor(accessModifier | BindingFlags.Instance, null, new Type[0], null);
    }

    public static bool IsNullable(Type t)
    {
      ValidationUtils.ArgumentNotNull(t, "t");

      if (t.IsValueType)
        return IsNullableType(t);

      return true;
    }

    public static bool IsNullableType(Type t)
    {
      ValidationUtils.ArgumentNotNull(t, "t");

      return (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>));
    }

    //public static bool IsValueTypeUnitializedValue(ValueType value)
    //{
    //  if (value == null)
    //    return true;

    //  return value.Equals(CreateUnitializedValue(value.GetType()));
    //}

    public static bool IsUnitializedValue(object value)
    {
      if (value == null)
      {
        return true;
      }
      else
      {
        object unitializedValue = CreateUnitializedValue(value.GetType());
        return value.Equals(unitializedValue);
      }
    }

    public static object CreateUnitializedValue(Type type)
    {
      ValidationUtils.ArgumentNotNull(type, "type");

      if (type.IsGenericTypeDefinition)
        throw new ArgumentException("Type {0} is a generic type definition and cannot be instantiated.".FormatWith(CultureInfo.InvariantCulture, type), "type");

      if (type.IsClass || type.IsInterface || type == typeof(void))
        return null;
      else if (type.IsValueType)
        return Activator.CreateInstance(type);
      else
        throw new ArgumentException("Type {0} cannot be instantiated.".FormatWith(CultureInfo.InvariantCulture, type), "type");
    }

    public static bool IsPropertyIndexed(PropertyInfo property)
    {
      ValidationUtils.ArgumentNotNull(property, "property");

      return !CollectionUtils.IsNullOrEmpty<ParameterInfo>(property.GetIndexParameters());
    }

    public static bool ImplementsGenericDefinition(Type type, Type genericInterfaceDefinition)
    {
      Type implementingType;
      return ImplementsGenericDefinition(type, genericInterfaceDefinition, out implementingType);
    }

    public static bool ImplementsGenericDefinition(Type type, Type genericInterfaceDefinition, out Type implementingType)
    {
      ValidationUtils.ArgumentNotNull(type, "type");
      ValidationUtils.ArgumentNotNull(genericInterfaceDefinition, "genericInterfaceDefinition");

      if (!genericInterfaceDefinition.IsInterface || !genericInterfaceDefinition.IsGenericTypeDefinition)
        throw new ArgumentNullException("'{0}' is not a generic interface definition.".FormatWith(CultureInfo.InvariantCulture, genericInterfaceDefinition));

      if (type.IsInterface)
      {
        if (type.IsGenericType)
        {
          Type interfaceDefinition = type.GetGenericTypeDefinition();

          if (genericInterfaceDefinition == interfaceDefinition)
          {
            implementingType = type;
            return true;
          }
        }
      }

      foreach (Type i in type.GetInterfaces())
      {
        if (i.IsGenericType)
        {
          Type interfaceDefinition = i.GetGenericTypeDefinition();

          if (genericInterfaceDefinition == interfaceDefinition)
          {
            implementingType = i;
            return true;
          }
        }
      }

      implementingType = null;
      return false;
    }

    public static bool AssignableToTypeName(this Type type, string fullTypeName, out Type match)
    {
      Type current = type;

      while (current != null)
      {
        if (string.Equals(current.FullName, fullTypeName, StringComparison.Ordinal))
        {
          match = current;
          return true;
        }

        current = current.BaseType;
      }

      foreach (Type i in type.GetInterfaces())
      {
        if (string.Equals(i.Name, fullTypeName, StringComparison.Ordinal))
        {
          match = type;
          return true;
        }
      }

      match = null;
      return false;
    }

    public static bool AssignableToTypeName(this Type type, string fullTypeName)
    {
      Type match;
      return type.AssignableToTypeName(fullTypeName, out match);
    }

    public static bool InheritsGenericDefinition(Type type, Type genericClassDefinition)
    {
      Type implementingType;
      return InheritsGenericDefinition(type, genericClassDefinition, out implementingType);
    }

    public static bool InheritsGenericDefinition(Type type, Type genericClassDefinition, out Type implementingType)
    {
      ValidationUtils.ArgumentNotNull(type, "type");
      ValidationUtils.ArgumentNotNull(genericClassDefinition, "genericClassDefinition");

      if (!genericClassDefinition.IsClass || !genericClassDefinition.IsGenericTypeDefinition)
        throw new ArgumentNullException("'{0}' is not a generic class definition.".FormatWith(CultureInfo.InvariantCulture, genericClassDefinition));

      return InheritsGenericDefinitionInternal(type, genericClassDefinition, out implementingType);
    }

    private static bool InheritsGenericDefinitionInternal(Type currentType, Type genericClassDefinition, out Type implementingType)
    {
      if (currentType.IsGenericType)
      {
        Type currentGenericClassDefinition = currentType.GetGenericTypeDefinition();

        if (genericClassDefinition == currentGenericClassDefinition)
        {
          implementingType = currentType;
          return true;
        }
      }

      if (currentType.BaseType == null)
      {
        implementingType = null;
        return false;
      }

      return InheritsGenericDefinitionInternal(currentType.BaseType, genericClassDefinition, out implementingType);
    }

    /// <summary>
    /// Gets the type of the typed collection's items.
    /// </summary>
    /// <param name="type">The type.</param>
    /// <returns>The type of the typed collection's items.</returns>
    public static Type GetCollectionItemType(Type type)
    {
      ValidationUtils.ArgumentNotNull(type, "type");
      Type genericListType;

      if (type.IsArray)
      {
        return type.GetElementType();
      }
      else if (ImplementsGenericDefinition(type, typeof(IEnumerable<>), out genericListType))
      {
        if (genericListType.IsGenericTypeDefinition)
          throw new Exception("Type {0} is not a collection.".FormatWith(CultureInfo.InvariantCulture, type));

        return genericListType.GetGenericArguments()[0];
      }
      else if (typeof(IEnumerable).IsAssignableFrom(type))
      {
        return null;
      }
      else
      {
        throw new Exception("Type {0} is not a collection.".FormatWith(CultureInfo.InvariantCulture, type));
      }
    }

    public static void GetDictionaryKeyValueTypes(Type dictionaryType, out Type keyType, out Type valueType)
    {
      ValidationUtils.ArgumentNotNull(dictionaryType, "type");

      Type genericDictionaryType;
      if (ImplementsGenericDefinition(dictionaryType, typeof(IDictionary<,>), out genericDictionaryType))
      {
        if (genericDictionaryType.IsGenericTypeDefinition)
          throw new Exception("Type {0} is not a dictionary.".FormatWith(CultureInfo.InvariantCulture, dictionaryType));

        Type[] dictionaryGenericArguments = genericDictionaryType.GetGenericArguments();

        keyType = dictionaryGenericArguments[0];
        valueType = dictionaryGenericArguments[1];
        return;
      }
      else if (typeof(IDictionary).IsAssignableFrom(dictionaryType))
      {
        keyType = null;
        valueType = null;
        return;
      }
      else
      {
        throw new Exception("Type {0} is not a dictionary.".FormatWith(CultureInfo.InvariantCulture, dictionaryType));
      }
    }

    public static Type GetDictionaryValueType(Type dictionaryType)
    {
      Type keyType;
      Type valueType;
      GetDictionaryKeyValueTypes(dictionaryType, out keyType, out valueType);

      return valueType;
    }

    public static Type GetDictionaryKeyType(Type dictionaryType)
    {
      Type keyType;
      Type valueType;
      GetDictionaryKeyValueTypes(dictionaryType, out keyType, out valueType);

      return keyType;
    }

    /// <summary>
    /// Tests whether the list's items are their unitialized value.
    /// </summary>
    /// <param name="list">The list.</param>
    /// <returns>Whether the list's items are their unitialized value</returns>
    public static bool ItemsUnitializedValue<T>(IList<T> list)
    {
      ValidationUtils.ArgumentNotNull(list, "list");

      Type elementType = GetCollectionItemType(list.GetType());

      if (elementType.IsValueType)
      {
        object unitializedValue = CreateUnitializedValue(elementType);

        for (int i = 0; i < list.Count; i++)
        {
          if (!list[i].Equals(unitializedValue))
            return false;
        }
      }
      else if (elementType.IsClass)
      {
        for (int i = 0; i < list.Count; i++)
        {
          object value = list[i];

          if (value != null)
            return false;
        }
      }
      else
      {
        throw new Exception("Type {0} is neither a ValueType or a Class.".FormatWith(CultureInfo.InvariantCulture, elementType));
      }

      return true;
    }

    /// <summary>
    /// Gets the member's underlying type.
    /// </summary>
    /// <param name="member">The member.</param>
    /// <returns>The underlying type of the member.</returns>
    public static Type GetMemberUnderlyingType(MemberInfo member)
    {
      ValidationUtils.ArgumentNotNull(member, "member");

      switch (member.MemberType)
      {
        case MemberTypes.Field:
          return ((FieldInfo)member).FieldType;
        case MemberTypes.Property:
          return ((PropertyInfo)member).PropertyType;
        case MemberTypes.Event:
          return ((EventInfo)member).EventHandlerType;
        default:
          throw new ArgumentException("MemberInfo must be of type FieldInfo, PropertyInfo or EventInfo", "member");
      }
    }

    /// <summary>
    /// Determines whether the member is an indexed property.
    /// </summary>
    /// <param name="member">The member.</param>
    /// <returns>
    /// 	<c>true</c> if the member is an indexed property; otherwise, <c>false</c>.
    /// </returns>
    public static bool IsIndexedProperty(MemberInfo member)
    {
      ValidationUtils.ArgumentNotNull(member, "member");

      PropertyInfo propertyInfo = member as PropertyInfo;

      if (propertyInfo != null)
        return IsIndexedProperty(propertyInfo);
      else
        return false;
    }

    /// <summary>
    /// Determines whether the property is an indexed property.
    /// </summary>
    /// <param name="property">The property.</param>
    /// <returns>
    /// 	<c>true</c> if the property is an indexed property; otherwise, <c>false</c>.
    /// </returns>
    public static bool IsIndexedProperty(PropertyInfo property)
    {
      ValidationUtils.ArgumentNotNull(property, "property");

      return (property.GetIndexParameters().Length > 0);
    }

    /// <summary>
    /// Gets the member's value on the object.
    /// </summary>
    /// <param name="member">The member.</param>
    /// <param name="target">The target object.</param>
    /// <returns>The member's value on the object.</returns>
    public static object GetMemberValue(MemberInfo member, object target)
    {
      ValidationUtils.ArgumentNotNull(member, "member");
      ValidationUtils.ArgumentNotNull(target, "target");

      switch (member.MemberType)
      {
        case MemberTypes.Field:
          return ((FieldInfo)member).GetValue(target);
        case MemberTypes.Property:
          try
          {
            return ((PropertyInfo)member).GetValue(target, null);
          }
          catch (TargetParameterCountException e)
          {
            throw new ArgumentException("MemberInfo '{0}' has index parameters".FormatWith(CultureInfo.InvariantCulture, member.Name), e);
          }
        default:
          throw new ArgumentException("MemberInfo '{0}' is not of type FieldInfo or PropertyInfo".FormatWith(CultureInfo.InvariantCulture, CultureInfo.InvariantCulture, member.Name), "member");
      }
    }

    /// <summary>
    /// Sets the member's value on the target object.
    /// </summary>
    /// <param name="member">The member.</param>
    /// <param name="target">The target.</param>
    /// <param name="value">The value.</param>
    public static void SetMemberValue(MemberInfo member, object target, object value)
    {
      ValidationUtils.ArgumentNotNull(member, "member");
      ValidationUtils.ArgumentNotNull(target, "target");

      switch (member.MemberType)
      {
        case MemberTypes.Field:
          ((FieldInfo)member).SetValue(target, value);
          break;
        case MemberTypes.Property:
          ((PropertyInfo)member).SetValue(target, value, null);
          break;
        default:
          throw new ArgumentException("MemberInfo '{0}' must be of type FieldInfo or PropertyInfo".FormatWith(CultureInfo.InvariantCulture, member.Name), "member");
      }
    }

    /// <summary>
    /// Determines whether the specified MemberInfo can be read.
    /// </summary>
    /// <param name="member">The MemberInfo to determine whether can be read.</param>
    /// /// <param name="nonPublic">if set to <c>true</c> then allow the member to be gotten non-publicly.</param>
    /// <returns>
    /// 	<c>true</c> if the specified MemberInfo can be read; otherwise, <c>false</c>.
    /// </returns>
    public static bool CanReadMemberValue(MemberInfo member, bool nonPublic)
    {
      switch (member.MemberType)
      {
        case MemberTypes.Field:
          FieldInfo fieldInfo = (FieldInfo)member;

          if (nonPublic)
            return true;
          else if (fieldInfo.IsPublic)
            return true;
          return false;
        case MemberTypes.Property:
          PropertyInfo propertyInfo = (PropertyInfo) member;

          if (!propertyInfo.CanRead)
            return false;
          if (nonPublic)
            return true;
          return (propertyInfo.GetGetMethod(nonPublic) != null);
        default:
          return false;
      }
    }

    /// <summary>
    /// Determines whether the specified MemberInfo can be set.
    /// </summary>
    /// <param name="member">The MemberInfo to determine whether can be set.</param>
    /// <param name="nonPublic">if set to <c>true</c> then allow the member to be set non-publicly.</param>
    /// <returns>
    /// 	<c>true</c> if the specified MemberInfo can be set; otherwise, <c>false</c>.
    /// </returns>
    public static bool CanSetMemberValue(MemberInfo member, bool nonPublic)
    {
      switch (member.MemberType)
      {
        case MemberTypes.Field:
          FieldInfo fieldInfo = (FieldInfo)member;

          if (fieldInfo.IsInitOnly)
            return false;
          if (nonPublic)
            return true;
          else if (fieldInfo.IsPublic)
            return true;
          return false;
        case MemberTypes.Property:
          PropertyInfo propertyInfo = (PropertyInfo)member;

          if (!propertyInfo.CanWrite)
            return false;
          if (nonPublic)
            return true;
          return (propertyInfo.GetSetMethod(nonPublic) != null);
        default:
          return false;
      }
    }

    public static List<MemberInfo> GetFieldsAndProperties<T>(BindingFlags bindingAttr)
    {
      return GetFieldsAndProperties(typeof(T), bindingAttr);
    }

    public static List<MemberInfo> GetFieldsAndProperties(Type type, BindingFlags bindingAttr)
    {
      List<MemberInfo> targetMembers = new List<MemberInfo>();

      targetMembers.AddRange(GetFields(type, bindingAttr));
      targetMembers.AddRange(GetProperties(type, bindingAttr));

      // for some reason .NET returns multiple members when overriding a generic member on a base class
      // http://forums.msdn.microsoft.com/en-US/netfxbcl/thread/b5abbfee-e292-4a64-8907-4e3f0fb90cd9/
      // filter members to only return the override on the topmost class
      // update: I think this is fixed in .NET 3.5 SP1 - leave this in for now...
      List<MemberInfo> distinctMembers = new List<MemberInfo>(targetMembers.Count);

      var groupedMembers = targetMembers.GroupBy(m => m.Name).Select(g => new { Count = g.Count(), Members = g.Cast<MemberInfo>() });
      foreach (var groupedMember in groupedMembers)
      {
        if (groupedMember.Count == 1)
        {
          distinctMembers.Add(groupedMember.Members.First());
        }
        else
        {
          var members = groupedMember.Members.Where(m => !IsOverridenGenericMember(m, bindingAttr) || m.Name == "Item");

          distinctMembers.AddRange(members);
        }
      }

      return distinctMembers;
    }

    private static bool IsOverridenGenericMember(MemberInfo memberInfo, BindingFlags bindingAttr)
    {
      if (memberInfo.MemberType != MemberTypes.Field && memberInfo.MemberType != MemberTypes.Property)
        throw new ArgumentException("Member must be a field or property.");

      Type declaringType = memberInfo.DeclaringType;
      if (!declaringType.IsGenericType)
        return false;
      Type genericTypeDefinition = declaringType.GetGenericTypeDefinition();
      if (genericTypeDefinition == null)
        return false;
      MemberInfo[] members = genericTypeDefinition.GetMember(memberInfo.Name, bindingAttr);
      if (members.Length == 0)
        return false;
      Type memberUnderlyingType = GetMemberUnderlyingType(members[0]);
      if (!memberUnderlyingType.IsGenericParameter)
        return false;

      return true;
    }

    public static T GetAttribute<T>(ICustomAttributeProvider attributeProvider) where T : Attribute
    {
      return GetAttribute<T>(attributeProvider, true);
    }

    public static T GetAttribute<T>(ICustomAttributeProvider attributeProvider, bool inherit) where T : Attribute
    {
      T[] attributes = GetAttributes<T>(attributeProvider, inherit);

      return CollectionUtils.GetSingleItem(attributes, true);
    }

    public static T[] GetAttributes<T>(ICustomAttributeProvider attributeProvider, bool inherit) where T : Attribute
    {
      ValidationUtils.ArgumentNotNull(attributeProvider, "attributeProvider");

      return (T[])attributeProvider.GetCustomAttributes(typeof(T), inherit);
    }

    public static string GetNameAndAssessmblyName(Type t)
    {
      ValidationUtils.ArgumentNotNull(t, "t");

      return t.FullName + ", " + t.Assembly.GetName().Name;
    }

    public static Type MakeGenericType(Type genericTypeDefinition, params Type[] innerTypes)
    {
      ValidationUtils.ArgumentNotNull(genericTypeDefinition, "genericTypeDefinition");
      ValidationUtils.ArgumentNotNullOrEmpty<Type>(innerTypes, "innerTypes");
      ValidationUtils.ArgumentConditionTrue(genericTypeDefinition.IsGenericTypeDefinition, "genericTypeDefinition", "Type {0} is not a generic type definition.".FormatWith(CultureInfo.InvariantCulture, genericTypeDefinition));

      return genericTypeDefinition.MakeGenericType(innerTypes);
    }

    public static object CreateGeneric(Type genericTypeDefinition, Type innerType, params object[] args)
    {
      return CreateGeneric(genericTypeDefinition, new [] { innerType }, args);
    }

    public static object CreateGeneric(Type genericTypeDefinition, IList<Type> innerTypes, params object[] args)
    {
      return CreateGeneric(genericTypeDefinition, innerTypes, (t, a) => CreateInstance(t, a.ToArray()), args);
    }

    public static object CreateGeneric(Type genericTypeDefinition, IList<Type> innerTypes, Func<Type, IList<object>, object> instanceCreator, params object[] args)
    {
      ValidationUtils.ArgumentNotNull(genericTypeDefinition, "genericTypeDefinition");
      ValidationUtils.ArgumentNotNullOrEmpty(innerTypes, "innerTypes");
      ValidationUtils.ArgumentNotNull(instanceCreator, "createInstance");

      Type specificType = MakeGenericType(genericTypeDefinition, innerTypes.ToArray());

      return instanceCreator(specificType, args);
    }

    public static bool IsCompatibleValue(object value, Type type)
    {
      if (value == null)
        return IsNullable(type);

      if (type.IsAssignableFrom(value.GetType()))
        return true;

      return false;
    }

     public static object CreateInstance(Type type, params object[] args)
     {
       ValidationUtils.ArgumentNotNull(type, "type");

#if !PocketPC
       return Activator.CreateInstance(type, args);
#else
       // CF doesn't have a Activator.CreateInstance overload that takes args
       // lame

       if (type.IsValueType && CollectionUtils.IsNullOrEmpty<object>(args))
         return Activator.CreateInstance(type);

       ConstructorInfo[] constructors = type.GetConstructors();
       ConstructorInfo match = constructors.Where(c =>
         {
           ParameterInfo[] parameters = c.GetParameters();
           if (parameters.Length != args.Length)
             return false;

           for (int i = 0; i < parameters.Length; i++)
           {
             ParameterInfo parameter = parameters[i];
             object value = args[i];

             if (!IsCompatibleValue(value, parameter.ParameterType))
               return false;
           }

           return true;
         }).FirstOrDefault();

       if (match == null)
         throw new Exception("Could not create '{0}' with given parameters.".FormatWith(CultureInfo.InvariantCulture, type));

       return match.Invoke(args);
#endif
     }

    public static void SplitFullyQualifiedTypeName(string fullyQualifiedTypeName, out string typeName, out string assemblyName)
    {
      int? assemblyDelimiterIndex = GetAssemblyDelimiterIndex(fullyQualifiedTypeName);

      if (assemblyDelimiterIndex != null)
      {
        typeName = fullyQualifiedTypeName.Substring(0, assemblyDelimiterIndex.Value).Trim();
        assemblyName = fullyQualifiedTypeName.Substring(assemblyDelimiterIndex.Value + 1, fullyQualifiedTypeName.Length - assemblyDelimiterIndex.Value - 1).Trim();
      }
      else
      {
        typeName = fullyQualifiedTypeName;
        assemblyName = null;
      }

    }

    private static int? GetAssemblyDelimiterIndex(string fullyQualifiedTypeName)
    {
      // we need to get the first comma following all surrounded in brackets because of generic types
      // e.g. System.Collections.Generic.Dictionary`2[[System.String, mscorlib,Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
      int scope = 0;
      for (int i = 0; i < fullyQualifiedTypeName.Length; i++)
      {
        char current = fullyQualifiedTypeName[i];
        switch (current)
        {
          case '[':
            scope++;
            break;
          case ']':
            scope--;
            break;
          case ',':
            if (scope == 0)
              return i;
            break;
        }
      }

      return null;
    }

    public static IEnumerable<FieldInfo> GetFields(Type targetType, BindingFlags bindingAttr)
    {
      ValidationUtils.ArgumentNotNull(targetType, "targetType");

      List<MemberInfo> fieldInfos = new List<MemberInfo>(targetType.GetFields(bindingAttr));
      // Type.GetFields doesn't return inherited private fields
      // manually find private fields from base class
      GetChildPrivateFields(fieldInfos, targetType, bindingAttr);

      return fieldInfos.Cast<FieldInfo>();
    }

    private static void GetChildPrivateFields(IList<MemberInfo> initialFields, Type targetType, BindingFlags bindingAttr)
    {
      // fix weirdness with private FieldInfos only being returned for the current Type
      // find base type fields and add them to result
      if ((bindingAttr & BindingFlags.NonPublic) != 0)
      {
        // modify flags to not search for public fields
        BindingFlags nonPublicBindingAttr = bindingAttr.RemoveFlag(BindingFlags.Public);

        while ((targetType = targetType.BaseType) != null)
        {
          // filter out protected fields
          IEnumerable<MemberInfo> childPrivateFields =
            targetType.GetFields(nonPublicBindingAttr).Where(f => f.IsPrivate).Cast<MemberInfo>();

          initialFields.AddRange(childPrivateFields);
        }
      }
    }

    public static IEnumerable<PropertyInfo> GetProperties(Type targetType, BindingFlags bindingAttr)
    {
      ValidationUtils.ArgumentNotNull(targetType, "targetType");

      List<MemberInfo> propertyInfos = new List<MemberInfo>(targetType.GetProperties(bindingAttr));
      GetChildPrivateProperties(propertyInfos, targetType, bindingAttr);

      return propertyInfos.Cast<PropertyInfo>();
    }

    public static BindingFlags RemoveFlag(this BindingFlags bindingAttr, BindingFlags flag)
    {
      return ((bindingAttr & flag) == flag)
        ? bindingAttr ^ flag
        : bindingAttr;
    }

    private static void GetChildPrivateProperties(IList<MemberInfo> initialProperties, Type targetType, BindingFlags bindingAttr)
    {
      // fix weirdness with private PropertyInfos only being returned for the current Type
      // find base type properties and add them to result
      if ((bindingAttr & BindingFlags.NonPublic) != 0)
      {
        // modify flags to not search for public fields
        BindingFlags nonPublicBindingAttr = bindingAttr.RemoveFlag(BindingFlags.Public);

        while ((targetType = targetType.BaseType) != null)
        {
          foreach (PropertyInfo propertyInfo in targetType.GetProperties(nonPublicBindingAttr))
          {
            PropertyInfo nonPublicProperty = propertyInfo;

            // have to test on name rather than reference because instances are different
            // depending on the type that GetProperties was called on
            int index = initialProperties.IndexOf(p => p.Name == nonPublicProperty.Name);
            if (index == -1)
            {
              initialProperties.Add(nonPublicProperty);
            }
            else
            {
              // replace nonpublic properties for a child, but gotten from
              // the parent with the one from the child
              // the property gotten from the child will have access to private getter/setter
              initialProperties[index] = nonPublicProperty;
            }
          }
        }
      }
    }
  }
}

L	V	Source
1		#region License
2		// Copyright (c) 2007 James Newton-King
3		//
4		// Permission is hereby granted, free of charge, to any person
5		// obtaining a copy of this software and associated documentation
6		// files (the "Software"), to deal in the Software without
7		// restriction, including without limitation the rights to use,
8		// copy, modify, merge, publish, distribute, sublicense, and/or sell
9		// copies of the Software, and to permit persons to whom the
10		// Software is furnished to do so, subject to the following
11		// conditions:
12		//
13		// The above copyright notice and this permission notice shall be
14		// included in all copies or substantial portions of the Software.
15		//
16		// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17		// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
18		// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19		// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
20		// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21		// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22		// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23		// OTHER DEALINGS IN THE SOFTWARE.
24		#endregion
25
26		using System;
27		using System.Collections.Generic;
28		using System.Reflection;
29		using System.Collections;
30		using System.Linq;
31		using System.Globalization;
32		using System.Runtime.Serialization.Formatters;
33
34		namespace Newtonsoft.Json.Utilities
35		{
36		internal static class ReflectionUtils
37		{
38		public static Type GetObjectType(object v)
39		{
40	210719	return (v != null) ? v.GetType() : null;
41	210719	}
42
43		public static string GetTypeName(Type t, FormatterAssemblyStyle assemblyFormat)
44		{
45	16	switch (assemblyFormat)
46		{
47		case FormatterAssemblyStyle.Simple:
48	10	return t.FullName + ", " + t.Assembly.GetName().Name;
49		case FormatterAssemblyStyle.Full:
50	6	return t.AssemblyQualifiedName;
51		default:
52	0	throw new ArgumentOutOfRangeException();
53		}
54	16	}
55
56		public static bool IsInstantiatableType(Type t)
57		{
58	20051	ValidationUtils.ArgumentNotNull(t, "t");
59
60	20051	if (t.IsAbstract \|\| t.IsInterface \|\| t.IsArray \|\| t.IsGenericTypeDefinition \|\| t == typeof(void))
61	0	return false;
62
63	20051	if (!HasDefaultConstructor(t))
64	0	return false;
65
66	20051	return true;
67	20051	}
68
69		public static bool HasDefaultConstructor(Type t)
70		{
71	20051	return HasDefaultConstructor(t, false);
72	20051	}
73
74		public static bool HasDefaultConstructor(Type t, bool nonPublic)
75		{
76	20360	ValidationUtils.ArgumentNotNull(t, "t");
77
78	20360	if (t.IsValueType)
79	46	return true;
80
81	20314	return (GetDefaultConstructor(t, nonPublic) != null);
82	20360	}
83
84		public static ConstructorInfo GetDefaultConstructor(Type t)
85		{
86	209	return GetDefaultConstructor(t, false);
87	209	}
88
89		public static ConstructorInfo GetDefaultConstructor(Type t, bool nonPublic)
90		{
91	20523	BindingFlags accessModifier = BindingFlags.Public;
92
93	20523	if (nonPublic)
94	263	accessModifier = accessModifier \| BindingFlags.NonPublic;
95
96	20523	return t.GetConstructor(accessModifier \| BindingFlags.Instance, null, new Type[0], null);
97	20523	}
98
99		public static bool IsNullable(Type t)
100		{
101	20276	ValidationUtils.ArgumentNotNull(t, "t");
102
103	20276	if (t.IsValueType)
104	116	return IsNullableType(t);
105
106	20160	return true;
107	20276	}
108
109		public static bool IsNullableType(Type t)
110		{
111	40922	ValidationUtils.ArgumentNotNull(t, "t");
112
113	40922	return (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>));
114	40922	}
115
116		//public static bool IsValueTypeUnitializedValue(ValueType value)
117		//{
118		// if (value == null)
119		// return true;
120
121		// return value.Equals(CreateUnitializedValue(value.GetType()));
122		//}
123
124		public static bool IsUnitializedValue(object value)
125		{
126	0	if (value == null)
127		{
128	0	return true;
129		}
130		else
131		{
132	0	object unitializedValue = CreateUnitializedValue(value.GetType());
133	0	return value.Equals(unitializedValue);
134		}
135	0	}
136
137		public static object CreateUnitializedValue(Type type)
138		{
139	0	ValidationUtils.ArgumentNotNull(type, "type");
140
141	0	if (type.IsGenericTypeDefinition)
142	0	throw new ArgumentException("Type {0} is a generic type definition and cannot be instantiated.".FormatWith(CultureInfo.InvariantCulture, type), "type");
143
144	0	if (type.IsClass \|\| type.IsInterface \|\| type == typeof(void))
145	0	return null;
146	0	else if (type.IsValueType)
147	0	return Activator.CreateInstance(type);
148		else
149	0	throw new ArgumentException("Type {0} cannot be instantiated.".FormatWith(CultureInfo.InvariantCulture, type), "type");
150	0	}
151
152		public static bool IsPropertyIndexed(PropertyInfo property)
153		{
154	0	ValidationUtils.ArgumentNotNull(property, "property");
155
156	0	return !CollectionUtils.IsNullOrEmpty<ParameterInfo>(property.GetIndexParameters());
157	0	}
158
159		public static bool ImplementsGenericDefinition(Type type, Type genericInterfaceDefinition)
160		{
161		Type implementingType;
162	235	return ImplementsGenericDefinition(type, genericInterfaceDefinition, out implementingType);
163	235	}
164
165		public static bool ImplementsGenericDefinition(Type type, Type genericInterfaceDefinition, out Type implementingType)
166		{
167	348	ValidationUtils.ArgumentNotNull(type, "type");
168	348	ValidationUtils.ArgumentNotNull(genericInterfaceDefinition, "genericInterfaceDefinition");
169
170	348	if (!genericInterfaceDefinition.IsInterface \|\| !genericInterfaceDefinition.IsGenericTypeDefinition)
171	0	throw new ArgumentNullException("'{0}' is not a generic interface definition.".FormatWith(CultureInfo.InvariantCulture, genericInterfaceDefinition));
172
173	348	if (type.IsInterface)
174		{
175	16	if (type.IsGenericType)
176		{
177	13	Type interfaceDefinition = type.GetGenericTypeDefinition();
178
179	13	if (genericInterfaceDefinition == interfaceDefinition)
180		{
181	4	implementingType = type;
182	4	return true;
183		}
184		}
185		}
186
187	344	foreach (Type i in type.GetInterfaces())
188		{
189	713	if (i.IsGenericType)
190		{
191	344	Type interfaceDefinition = i.GetGenericTypeDefinition();
192
193	344	if (genericInterfaceDefinition == interfaceDefinition)
194		{
195	94	implementingType = i;
196	94	return true;
197		}
198		}
199		}
200
201	250	implementingType = null;
202	250	return false;
203	348	}
204
205		public static bool AssignableToTypeName(this Type type, string fullTypeName, out Type match)
206		{
207	813	Type current = type;
208
209	2713	while (current != null)
210		{
211	1909	if (string.Equals(current.FullName, fullTypeName, StringComparison.Ordinal))
212		{
213	9	match = current;
214	9	return true;
215		}
216
217	1900	current = current.BaseType;
218		}
219
220	804	foreach (Type i in type.GetInterfaces())
221		{
222	1591	if (string.Equals(i.Name, fullTypeName, StringComparison.Ordinal))
223		{
224	0	match = type;
225	0	return true;
226		}
227		}
228
229	804	match = null;
230	804	return false;
231	813	}
232
233		public static bool AssignableToTypeName(this Type type, string fullTypeName)
234		{
235		Type match;
236	640	return type.AssignableToTypeName(fullTypeName, out match);
237	640	}
238
239		public static bool InheritsGenericDefinition(Type type, Type genericClassDefinition)
240		{
241		Type implementingType;
242	17	return InheritsGenericDefinition(type, genericClassDefinition, out implementingType);
243	17	}
244
245		public static bool InheritsGenericDefinition(Type type, Type genericClassDefinition, out Type implementingType)
246		{
247	20069	ValidationUtils.ArgumentNotNull(type, "type");
248	20069	ValidationUtils.ArgumentNotNull(genericClassDefinition, "genericClassDefinition");
249
250	20069	if (!genericClassDefinition.IsClass \|\| !genericClassDefinition.IsGenericTypeDefinition)
251	0	throw new ArgumentNullException("'{0}' is not a generic class definition.".FormatWith(CultureInfo.InvariantCulture, genericClassDefinition));
252
253	20069	return InheritsGenericDefinitionInternal(type, genericClassDefinition, out implementingType);
254	20069	}
255
256		private static bool InheritsGenericDefinitionInternal(Type currentType, Type genericClassDefinition, out Type implementingType)
257		{
258	40147	if (currentType.IsGenericType)
259		{
260	20067	Type currentGenericClassDefinition = currentType.GetGenericTypeDefinition();
261
262	20067	if (genericClassDefinition == currentGenericClassDefinition)
263		{
264	2	implementingType = currentType;
265	2	return true;
266		}
267		}
268
269	40145	if (currentType.BaseType == null)
270		{
271	20067	implementingType = null;
272	20067	return false;
273		}
274
275	20078	return InheritsGenericDefinitionInternal(currentType.BaseType, genericClassDefinition, out implementingType);
276	40147	}
277
278		/// <summary>
279		/// Gets the type of the typed collection's items.
280		/// </summary>
281		/// <param name="type">The type.</param>
282		/// <returns>The type of the typed collection's items.</returns>
283		public static Type GetCollectionItemType(Type type)
284		{
285	70	ValidationUtils.ArgumentNotNull(type, "type");
286		Type genericListType;
287
288	70	if (type.IsArray)
289		{
290	40	return type.GetElementType();
291		}
292	30	else if (ImplementsGenericDefinition(type, typeof(IEnumerable<>), out genericListType))
293		{
294	23	if (genericListType.IsGenericTypeDefinition)
295	0	throw new Exception("Type {0} is not a collection.".FormatWith(CultureInfo.InvariantCulture, type));
296
297	23	return genericListType.GetGenericArguments()[0];
298		}
299	7	else if (typeof(IEnumerable).IsAssignableFrom(type))
300		{
301	7	return null;
302		}
303		else
304		{
305	0	throw new Exception("Type {0} is not a collection.".FormatWith(CultureInfo.InvariantCulture, type));
306		}
307	70	}
308
309		public static void GetDictionaryKeyValueTypes(Type dictionaryType, out Type keyType, out Type valueType)
310		{
311	4	ValidationUtils.ArgumentNotNull(dictionaryType, "type");
312
313		Type genericDictionaryType;
314	4	if (ImplementsGenericDefinition(dictionaryType, typeof(IDictionary<,>), out genericDictionaryType))
315		{
316	3	if (genericDictionaryType.IsGenericTypeDefinition)
317	0	throw new Exception("Type {0} is not a dictionary.".FormatWith(CultureInfo.InvariantCulture, dictionaryType));
318
319	3	Type[] dictionaryGenericArguments = genericDictionaryType.GetGenericArguments();
320
321	3	keyType = dictionaryGenericArguments[0];
322	3	valueType = dictionaryGenericArguments[1];
323	3	return;
324		}
325	1	else if (typeof(IDictionary).IsAssignableFrom(dictionaryType))
326		{
327	1	keyType = null;
328	1	valueType = null;
329	1	return;
330		}
331		else
332		{
333	0	throw new Exception("Type {0} is not a dictionary.".FormatWith(CultureInfo.InvariantCulture, dictionaryType));
334		}
335	4	}
336
337		public static Type GetDictionaryValueType(Type dictionaryType)
338		{
339		Type keyType;
340		Type valueType;
341	1	GetDictionaryKeyValueTypes(dictionaryType, out keyType, out valueType);
342
343	1	return valueType;
344	1	}
345
346		public static Type GetDictionaryKeyType(Type dictionaryType)
347		{
348		Type keyType;
349		Type valueType;
350	1	GetDictionaryKeyValueTypes(dictionaryType, out keyType, out valueType);
351
352	1	return keyType;
353	1	}
354
355		/// <summary>
356		/// Tests whether the list's items are their unitialized value.
357		/// </summary>
358		/// <param name="list">The list.</param>
359		/// <returns>Whether the list's items are their unitialized value</returns>
360		public static bool ItemsUnitializedValue<T>(IList<T> list)
361		{
362	0	ValidationUtils.ArgumentNotNull(list, "list");
363
364	0	Type elementType = GetCollectionItemType(list.GetType());
365
366	0	if (elementType.IsValueType)
367		{
368	0	object unitializedValue = CreateUnitializedValue(elementType);
369
370	0	for (int i = 0; i < list.Count; i++)
371		{
372	0	if (!list[i].Equals(unitializedValue))
373	0	return false;
374		}
375		}
376	0	else if (elementType.IsClass)
377		{
378	0	for (int i = 0; i < list.Count; i++)
379		{
380	0	object value = list[i];
381
382	0	if (value != null)
383	0	return false;
384		}
385		}
386		else
387		{
388	0	throw new Exception("Type {0} is neither a ValueType or a Class.".FormatWith(CultureInfo.InvariantCulture, elementType));
389		}
390
391	0	return true;
392	0	}
393
394		/// <summary>
395		/// Gets the member's underlying type.
396		/// </summary>
397		/// <param name="member">The member.</param>
398		/// <returns>The underlying type of the member.</returns>
399		public static Type GetMemberUnderlyingType(MemberInfo member)
400		{
401	161795	ValidationUtils.ArgumentNotNull(member, "member");
402
403	161795	switch (member.MemberType)
404		{
405		case MemberTypes.Field:
406	20503	return ((FieldInfo)member).FieldType;
407		case MemberTypes.Property:
408	141292	return ((PropertyInfo)member).PropertyType;
409		case MemberTypes.Event:
410	0	return ((EventInfo)member).EventHandlerType;
411		default:
412	0	throw new ArgumentException("MemberInfo must be of type FieldInfo, PropertyInfo or EventInfo", "member");
413		}
414	161795	}
415
416		/// <summary>
417		/// Determines whether the member is an indexed property.
418		/// </summary>
419		/// <param name="member">The member.</param>
420		/// <returns>
421		/// <c>true</c> if the member is an indexed property; otherwise, <c>false</c>.
422		/// </returns>
423		public static bool IsIndexedProperty(MemberInfo member)
424		{
425	1725	ValidationUtils.ArgumentNotNull(member, "member");
426
427	1725	PropertyInfo propertyInfo = member as PropertyInfo;
428
429	1725	if (propertyInfo != null)
430	972	return IsIndexedProperty(propertyInfo);
431		else
432	753	return false;
433	1725	}
434
435		/// <summary>
436		/// Determines whether the property is an indexed property.
437		/// </summary>
438		/// <param name="property">The property.</param>
439		/// <returns>
440		/// <c>true</c> if the property is an indexed property; otherwise, <c>false</c>.
441		/// </returns>
442		public static bool IsIndexedProperty(PropertyInfo property)
443		{
444	972	ValidationUtils.ArgumentNotNull(property, "property");
445
446	972	return (property.GetIndexParameters().Length > 0);
447	972	}
448
449		/// <summary>
450		/// Gets the member's value on the object.
451		/// </summary>
452		/// <param name="member">The member.</param>
453		/// <param name="target">The target object.</param>
454		/// <returns>The member's value on the object.</returns>
455		public static object GetMemberValue(MemberInfo member, object target)
456		{
457	32	ValidationUtils.ArgumentNotNull(member, "member");
458	32	ValidationUtils.ArgumentNotNull(target, "target");
459
460	32	switch (member.MemberType)
461		{
462		case MemberTypes.Field:
463	7	return ((FieldInfo)member).GetValue(target);
464		case MemberTypes.Property:
465		try
466		{
467	25	return ((PropertyInfo)member).GetValue(target, null);
468		}
469	0	catch (TargetParameterCountException e)
470		{
471	0	throw new ArgumentException("MemberInfo '{0}' has index parameters".FormatWith(CultureInfo.InvariantCulture, member.Name), e);
472		}
473		default:
474	0	throw new ArgumentException("MemberInfo '{0}' is not of type FieldInfo or PropertyInfo".FormatWith(CultureInfo.InvariantCulture, CultureInfo.InvariantCulture, member.Name), "member");
475		}
476	32	}
477
478		/// <summary>
479		/// Sets the member's value on the target object.
480		/// </summary>
481		/// <param name="member">The member.</param>
482		/// <param name="target">The target.</param>
483		/// <param name="value">The value.</param>
484		public static void SetMemberValue(MemberInfo member, object target, object value)
485		{
486	0	ValidationUtils.ArgumentNotNull(member, "member");
487	0	ValidationUtils.ArgumentNotNull(target, "target");
488
489	0	switch (member.MemberType)
490		{
491		case MemberTypes.Field:
492	0	((FieldInfo)member).SetValue(target, value);
493	0	break;
494		case MemberTypes.Property:
495	0	((PropertyInfo)member).SetValue(target, value, null);
496	0	break;
497		default:
498	0	throw new ArgumentException("MemberInfo '{0}' must be of type FieldInfo or PropertyInfo".FormatWith(CultureInfo.InvariantCulture, member.Name), "member");
499		}
500	0	}