void ExportType(TypeMapping mapping)
        {
            if (mapping.IsReference)
            {
                return;
            }
            if (ExportedMappings[mapping] == null)
            {
                CodeTypeDeclaration codeClass = null;
                ExportedMappings.Add(mapping, mapping);
                if (mapping is EnumMapping)
                {
                    codeClass = ExportEnum((EnumMapping)mapping, typeof(SoapEnumAttribute));
                }
                else if (mapping is StructMapping)
                {
                    codeClass = ExportStruct((StructMapping)mapping);
                }
                else if (mapping is ArrayMapping)
                {
                    EnsureTypesExported(((ArrayMapping)mapping).Elements, null);
                }
                if (codeClass != null)
                {
                    // Add [GeneratedCodeAttribute(Tool=.., Version=..)]
                    codeClass.CustomAttributes.Add(GeneratedCodeAttribute);

                    // Add [SerializableAttribute]
                    codeClass.CustomAttributes.Add(new CodeAttributeDeclaration(typeof(SerializableAttribute).FullName));

                    if (!codeClass.IsEnum)
                    {
                        // Add [DebuggerStepThrough]
                        codeClass.CustomAttributes.Add(new CodeAttributeDeclaration(typeof(DebuggerStepThroughAttribute).FullName));
                        // Add [DesignerCategory("code")]
                        codeClass.CustomAttributes.Add(new CodeAttributeDeclaration(typeof(DesignerCategoryAttribute).FullName, new CodeAttributeArgument[] { new CodeAttributeArgument(new CodePrimitiveExpression("code")) }));
                    }
                    AddTypeMetadata(codeClass.CustomAttributes, typeof(SoapTypeAttribute), mapping.TypeDesc.Name, Accessor.UnescapeName(mapping.TypeName), mapping.Namespace, mapping.IncludeInSchema);
                    ExportedClasses.Add(mapping, codeClass);
                }
            }
        }
Example #2
0
        private void ExportType(TypeMapping mapping, string name, string ns, ElementAccessor rootElement, bool checkReference)
        {
            if (mapping.IsReference && mapping.Namespace != Soap.Encoding)
            {
                return;
            }

            if (mapping is StructMapping && checkReference && ((StructMapping)mapping).ReferencedByTopLevelElement && rootElement == null)
            {
                return;
            }

            if (mapping is ArrayMapping && rootElement != null && rootElement.IsTopLevelInSchema && ((ArrayMapping)mapping).TopLevelMapping != null)
            {
                mapping = ((ArrayMapping)mapping).TopLevelMapping;
            }

            CodeTypeDeclaration codeClass = null;

            if (ExportedMappings[mapping] == null)
            {
                ExportedMappings.Add(mapping, mapping);
                if (mapping.TypeDesc.IsMappedType)
                {
                    codeClass = mapping.TypeDesc.ExtendedType.ExportTypeDefinition(CodeNamespace, CodeCompileUnit);
                }
                else if (mapping is EnumMapping)
                {
                    codeClass = ExportEnum((EnumMapping)mapping, typeof(XmlEnumAttribute));
                }
                else if (mapping is StructMapping)
                {
                    codeClass = ExportStruct((StructMapping)mapping);
                }
                else if (mapping is ArrayMapping)
                {
                    EnsureTypesExported(((ArrayMapping)mapping).Elements, ns);
                }
                if (codeClass != null)
                {
                    if (!mapping.TypeDesc.IsMappedType)
                    {
                        // Add [GeneratedCodeAttribute(Tool=.., Version=..)]
                        codeClass.CustomAttributes.Add(GeneratedCodeAttribute);

                        if (!codeClass.IsEnum)
                        {
                            // Add [DebuggerStepThrough]
                            codeClass.CustomAttributes.Add(new CodeAttributeDeclaration(typeof(DebuggerStepThroughAttribute).FullName));
                            // Add [DesignerCategory("code")]
                        }
                        AddTypeMetadata(codeClass.CustomAttributes, typeof(XmlTypeAttribute), mapping.TypeDesc.Name, Accessor.UnescapeName(mapping.TypeName), mapping.Namespace, mapping.IncludeInSchema);
                    }
                    else if (FindAttributeDeclaration(typeof(GeneratedCodeAttribute), codeClass.CustomAttributes) == null)
                    {
                        // Add [GeneratedCodeAttribute(Tool=.., Version=..)]
                        codeClass.CustomAttributes.Add(GeneratedCodeAttribute);
                    }
                    ExportedClasses.Add(mapping, codeClass);
                }
            }
            else
            {
                codeClass = (CodeTypeDeclaration)ExportedClasses[mapping];
            }

            if (codeClass != null && rootElement != null)
            {
                AddRootMetadata(codeClass.CustomAttributes, mapping, name, ns, rootElement);
            }
        }