protected virtual object SerializeCollection(IDesignerSerializationManager manager, CodeExpression targetExpression, Type targetType, ICollection originalCollection, ICollection valuesToSerialize) { if (manager == null) { throw new ArgumentNullException("manager"); } if (targetType == null) { throw new ArgumentNullException("targetType"); } if (originalCollection == null) { throw new ArgumentNullException("originalCollection"); } if (valuesToSerialize == null) { throw new ArgumentNullException("valuesToSerialize"); } object obj2 = null; bool flag = false; if (typeof(Array).IsAssignableFrom(targetType)) { CodeArrayCreateExpression right = this.SerializeArray(manager, targetType, originalCollection, valuesToSerialize); if (right != null) { if (targetExpression != null) { obj2 = new CodeAssignStatement(targetExpression, right); } else { obj2 = right; } flag = true; } return(obj2); } if (valuesToSerialize.Count > 0) { TypeDescriptionProvider targetFrameworkProvider = CodeDomSerializerBase.GetTargetFrameworkProvider(manager, originalCollection); if (targetFrameworkProvider == null) { targetFrameworkProvider = TypeDescriptor.GetProvider(originalCollection); } MethodInfo[] methods = targetFrameworkProvider.GetReflectionType(originalCollection).GetMethods(BindingFlags.Public | BindingFlags.Instance); List <MethodInfo> list = new List <MethodInfo>(); List <MethodInfo> list2 = new List <MethodInfo>(); foreach (MethodInfo info in methods) { if (info.Name.Equals("AddRange")) { ParameterInfo[] parameters = info.GetParameters(); if (((parameters.Length == 1) && parameters[0].ParameterType.IsArray) && this.MethodSupportsSerialization(info)) { list.Add(info); } } if ((info.Name.Equals("Add") && (info.GetParameters().Length == 1)) && this.MethodSupportsSerialization(info)) { list2.Add(info); } } MethodInfo info2 = ChooseMethodByType(targetFrameworkProvider, list, valuesToSerialize); if (info2 != null) { Type runtimeType = targetFrameworkProvider.GetRuntimeType(info2.GetParameters()[0].ParameterType.GetElementType()); obj2 = this.SerializeViaAddRange(manager, targetExpression, targetType, runtimeType, valuesToSerialize); flag = true; } else { MethodInfo info3 = ChooseMethodByType(targetFrameworkProvider, list2, valuesToSerialize); if (info3 != null) { Type elementType = targetFrameworkProvider.GetRuntimeType(info3.GetParameters()[0].ParameterType); obj2 = this.SerializeViaAdd(manager, targetExpression, targetType, elementType, valuesToSerialize); flag = true; } } if (!flag && originalCollection.GetType().IsSerializable) { obj2 = base.SerializeToResourceExpression(manager, originalCollection, false); } } return(obj2); }
/// <summary> /// This retrieves the value of this property. If the property returns false /// from ShouldSerializeValue (indicating the ambient value for this property) /// This will look for an AmbientValueAttribute and use it if it can. /// </summary> private object GetPropertyValue(IDesignerSerializationManager manager, PropertyDescriptor property, object value, out bool validValue) { object propertyValue = null; validValue = true; try { if (!property.ShouldSerializeValue(value)) { // We aren't supposed to be serializing this property, but we decided to do // it anyway. Check the property for an AmbientValue attribute and if we // find one, use it's value to serialize. AmbientValueAttribute attr = (AmbientValueAttribute)property.Attributes[typeof(AmbientValueAttribute)]; if (attr != null) { return(attr.Value); } else { DefaultValueAttribute defAttr = (DefaultValueAttribute)property.Attributes[typeof(DefaultValueAttribute)]; if (defAttr != null) { return(defAttr.Value); } else { // nope, we're not valid... // validValue = false; } } } propertyValue = property.GetValue(value); } catch (Exception e) { // something failed -- we don't have a valid value validValue = false; manager.ReportError(new CodeDomSerializerException(string.Format(SR.SerializerPropertyGenFailed, property.Name, e.Message), manager)); } if ((propertyValue != null) && (!propertyValue.GetType().IsValueType) && !(propertyValue is Type)) { // DevDiv2 (Dev11) bug 187766 : property whose type implements ISupportInitialize is not // serialized with Begin/EndInit. Type type = TypeDescriptor.GetProvider(propertyValue).GetReflectionType(typeof(object)); if (!type.IsDefined(typeof(ProjectTargetFrameworkAttribute), false)) { // TargetFrameworkProvider is not attached TypeDescriptionProvider typeProvider = CodeDomSerializerBase.GetTargetFrameworkProvider(manager, propertyValue); if (typeProvider != null) { TypeDescriptor.AddProvider(typeProvider, propertyValue); } } } return(propertyValue); }