コード例 #1
0
		public IList<FilterDef> FullTextFilters(Type type)
		{
			return AttributeUtil
				.GetAttributes<FullTextFilterDefAttribute>(type, false)
				.Select(CreateFilterDefinition)
				.ToList();
		}
コード例 #2
0
        public DocumentMapping(Type mappedClass) {
            this.MappedClass = mappedClass;

            this.ClassBridges = new List<ClassBridgeMapping>();
            this.Fields = new List<FieldMapping>();
            this.Embedded = new List<EmbeddedMapping>();
            this.ContainedIn = new List<ContainedInMapping>();
            this.FullTextFilterDefinitions = new List<FilterDef>();
        }
コード例 #3
0
 public ObjectSubclassInfo(Type type, ConstructorInfo constructor) {
   TypeInfo = type.GetTypeInfo();
   ClassName = GetClassName(TypeInfo);
   Constructor = constructor;
   PropertyMappings = type.GetProperties()
     .Select(prop => Tuple.Create(prop, prop.GetCustomAttribute<ParseFieldNameAttribute>(true)))
     .Where(t => t.Item2 != null)
     .Select(t => Tuple.Create(t.Item1, t.Item2.FieldName))
     .ToDictionary(t => t.Item1.Name, t => t.Item2);
 }
コード例 #4
0
    public bool IsTypeValid(String className, Type type) {
      ObjectSubclassInfo subclassInfo = null;

      mutex.EnterReadLock();
      registeredSubclasses.TryGetValue(className, out subclassInfo);
      mutex.ExitReadLock();

      return subclassInfo == null
        ? type == typeof(ParseObject)
        : subclassInfo.TypeInfo == type.GetTypeInfo();
    }
コード例 #5
0
        public EntityPropertyMappingInfo(EntityPropertyMappingAttribute attribute, Type definingType, ClientType actualPropertyType)
        {
            Debug.Assert(attribute != null, "attribute != null");
            Debug.Assert(definingType != null, "definingType != null");
            Debug.Assert(actualPropertyType != null, "actualPropertyType != null");

            this.attribute = attribute;
            this.definingType = definingType;
            this.actualPropertyType = actualPropertyType;

            Debug.Assert(!string.IsNullOrEmpty(attribute.SourcePath), "Invalid source path");
            this.segmentedSourcePath = attribute.SourcePath.Split('/');
        }
コード例 #6
0
    public void RegisterSubclass(Type type) {
      TypeInfo typeInfo = type.GetTypeInfo();
      if (!typeInfo.IsSubclassOf(typeof(ParseObject))) {
        throw new ArgumentException("Cannot register a type that is not a subclass of ParseObject");
      }

      String className = ObjectSubclassInfo.GetClassName(typeInfo);

      try {
        // Perform this as a single independent transaction, so we can never get into an
        // intermediate state where we *theoretically* register the wrong class due to a
        // TOCTTOU bug.
        mutex.EnterWriteLock();

        ObjectSubclassInfo previousInfo = null;
        if (registeredSubclasses.TryGetValue(className, out previousInfo)) {
          if (typeInfo.IsAssignableFrom(previousInfo.TypeInfo)) {
            // Previous subclass is more specific or equal to the current type, do nothing.
            return;
          } else if (previousInfo.TypeInfo.IsAssignableFrom(typeInfo)) {
            // Previous subclass is parent of new child, fallthrough and actually register
            // this class.
            /* Do nothing */
          } else {
            throw new ArgumentException(
              "Tried to register both " + previousInfo.TypeInfo.FullName + " and " + typeInfo.FullName +
              " as the ParseObject subclass of " + className + ". Cannot determine the right class " +
              "to use because neither inherits from the other."
            );
          }
        }

        ConstructorInfo constructor = type.FindConstructor();
        if (constructor == null) {
          throw new ArgumentException("Cannot register a type that does not implement the default constructor!");
        }

        registeredSubclasses[className] = new ObjectSubclassInfo(type, constructor);
      } finally {
        mutex.ExitWriteLock();
      }

      Action toPerform = null;
      if (registerActions.TryGetValue(className, out toPerform)) {
        toPerform();
      }
    }
