/// <summary> /// Fills in the given type declaration based on the given metadata /// </summary> /// <param name="complexType">The complex type's metadata</param> /// <param name="complexTypeClass">The type declaration</param> protected override void DeclareComplexType(ComplexType complexType, CodeTypeDeclaration complexTypeClass) { complexTypeClass.IsPartial = true; complexTypeClass.IsClass = true; // Add public constructor for this type var constructor = complexTypeClass.AddConstructor(); foreach (MemberProperty memberProperty in complexType.Properties) { this.DeclareMemberProperty(memberProperty, complexTypeClass); this.DeclareOptionalPropertyInitializer(memberProperty, constructor); } }
/// <summary> /// Fills in the given type declaration based on the given metadata /// </summary> /// <param name="entityType">The entity type's metadata</param> /// <param name="entityTypeClass">The type declaration</param> protected override void DeclareEntityType(EntityType entityType, CodeTypeDeclaration entityTypeClass) { entityTypeClass.IsPartial = true; entityTypeClass.IsClass = true; if (entityType.IsAbstract) { entityTypeClass.SetAbstract(); } if (entityType.BaseType != null) { entityTypeClass.BaseTypes.Add(entityType.BaseType.FullName); } // Add public constructor for this type var constructor = entityTypeClass.AddConstructor(); // Declare all members that are declared foreach (MemberProperty memberProperty in entityType.Properties) { this.DeclareMemberProperty(memberProperty, entityTypeClass); this.DeclareOptionalPropertyInitializer(memberProperty, constructor); } // Declare all members that are declared foreach (NavigationProperty navigationProperty in entityType.NavigationProperties) { this.DeclareNavigationProperty(navigationProperty, entityTypeClass); this.DeclareOptionalPropertyInitializer(navigationProperty, constructor); } this.GenerateAttributes(entityType, entityTypeClass); }
/// <summary> /// Builds a code representation of an <see cref="ComplexType"/>. /// </summary> /// <param name="type">The <see cref="ComplexType"/> from which to generate code.</param> /// <returns>A <see cref="CodeTypeDeclaration"/> which represents the <see cref="ComplexType"/>.</returns> protected virtual CodeTypeDeclaration BuildType(ComplexType type) { var codeClass = new CodeTypeDeclaration(type.Name); codeClass.AddConstructor(); ApplyTypeAccessModifier(codeClass, type.Annotations.OfType<TypeAccessModifierAnnotation>().SingleOrDefault()); if (type.Annotations.Any(a => a is SerializableAnnotation)) { codeClass.AddCustomAttribute(typeof(SerializableAttribute)); } if (type.Annotations.Any(a => a is CodeAttributeAnnotation)) { this.AddCodeAttributeAnnotationAsCustomAttribute(codeClass, type.Annotations.OfType<CodeAttributeAnnotation>()); } this.AddProperties(codeClass, type); return codeClass; }
/// <summary> /// Builds a code representation of an <see cref="EntityType"/>. /// </summary> /// <param name="type">The <see cref="EntityType"/> from which to generate code.</param> /// <returns>A <see cref="CodeTypeDeclaration"/> which represents the <see cref="EntityType"/>.</returns> protected virtual CodeTypeDeclaration BuildType(EntityType type) { var codeClass = new CodeTypeDeclaration(type.Name); var defaultConstructor = codeClass.AddConstructor(); ApplyTypeAccessModifier(codeClass, type.Annotations.OfType<TypeAccessModifierAnnotation>().SingleOrDefault()); if (type.Annotations.Any(a => a is SerializableAnnotation)) { codeClass.AddCustomAttribute(typeof(SerializableAttribute)); } if (type.Annotations.Any(a => a is CodeAttributeAnnotation)) { this.AddCodeAttributeAnnotationAsCustomAttribute(codeClass, type.Annotations.OfType<CodeAttributeAnnotation>()); } var genericTypeAnnotation = type.Annotations.OfType<GenericTypeAnnotation>().FirstOrDefault(); if (genericTypeAnnotation != null) { foreach (var typeParameter in genericTypeAnnotation.TypeParameters) { codeClass.TypeParameters.Add(new CodeTypeParameter(typeParameter)); } } if (type.BaseType != null) { var baseType = new CodeTypeReference(type.BaseType.FullName); var baseGenericTypeAnnotation = type.BaseType.Annotations.OfType<GenericTypeAnnotation>().SingleOrDefault(); var genericArgumentsAnnotation = type.Annotations.OfType<GenericArgumentsAnnotation>().SingleOrDefault(); if (genericArgumentsAnnotation != null) { foreach (var typeParameter in baseGenericTypeAnnotation.TypeParameters) { var typeRef = Code.TypeRef(typeParameter); var argument = genericArgumentsAnnotation.GenericArguments.SingleOrDefault(g => g.TypeParameterName == typeParameter); if (argument != null) { typeRef = codeTypeReferenceResolver.Resolve(argument.DataType); } else { if (genericTypeAnnotation == null || !genericTypeAnnotation.TypeParameters.Contains(typeParameter)) { throw new TaupoArgumentException( string.Format( CultureInfo.InvariantCulture, "Entity type {0} cannot derive from entity type {1} because it does not specify a {2} or {3} to fill in {1}'s generic parameter {4}.", type.Name, type.BaseType.Name, typeof(GenericTypeAnnotation).Name, typeof(GenericArgumentsAnnotation).Name, typeParameter)); } } baseType.TypeArguments.Add(typeRef); } } else { if (baseGenericTypeAnnotation != null) { throw new TaupoArgumentException( string.Format( CultureInfo.InvariantCulture, "Entity type {0} cannot derive from entity type {1} because it does not specify a {2} or {3} to fill in {1}'s generic parameter {4}.", type.Name, type.BaseType.Name, typeof(GenericTypeAnnotation).Name, typeof(GenericArgumentsAnnotation).Name, baseGenericTypeAnnotation.TypeParameters.First())); } } codeClass.InheritsFrom(baseType); } if (type.IsAbstract) { codeClass.SetAbstract(); } this.AddProperties(codeClass, type); this.AddNavigationProperties(codeClass, type, defaultConstructor); return codeClass; }