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);
}