コード例 #7
0
		internal Object InstantiateObject(Type objectType)
		{
			/*if (TCU.GetTypeInfo(objectType).IsInterface || TCU.GetTypeInfo(objectType).IsAbstract || TCU.GetTypeInfo(objectType).IsValueType)
			{
				throw new JsonTypeCoercionException(
					String.Format(TypeCoercionUtility.ErrorCannotInstantiate, new System.Object[] {objectType.FullName}));
			}

			ConstructorInfo ctor = objectType.GetConstructor(Type.EmptyTypes);
			if (ConstructorInfo.Equals (ctor, null)) {
				throw new JsonTypeCoercionException (
					String.Format (TypeCoercionUtility.ErrorDefaultCtor, new System.Object[] { objectType.FullName }));
			}
			Object result;
			try
			{
				// always try-catch Invoke() to expose real exception
				result = ctor.Invoke(null);
			}
			catch (TargetInvocationException ex)
			{
				if (ex.InnerException != null)
				{
					throw new JsonTypeCoercionException(ex.InnerException.Message, ex.InnerException);
				}
				throw new JsonTypeCoercionException("Error instantiating " + objectType.FullName, ex);
			}*/
			return System.Activator.CreateInstance (objectType);
			//return result;
			}
コード例 #8
0
		public IList<IClassBridgeDefinition> ClassBridges(Type type)
		{
			return AttributeUtil.GetAttributes<ClassBridgeAttribute>(type);
		}
コード例 #9
0
		public IIndexedDefinition Indexed(Type type)
		{
			return AttributeUtil.GetAttribute<IndexedAttribute>(type);
		}
コード例 #10
0
		public abstract Dictionary<string,object> WriteJson (Type type, object value);
コード例 #11
0
		public void Write (JsonWriter writer, Type type, object value) {
			Dictionary<string,object> dict = WriteJson (type,value);
			writer.Write (dict);
		}
コード例 #12
0
		/** Returns the converter for the specified type */
		public virtual JsonConverter GetConverter (Type type) {
			for (int i=0;i<converters.Count;i++)
				if (converters[i].CanConvert (type))
					return converters[i];
			
			return null;
		}
