|
static private ApplyAnnotations ( |
||
| typeDecl | ||
| annotations | List |
|
| typeAnnotations | List |
|
| return | ||
private CodeTypeDeclaration ProcessType(ClrContentTypeInfo typeInfo, string parentIdentifier, bool globalType)
{
SetFullTypeName(typeInfo, parentIdentifier);
if (globalType)
{
currentNamespace = typeInfo.clrtypeNs;
}
//Build type using TypeBuilder
typeBuilder = GetTypeBuilder();
typeBuilder.CreateTypeDeclaration(typeInfo);
ProcessProperties(typeInfo.Content, typeInfo.Annotations);
typeBuilder.CreateFunctionalConstructor(typeInfo.Annotations);
typeBuilder.ImplementInterfaces(settings.EnableServiceReference);
typeBuilder.ApplyAnnotations(typeInfo);
if (globalType)
{
if (typeInfo.typeOrigin == SchemaOrigin.Fragment)
{
typeBuilder.AddTypeToTypeManager(typeDictionaryAddStatements, Constants.TypeDictionaryField);
}
else
{
typeBuilder.AddTypeToTypeManager(elementDictionaryAddStatements, Constants.ElementDictionaryField);
}
}
CodeTypeDeclaration builtType = typeBuilder.TypeDeclaration;
ProcessNestedTypes(typeInfo.NestedTypes, builtType, typeInfo.clrFullTypeName);
return(builtType);
}
internal override CodeConstructor CreateFunctionalConstructor(List <ClrAnnotation> annotations)
{
CodeConstructor functionalConstructor = this.declItemsInfo.functionalConstructor;
if ((functionalConstructor == null ? false : functionalConstructor.Parameters.Count > 0))
{
TypeBuilder.ApplyAnnotations(functionalConstructor, annotations, null);
this.decl.Members.Add(functionalConstructor);
}
return(functionalConstructor);
}
internal override CodeConstructor CreateFunctionalConstructor(List <ClrAnnotation> annotations)
{
CodeConstructor constructor = CodeDomHelper.CreateConstructor(MemberAttributes.Public);
if (this.clrTypeInfo.IsSubstitutionMember())
{
constructor.BaseConstructorArgs.Add(new CodePrimitiveExpression(true));
}
constructor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(this.innerTypeName), "content"));
CodeStatementCollection statements = constructor.Statements;
CodeExpression[] codeVariableReferenceExpression = new CodeExpression[] { new CodeVariableReferenceExpression("content") };
statements.Add(CodeDomHelper.CreateMethodCall(null, "SetInnerType", codeVariableReferenceExpression));
TypeBuilder.ApplyAnnotations(constructor, annotations, null);
this.decl.Members.Add(constructor);
return(constructor);
}
internal override void CreateDefaultConstructor(List <ClrAnnotation> annotations)
{
CodeMemberField typeField = CodeDomHelper.CreateMemberField(this.memberName, this.innerTypeName, MemberAttributes.Private, false);
CodeFieldReferenceExpression fieldRef = CodeDomHelper.CreateFieldReference("this", this.memberName);
CodeConstructor emptyConstructor = CodeDomHelper.CreateConstructor(MemberAttributes.Public);
if ((this.innerTypeAttributes & TypeAttributes.Abstract) != TypeAttributes.NotPublic)
{
emptyConstructor.Statements.Add(new CodeThrowExceptionStatement(new CodeObjectCreateExpression("InvalidOperationException", new CodeExpression[0])));
}
else
{
CodeStatementCollection statements = emptyConstructor.Statements;
CodeExpression[] codeObjectCreateExpression = new CodeExpression[] { new CodeObjectCreateExpression(typeField.Type, new CodeExpression[0]) };
statements.Add(CodeDomHelper.CreateMethodCall(null, "SetInnerType", codeObjectCreateExpression));
}
CodeConstructor dummyConstructor = null;
if (this.clrTypeInfo.IsSubstitutionHead)
{
dummyConstructor = CodeDomHelper.CreateConstructor(MemberAttributes.Family);
dummyConstructor.Parameters.Add(new CodeParameterDeclarationExpression("System.Boolean", "setNull"));
this.decl.Members.Add(dummyConstructor);
}
if (this.clrTypeInfo.IsSubstitutionMember())
{
emptyConstructor.BaseConstructorArgs.Add(new CodePrimitiveExpression(true));
if (dummyConstructor != null)
{
dummyConstructor.BaseConstructorArgs.Add(new CodePrimitiveExpression(true));
}
}
TypeBuilder.ApplyAnnotations(emptyConstructor, annotations, null);
this.decl.Members.Add(typeField);
this.decl.Members.Add(emptyConstructor);
this.decl.Members.Add(this.CreateUntypedProperty(fieldRef));
this.decl.Members.Add(this.InnerTypeProperty());
this.decl.Members.Add(this.SetInnerType());
if (this.clrTypeInfo.IsSubstitutionHead)
{
this.decl.Members.Add(this.SetSubstitutionMember());
}
}
internal static CodeTypeDeclaration CreateSimpleType(ClrSimpleTypeInfo typeInfo, Dictionary <XmlSchemaObject, string> nameMappings, LinqToXsdSettings settings)
{
CodeTypeDeclaration simpleTypeDecl = new CodeTypeDeclaration(typeInfo.clrtypeName)
{
TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed
};
CodeConstructor privateConst = new CodeConstructor()
{
Attributes = MemberAttributes.Private
};
simpleTypeDecl.Members.Add(privateConst);
CodeMemberField typeField = CodeDomHelper.CreateMemberField("TypeDefinition", "Xml.Schema.Linq.SimpleTypeValidator", MemberAttributes.Abstract | MemberAttributes.Final | MemberAttributes.Static | MemberAttributes.FamilyAndAssembly | MemberAttributes.FamilyOrAssembly | MemberAttributes.Public, false);
typeField.InitExpression = SimpleTypeCodeDomHelper.CreateSimpleTypeDef(typeInfo, nameMappings, settings, false);
simpleTypeDecl.Members.Add(typeField);
TypeBuilder.ApplyAnnotations(simpleTypeDecl, typeInfo);
return(simpleTypeDecl);
}
internal override CodeConstructor CreateFunctionalConstructor(List <ClrAnnotation> annotations)
{
string parameterName = "content";
CodeConstructor constructor = CodeDomHelper.CreateConstructor(MemberAttributes.Public);
CodeTypeReference returnType = null;
if (!this.isSchemaList)
{
returnType = new CodeTypeReference(this.simpleTypeName);
}
else
{
CodeTypeReference[] codeTypeReference = new CodeTypeReference[] { new CodeTypeReference(this.simpleTypeName) };
returnType = new CodeTypeReference("IList", codeTypeReference);
}
constructor.Parameters.Add(new CodeParameterDeclarationExpression(returnType, parameterName));
constructor.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(CodeDomHelper.This(), "TypedValue"), new CodeVariableReferenceExpression(parameterName)));
TypeBuilder.ApplyAnnotations(constructor, annotations, null);
this.decl.Members.Add(constructor);
return(constructor);
}
private CodeTypeDeclaration ProcessType(ClrContentTypeInfo typeInfo, string parentIdentifier, bool globalType)
{
SetFullTypeName(typeInfo, parentIdentifier);
if(globalType) {
currentNamespace = typeInfo.clrtypeNs;
}
//Build type using TypeBuilder
typeBuilder = GetTypeBuilder();
typeBuilder.CreateTypeDeclaration(typeInfo);
ProcessProperties(typeInfo.Content, typeInfo.Annotations);
typeBuilder.CreateFunctionalConstructor(typeInfo.Annotations);
typeBuilder.ImplementInterfaces(settings.EnableServiceReference);
typeBuilder.ApplyAnnotations(typeInfo);
if (globalType) {
if (typeInfo.typeOrigin == SchemaOrigin.Fragment) {
typeBuilder.AddTypeToTypeManager(typeDictionaryAddStatements, Constants.TypeDictionaryField);
}
else {
typeBuilder.AddTypeToTypeManager(elementDictionaryAddStatements, Constants.ElementDictionaryField);
}
}
CodeTypeDeclaration builtType = typeBuilder.TypeDeclaration;
ProcessNestedTypes(typeInfo.NestedTypes, builtType, typeInfo.clrFullTypeName);
return builtType;
}
internal static void ApplyAnnotations(CodeTypeMember typeDecl, ClrTypeInfo typeInfo)
{
TypeBuilder.ApplyAnnotations(typeDecl, typeInfo.Annotations, null);
}
internal static void ApplyAnnotations(CodeMemberProperty propDecl, ClrBasePropertyInfo propInfo, List <ClrAnnotation> typeAnnotations)
{
TypeBuilder.ApplyAnnotations(propDecl, propInfo.Annotations, typeAnnotations);
}
internal void ApplyAnnotations(ClrTypeInfo typeInfo)
{
TypeBuilder.ApplyAnnotations(this.decl, typeInfo);
}
internal virtual void CreateDefaultConstructor(List <ClrAnnotation> annotations)
{
this.decl.Members.Add(TypeBuilder.ApplyAnnotations(CodeDomHelper.CreateConstructor(MemberAttributes.Public), annotations, null));
}
internal virtual void ApplyAnnotations(CodeMemberProperty propDecl, List <ClrAnnotation> typeAnnotations)
{
TypeBuilder.ApplyAnnotations(propDecl, this, typeAnnotations);
}