private static void AddPrimitive(Type type, string dataTypeName, string formatterName, TypeFlags flags) { XmlSchemaSimpleType dataType = new XmlSchemaSimpleType(); dataType.Name = dataTypeName; TypeDesc typeDesc = new TypeDesc(type, true, dataType, formatterName, flags); if (s_primitiveTypes[type] == null) { s_primitiveTypes.Add(type, typeDesc); } s_primitiveDataTypes.Add(dataType, typeDesc); s_primitiveNames.Add(dataTypeName, XmlSchema.Namespace, typeDesc); }
/// <include file='doc\XmlAttributeOverrides.uex' path='docs/doc[@for="XmlAttributeOverrides.Add1"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void Add(Type type, string member, XmlAttributes attributes) { Hashtable members = (Hashtable)_types[type]; if (members == null) { members = new Hashtable(); _types.Add(type, members); } else if (members[member] != null) { throw new InvalidOperationException(SR.Format(SR.XmlAttributeSetAgain, type.FullName, member)); } members.Add(member, attributes); }
internal ArrayModel GetArrayModel(Type type) { TypeModel model = (TypeModel)_arrayModels[type]; if (model == null) { model = GetTypeModel(type); if (!(model is ArrayModel)) { TypeDesc typeDesc = _typeScope.GetArrayTypeDesc(type); model = new ArrayModel(type, typeDesc, this); } _arrayModels.Add(type, model); } return((ArrayModel)model); }
internal TypeDesc GetArrayTypeDesc(Type type) { TypeDesc typeDesc = (TypeDesc)_arrayTypeDescs[type]; if (typeDesc == null) { typeDesc = GetTypeDesc(type); if (!typeDesc.IsArrayLike) { typeDesc = ImportTypeDesc(type, null, false); } typeDesc.CheckSupported(); _arrayTypeDescs.Add(type, typeDesc); } return(typeDesc); }
internal TypeModel GetTypeModel(Type type, bool directReference) { TypeModel model = (TypeModel)_models[type]; if (model != null) { return(model); } TypeDesc typeDesc = _typeScope.GetTypeDesc(type, null, directReference); switch (typeDesc.Kind) { case TypeKind.Enum: model = new EnumModel(type, typeDesc, this); break; case TypeKind.Primitive: model = new PrimitiveModel(type, typeDesc, this); break; case TypeKind.Array: case TypeKind.Collection: case TypeKind.Enumerable: model = new ArrayModel(type, typeDesc, this); break; case TypeKind.Root: case TypeKind.Class: case TypeKind.Struct: model = new StructModel(type, typeDesc, this); break; default: if (!typeDesc.IsSpecial) { throw new NotSupportedException(SR.Format(SR.XmlUnsupportedTypeKind, type.FullName)); } model = new SpecialModel(type, typeDesc, this); break; } _models.Add(type, model); return(model); }
internal void Add(string ns, object o, TempAssembly assembly) { TempAssemblyCacheKey key = new TempAssemblyCacheKey(ns, o); lock (this) { if (_cache[key] == assembly) { return; } Hashtable clone = new Hashtable(); foreach (object k in _cache.Keys) { clone.Add(k, _cache[k]); } _cache = clone; _cache[key] = assembly; } }
private void CheckAmbiguousChoice(XmlAttributes a, Type accessorType, string accessorName) { Hashtable choiceTypes = new Hashtable(); XmlElementAttributes elements = a.XmlElements; if (elements != null && elements.Count >= 2 && a.XmlChoiceIdentifier == null) { for (int i = 0; i < elements.Count; i++) { Type type = elements[i].Type == null ? accessorType : elements[i].Type; if (choiceTypes.Contains(type)) { // You need to add {0} to the '{1}'. throw new InvalidOperationException(SR.Format(SR.XmlChoiceIdentiferMissing, typeof(XmlChoiceIdentifierAttribute).Name, accessorName)); } else { choiceTypes.Add(type, false); } } } if (choiceTypes.Contains(typeof(XmlElement)) && a.XmlAnyElements.Count > 0) { // You need to add {0} to the '{1}'. throw new InvalidOperationException(SR.Format(SR.XmlChoiceIdentiferMissing, typeof(XmlChoiceIdentifierAttribute).Name, accessorName)); } XmlArrayItemAttributes items = a.XmlArrayItems; if (items != null && items.Count >= 2) { NameTable arrayTypes = new NameTable(); for (int i = 0; i < items.Count; i++) { Type type = items[i].Type == null ? accessorType : items[i].Type; string ns = items[i].NestingLevel.ToString(CultureInfo.InvariantCulture); XmlArrayItemAttribute item = (XmlArrayItemAttribute)arrayTypes[type.FullName, ns]; if (item != null) { throw new InvalidOperationException(SR.Format(SR.XmlArrayItemAmbiguousTypes, accessorName, item.ElementName, items[i].ElementName, typeof(XmlElementAttribute).Name, typeof(XmlChoiceIdentifierAttribute).Name, accessorName)); } else { arrayTypes[type.FullName, ns] = items[i]; } } } }
/// <include file='doc\CodeIdentifiers.uex' path='docs/doc[@for="CodeIdentifiers.Add"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void Add(string identifier, object value) { _identifiers.Add(identifier, value); _list.Add(value); }
internal void Add(string name, string ns, object value) { NameKey key = new NameKey(name, ns); _table.Add(key, value); }
private TypeDesc ImportTypeDesc(Type type, MemberInfo memberInfo, bool directReference) { TypeDesc typeDesc = null; TypeKind kind; Type arrayElementType = null; Type baseType = null; TypeFlags flags = 0; Exception exception = null; if (!type.GetTypeInfo().IsVisible) { flags |= TypeFlags.Unsupported; exception = new InvalidOperationException(SR.Format(SR.XmlTypeInaccessible, type.FullName)); } else if (directReference && (type.GetTypeInfo().IsAbstract&& type.GetTypeInfo().IsSealed)) { flags |= TypeFlags.Unsupported; exception = new InvalidOperationException(SR.Format(SR.XmlTypeStatic, type.FullName)); } if (!type.GetTypeInfo().IsValueType) { flags |= TypeFlags.Reference; } if (type == typeof(object)) { kind = TypeKind.Root; flags |= TypeFlags.HasDefaultConstructor; } else if (type == typeof(ValueType)) { kind = TypeKind.Enum; flags |= TypeFlags.Unsupported; if (exception == null) { exception = new NotSupportedException(SR.Format(SR.XmlSerializerUnsupportedType, type.FullName)); } } else if (type == typeof(void)) { kind = TypeKind.Void; } else if (typeof(IXmlSerializable).IsAssignableFrom(type)) { kind = TypeKind.Serializable; flags |= TypeFlags.Special | TypeFlags.CanBeElementValue; flags |= GetConstructorFlags(type, ref exception); } else if (type.IsArray) { kind = TypeKind.Array; if (type.GetArrayRank() > 1) { flags |= TypeFlags.Unsupported; if (exception == null) { exception = new NotSupportedException(SR.Format(SR.XmlUnsupportedRank, type.FullName)); } } arrayElementType = type.GetElementType(); flags |= TypeFlags.HasDefaultConstructor; } else if (typeof(ICollection).IsAssignableFrom(type)) { kind = TypeKind.Collection; arrayElementType = GetCollectionElementType(type, memberInfo == null ? null : memberInfo.DeclaringType.FullName + "." + memberInfo.Name); flags |= GetConstructorFlags(type, ref exception); } else if (type == typeof(XmlQualifiedName)) { kind = TypeKind.Primitive; } else if (type.GetTypeInfo().IsPrimitive) { kind = TypeKind.Primitive; flags |= TypeFlags.Unsupported; if (exception == null) { exception = new NotSupportedException(SR.Format(SR.XmlSerializerUnsupportedType, type.FullName)); } } else if (type.GetTypeInfo().IsEnum) { kind = TypeKind.Enum; } else if (type.GetTypeInfo().IsValueType) { kind = TypeKind.Struct; if (IsOptionalValue(type)) { baseType = type.GetGenericArguments()[0]; flags |= TypeFlags.OptionalValue; } else { baseType = type.GetTypeInfo().BaseType; } if (type.GetTypeInfo().IsAbstract) { flags |= TypeFlags.Abstract; } } else if (type.GetTypeInfo().IsClass) { { kind = TypeKind.Class; baseType = type.GetTypeInfo().BaseType; if (type.GetTypeInfo().IsAbstract) { flags |= TypeFlags.Abstract; } } } else if (type.GetTypeInfo().IsInterface) { kind = TypeKind.Void; flags |= TypeFlags.Unsupported; if (exception == null) { if (memberInfo == null) { exception = new NotSupportedException(SR.Format(SR.XmlUnsupportedInterface, type.FullName)); } else { exception = new NotSupportedException(SR.Format(SR.XmlUnsupportedInterfaceDetails, memberInfo.DeclaringType.FullName + "." + memberInfo.Name, type.FullName)); } } } else { kind = TypeKind.Void; flags |= TypeFlags.Unsupported; if (exception == null) { exception = new NotSupportedException(SR.Format(SR.XmlSerializerUnsupportedType, type.FullName)); } } // check to see if the type has public default constructor for classes if (kind == TypeKind.Class && !type.GetTypeInfo().IsAbstract) { flags |= GetConstructorFlags(type, ref exception); } // check if a struct-like type is enumerable if (kind == TypeKind.Struct || kind == TypeKind.Class) { if (typeof(IEnumerable).IsAssignableFrom(type)) { arrayElementType = GetEnumeratorElementType(type, ref flags); kind = TypeKind.Enumerable; // GetEnumeratorElementType checks for the security attributes on the GetEnumerator(), Add() methods and Current property, // we need to check the MoveNext() and ctor methods for the security attribues flags |= GetConstructorFlags(type, ref exception); } } typeDesc = new TypeDesc(type, CodeIdentifier.MakeValid(TypeName(type)), type.ToString(), kind, null, flags, null); typeDesc.Exception = exception; if (directReference && (typeDesc.IsClass || kind == TypeKind.Serializable)) { typeDesc.CheckNeedConstructor(); } if (typeDesc.IsUnsupported) { // return right away, do not check anything else return(typeDesc); } _typeDescs.Add(type, typeDesc); if (arrayElementType != null) { TypeDesc td = GetTypeDesc(arrayElementType, memberInfo, true, false); // explicitly disallow read-only elements, even if they are collections if (directReference && (td.IsCollection || td.IsEnumerable) && !td.IsPrimitive) { td.CheckNeedConstructor(); } typeDesc.ArrayElementTypeDesc = td; } if (baseType != null && baseType != typeof(object) && baseType != typeof(ValueType)) { typeDesc.BaseTypeDesc = GetTypeDesc(baseType, memberInfo, false, false); } return(typeDesc); }