コード例 #13
0
		internal object CoerceType(Type targetType, object value)
		{
			bool isNullable = TypeCoercionUtility.IsNullable(targetType);
			if (value == null)
			{
				if (!allowNullValueTypes &&
					TypeCoercionUtility.GetTypeInfo(targetType).IsValueType &&
					!isNullable)
				{
					throw new JsonTypeCoercionException(String.Format(TypeCoercionUtility.ErrorNullValueType, new System.Object[] {targetType.FullName}));
				}
				return value;
			}

			if (isNullable)
			{
				// nullable types have a real underlying struct
				Type[] genericArgs = targetType.GetGenericArguments();
				if (genericArgs.Length == 1)
				{
					targetType = genericArgs[0];
				}
			}

			Type actualType = value.GetType();
			if (TypeCoercionUtility.GetTypeInfo(targetType).IsAssignableFrom(TypeCoercionUtility.GetTypeInfo(actualType)))
			{
				return value;
			}

			if (TypeCoercionUtility.GetTypeInfo(targetType).IsEnum)
			{
				if (value is String)
				{
					if (!Enum.IsDefined(targetType, value))
					{
						// if isn't a defined value perhaps it is the JsonName
						foreach (FieldInfo field in TypeCoercionUtility.GetTypeInfo(targetType).GetFields())
						{
							string jsonName = JsonNameAttribute.GetJsonName(field);
							if (((string)value).Equals(jsonName))
							{
								value = field.Name;
								break;
							}
						}
					}

					return Enum.Parse(targetType, (string)value);
				}
				else
				{
					value = this.CoerceType(Enum.GetUnderlyingType(targetType), value);
					return Enum.ToObject(targetType, value);
				}
			}

			if (value is IDictionary)
			{
				Dictionary<string, MemberInfo> memberMap;
				return this.CoerceType(targetType, (IDictionary)value, out memberMap);
			}

			if (TypeCoercionUtility.GetTypeInfo(typeof(IEnumerable)).IsAssignableFrom(TypeCoercionUtility.GetTypeInfo(targetType)) &&
				TypeCoercionUtility.GetTypeInfo(typeof(IEnumerable)).IsAssignableFrom(TypeCoercionUtility.GetTypeInfo(actualType)))
			{
				return this.CoerceList(targetType, actualType, (IEnumerable)value);
			}

			if (value is String)
			{
				if (Type.Equals (targetType, typeof(DateTime))) {
					DateTime date;
					if (DateTime.TryParse(
						(string)value,
						DateTimeFormatInfo.InvariantInfo,
						DateTimeStyles.RoundtripKind | DateTimeStyles.AllowWhiteSpaces | DateTimeStyles.NoCurrentDateDefault,
						    out date)) {
						return date;
					}
				} else if (Type.Equals (targetType, typeof(Guid))) {
					// try-catch is pointless since will throw upon generic conversion
					return new Guid((string)value);
				} else if (Type.Equals (targetType, typeof(Char))) {
					if (((string)value).Length == 1) {
						return ((string)value)[0];
					}
				} else if (Equals (targetType, typeof(Uri))) {
					Uri uri;
					if (Uri.TryCreate ((string)value, UriKind.RelativeOrAbsolute, out uri)) {
						return uri;
					}
				} else if (Type.Equals (targetType, typeof(Version))) {
					// try-catch is pointless since will throw upon generic conversion
					return new Version ((string)value);
				}
			}
			else if (Type.Equals (targetType, typeof(TimeSpan))) {
				return new TimeSpan ((long)this.CoerceType (typeof(Int64), value));
			}
            if (targetType == typeof(int))
            {
                unchecked
                {
                    if (value is long)
                    {
                        value = (int)((long)value % int.MaxValue);
                    }
                    else if (!(value is string))
                    {
                        value = Convert.ToInt32(value);
                    }
                }
            }
#if !WINPHONE_8

            TypeConverter converter = TypeDescriptor.GetConverter(targetType);
		    if (converter.CanConvertFrom(actualType))
		    {
		        return converter.ConvertFrom(value);
		    }

		    converter = TypeDescriptor.GetConverter(actualType);
			if (converter.CanConvertTo(targetType))
			{
				return converter.ConvertTo(value, targetType);
			}
#endif
            
			try
			{
				// fall back to basics
				return Convert.ChangeType(value, targetType);
			}
			catch (Exception ex)
			{
				throw new JsonTypeCoercionException(
					String.Format("Error converting {0} to {1}", new System.Object[] {value.GetType().FullName, targetType.FullName}), ex);
			}
		}
コード例 #14
0
		/// <summary>
		/// Helper method to set value of either property or field
		/// </summary>
		/// <param name="result"></param>
		/// <param name="memberType"></param>
		/// <param name="memberInfo"></param>
		/// <param name="value"></param>
		internal void SetMemberValue(Object result, Type memberType, MemberInfo memberInfo, object value)
		{
		    try
		    {
		        if (memberInfo is PropertyInfo)
		        {
		            // set value of public property
		            ((PropertyInfo) memberInfo).SetValue(
		                result,
		                this.CoerceType(memberType, value),
		                null);
		        }
		        else if (memberInfo is FieldInfo)
		        {
		            // set value of public field
		            ((FieldInfo) memberInfo).SetValue(
		                result,
		                this.CoerceType(memberType, value));
		        }
		    }
		    catch (Exception e)
		    {
		        throw;
		    }

		    // all other values are ignored
		}
コード例 #15
0
		/** Creates a member map for the type */
		private Dictionary<string, MemberInfo> CreateMemberMap(Type objectType)
		{

			Dictionary<string, MemberInfo> memberMap;

			if (this.MemberMapCache.TryGetValue(objectType, out memberMap))
			{
				// map was stored in cache
				return memberMap;
			}

			// create a new map
			memberMap = new Dictionary<string, MemberInfo>();

			// load properties into property map
			Type tp = objectType;
			while (tp != null) {
				PropertyInfo[] properties = TypeCoercionUtility.GetTypeInfo(tp).GetProperties( BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance );
				for  ( int i = 0 ; i < properties.Length; i++ )
				{
					PropertyInfo info = properties [i];
					if (!info.CanRead || !info.CanWrite) {
						continue;
					}

					if (JsonIgnoreAttribute.IsJsonIgnore (info)) {
						continue;
					}

					string jsonName = JsonNameAttribute.GetJsonName (info);
					if (String.IsNullOrEmpty (jsonName)) {
						memberMap[info.Name] = info;
					} else {
						memberMap[jsonName] = info;
					}
				}

				// load public fields into property map
				FieldInfo[] fields = TypeCoercionUtility.GetTypeInfo(tp).GetFields( BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance );
				foreach (FieldInfo info in fields)
				{
					if (!info.IsPublic && 
	#if WINDOWS_STORE
						info.GetCustomAttribute<JsonMemberAttribute>(false) == null
	#else
						info.GetCustomAttributes(typeof(JsonMemberAttribute), false).Length == 0
	#endif
					) {
						continue;
					}
						
					if (JsonIgnoreAttribute.IsJsonIgnore (info)) {
						continue;
					}

					string jsonName = JsonNameAttribute.GetJsonName (info);
					if (String.IsNullOrEmpty (jsonName)) {
						memberMap[info.Name] = info;
					} else {
						memberMap[jsonName] = info;
					}
				}

				tp = tp.BaseType;
			}

			// store in cache for repeated usage
			this.MemberMapCache[objectType] = memberMap;

			return memberMap;
		}
コード例 #16
0
		/** Returns a member map if suitable for the object type.
		 * Dictionary types will make this method return null
		 */
		public Dictionary<string, MemberInfo> GetMemberMap (Type objectType) {
			// don't incurr the cost of member map for dictionaries
			if (TypeCoercionUtility.GetTypeInfo(typeof(IDictionary)).IsAssignableFrom(TypeCoercionUtility.GetTypeInfo(objectType)))
			{
				return null;
			}
			else
			{
				return this.CreateMemberMap(objectType);
			}
		}
コード例 #17
0
		public void GetMemberWritingMap (Type objectType, JsonWriterSettings settings, out KeyValuePair<string,FieldInfo>[] outFields, out KeyValuePair<string,PropertyInfo>[] outProps) {

			if ( writingMaps == null ) {
				writingMaps = new Dictionary<Type,KeyValuePair< KeyValuePair<string,FieldInfo>[] , KeyValuePair<string,PropertyInfo>[] >> ();
			}

			KeyValuePair< KeyValuePair<string,FieldInfo>[] , KeyValuePair<string,PropertyInfo>[]> pair;
			if (writingMaps.TryGetValue (objectType, out pair)) {
				outFields = pair.Key;
				outProps = pair.Value;
				return;
			}

			bool anonymousType = objectType.IsGenericType && objectType.Name.StartsWith(JsonWriter.AnonymousTypePrefix);

			Type tp = objectType;

			if (fieldList == null)
				fieldList = new List<KeyValuePair<string, FieldInfo>> ();

			if (propList == null)
				propList = new List<KeyValuePair<string, PropertyInfo>> ();

			fieldList.Clear ();
			propList.Clear ();

			while (tp != null) {

				FieldInfo[] fields = tp.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
				for (int j = 0; j < fields.Length; j++ )
				{
					FieldInfo field = fields[j];

					if (field.IsStatic || (!field.IsPublic && field.GetCustomAttributes (typeof(JsonMemberAttribute), true).Length == 0)) {
						//if (Settings.DebugMode)
							//	Console.WriteLine ("Cannot serialize " + field.Name + " : not public or is static (and does not have a JsonMember attribute)");
						continue;
					}

					if (settings.IsIgnored (objectType, field, null)) {
						//if (Settings.DebugMode)
						//	Console.WriteLine ("Cannot serialize " + field.Name + " : ignored by settings");
						continue;
					}

					// use Attributes here to control naming
					string fieldName = JsonNameAttribute.GetJsonName (field);
					if (String.IsNullOrEmpty (fieldName))
						fieldName = field.Name;

					fieldList.Add (new KeyValuePair<string, FieldInfo> (fieldName, field));
				}

				PropertyInfo[] properties = tp.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
				for (int j = 0; j < properties.Length; j++ )
				{
					PropertyInfo property  = properties[j];

					//Console.WriteLine (property.Name);
					if (!property.CanRead) {
						//if (Settings.DebugMode)
						//	Console.WriteLine ("Cannot serialize "+property.Name+" : cannot read");
						continue;
					}

					if (!property.CanWrite && !anonymousType) {
						//if (Settings.DebugMode)
						//	Console.WriteLine ("Cannot serialize "+property.Name+" : cannot write");
						continue;
					}

					if (settings.IsIgnored(objectType, property, null)) {
						//if (Settings.DebugMode)
						//	Console.WriteLine ("Cannot serialize "+property.Name+" : is ignored by settings");
						continue;
					}

					if (property.GetIndexParameters ().Length != 0) {
						//if (Settings.DebugMode)
						//	Console.WriteLine ("Cannot serialize "+property.Name+" : is indexed");
						continue;
					}


					// use Attributes here to control naming
					string propertyName = JsonNameAttribute.GetJsonName(property);
					if (String.IsNullOrEmpty(propertyName))
						propertyName = property.Name;

					propList.Add ( new KeyValuePair<string, PropertyInfo>(propertyName, property));
				}

				tp = tp.BaseType;
			}

			outFields = fieldList.ToArray();
			outProps = propList.ToArray();

			pair = new KeyValuePair< KeyValuePair<string,FieldInfo>[] , KeyValuePair<string,PropertyInfo>[]> ( outFields, outProps );

			writingMaps[objectType] = pair;
		}
コード例 #18
0
		internal Object InstantiateObject(Type objectType, out Dictionary<string, MemberInfo> memberMap)
		{
			Object o = InstantiateObject (objectType);
			memberMap = GetMemberMap (objectType);
			
			return o;
		}
コード例 #19
0
 public void UnregisterSubclass(Type type) {
   mutex.EnterWriteLock();
   registeredSubclasses.Remove(GetClassName(type));
   mutex.ExitWriteLock();
 }
コード例 #20
0
		private object CoerceType(Type targetType, IDictionary value, out Dictionary<string, MemberInfo> memberMap)
		{
			object newValue = this.InstantiateObject(targetType, out memberMap);
			if (memberMap != null)
			{
				// copy any values into new object
				foreach (object key in value.Keys)
				{
					MemberInfo memberInfo;
					Type memberType = TypeCoercionUtility.GetMemberInfo(memberMap, key as String, out memberInfo);
					this.SetMemberValue(newValue, memberType, memberInfo, value[key]);
				}
			}
			return newValue;
		}
コード例 #21
0
		/** Test if this converter can convert the specified type */
		public abstract bool CanConvert (Type t);
コード例 #22
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 &&
					TypeCoercionUtility.GetTypeInfo(paramList[0].ParameterType).IsAssignableFrom(TypeCoercionUtility.GetTypeInfo(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 (ConstructorInfo.Equals (defaultCtor, null)) {
				throw new JsonTypeCoercionException (
					String.Format (TypeCoercionUtility.ErrorDefaultCtor, new System.Object[] { 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
			#if WINDOWS_STORE
			/** \todo Not sure if this finds the correct methods */
			MethodInfo method = TCU.GetTypeInfo(targetType).GetDeclaredMethod("AddRange");
			#else
			MethodInfo method = TypeCoercionUtility.GetTypeInfo(targetType).GetMethod("AddRange");
			#endif

			ParameterInfo[] parameters = (MethodInfo.Equals (method, null)) ?
					null : method.GetParameters();
			Type paramType = (parameters == null || parameters.Length != 1) ?
					null : parameters[0].ParameterType;
			if (!Type.Equals (paramType, null) &&
				TypeCoercionUtility.GetTypeInfo(paramType).IsAssignableFrom (TypeCoercionUtility.GetTypeInfo(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
#if WINDOWS_STORE
				/** \todo Not sure if this finds the correct methods */
				method = TCU.GetTypeInfo(targetType).GetDeclaredMethod("Add");
#else
				method = TypeCoercionUtility.GetTypeInfo(targetType).GetMethod("Add");
#endif
				parameters = (MethodInfo.Equals (method, null)) ?
						null : method.GetParameters();
				paramType = (parameters == null || parameters.Length != 1) ?
						null : parameters[0].ParameterType;
				if (!Type.Equals (paramType, null)) {
					// loop through adding items to collection
					foreach (object item in value) {
						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);
						}
					}
					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}", new System.Object[] {value.GetType().FullName, targetType.FullName}), ex);
			}
		}
コード例 #23
0
		public object Read (JsonReader reader, Type type, Dictionary<string,object> value) {
			return ReadJson (type, value);
		}
コード例 #24
0
		private Array CoerceArray(Type elementType, IEnumerable value)
		{
			//ArrayList target = new ArrayList();
			
			int count = 0;
			foreach (object item in value)
			{
				count++;
			}
			Array arr = Array.CreateInstance (elementType, new int[] {count});

			int i=0;
			foreach (object item in value)
			{
				//target.Add(this.CoerceType(elementType, item));
				arr.SetValue ( this.CoerceType(elementType, item), new int[] {i} );
				i++;
			}

			return arr;//target.ToArray(elementType);
		}
コード例 #25
0
		public abstract object ReadJson (Type type, Dictionary<string,object> value);
コード例 #26
0
		private static bool IsNullable(Type type)
		{
			return TypeCoercionUtility.GetTypeInfo(type).IsGenericType && (typeof(Nullable<>).Equals (type.GetGenericTypeDefinition()));
		}
コード例 #27
0
		/// <summary>
		/// If a Type Hint is present then this method attempts to
		/// use it and move any previously parsed data over.
		/// </summary>
		/// <param name="result">the previous result</param>
		/// <param name="typeInfo">the type info string to use</param>
		/// <param name="objectType">reference to the objectType</param>
		/// <param name="memberMap">reference to the memberMap</param>
		/// <returns></returns>
		internal object ProcessTypeHint(
			IDictionary result,
			string typeInfo,
			out Type objectType,
			out Dictionary<string, MemberInfo> memberMap)
		{
			if (String.IsNullOrEmpty(typeInfo))
			{
				objectType = null;
				memberMap = null;
				return result;
			}

			Type hintedType = Type.GetType(typeInfo, false);
			if (Type.Equals (hintedType, null)) {
				objectType = null;
				memberMap = null;
				return result;
			}

			objectType = hintedType;
			return this.CoerceType(hintedType, result, out memberMap);
		}
コード例 #28
0
 public String GetClassName(Type type) {
   return ObjectSubclassInfo.GetClassName(type.GetTypeInfo());
 }
コード例 #29
0
		/// <summary>
		/// Deserializes a data object of Type <param name="type">type</param> from the <param name="input">input</param>
		/// </summary>
		/// <param name="output"></param>
		/// <param name="data"></param>
		public object Deserialize(TextReader input, Type type)
		{
			return new JsonReader(input, this.Settings).Deserialize(type);
		}
コード例 #30
0
		internal object ProcessTypeHint ( object result, string typeInfo, out Type objectType, out Dictionary<string, MemberInfo> memberMap ) {
			Type hintedType = Type.GetType(typeInfo, false);
			if (Type.Equals (hintedType, null)) {
				objectType = null;
				memberMap = null;
				return result;
			}

			objectType = hintedType;

			if (result != null && Type.Equals (result.GetType (), hintedType)) {
				memberMap = GetMemberMap(objectType);
				return result;
			}

			return InstantiateObject (objectType, out memberMap);
		}