C# CodeTypeDeclaration.AddAutoImplementedProperty方法代码示例

 /// <summary>
 /// Adds a property to the given type declaration based on the given metadata
 /// </summary>
 /// <param name="memberProperty">The property's metadata</param>
 /// <param name="parentClass">The type declaration</param>
 protected override void DeclareMemberProperty(MemberProperty memberProperty, CodeTypeDeclaration parentClass)
 {
     if (memberProperty.IsStream())
     {
         this.DeclareNamedStreamProperty(memberProperty, parentClass);
     }
     else
     {
         parentClass.AddAutoImplementedProperty(this.GetPropertyType(memberProperty, CodeGenerationTypeUsage.Declaration), memberProperty.Name);
     }
 }

 /// <summary>
 /// Adds a navigation property to the given type declaration based on the given metadata
 /// </summary>
 /// <param name="navigationProperty">The property's metadata</param>
 /// <param name="parentClass">The type declaration</param>
 protected override void DeclareNavigationProperty(NavigationProperty navigationProperty, CodeTypeDeclaration parentClass)
 {
     parentClass.AddAutoImplementedProperty(this.GetPropertyType(navigationProperty, CodeGenerationTypeUsage.Declaration), navigationProperty.Name);
 }

        /// <summary>
        /// Adds scalar and complex properties to the generated type class.
        /// </summary>
        /// <param name="codeClass">The <see cref="CodeTypeDeclaration"/> to which to add the properties.</param>
        /// <param name="type">The <see cref="StructuralType"/> from which to find properties.</param>
        protected virtual void AddProperties(CodeTypeDeclaration codeClass, StructuralType type)
        {
            foreach (var prop in type.Properties)
            {
                CodeTypeReference propertyType = null;
                var genericPropertyTypeAnnotation = prop.Annotations.OfType<GenericPropertyTypeAnnotation>().FirstOrDefault();
                if (genericPropertyTypeAnnotation != null)
                {
                    propertyType = Code.TypeRef(genericPropertyTypeAnnotation.GenericTypeParameterName);
                }
                else
                {
                    propertyType = codeTypeReferenceResolver.Resolve(prop.PropertyType);
                }

                var codeProp = codeClass.AddAutoImplementedProperty(propertyType, prop.Name);

                ApplyPropertyAccessModifier(codeProp, prop.Annotations.OfType<PropertyAccessModifierAnnotation>().SingleOrDefault());

                if (prop.Annotations.Any(a => a is VirtualAnnotation))
                {
                    codeProp.SetVirtual();
                }

                if (prop.Annotations.Any(a => a is CodeAttributeAnnotation))
                {
                    this.AddCodeAttributeAnnotationAsCustomAttribute(codeProp, prop.Annotations.OfType<CodeAttributeAnnotation>());
                }
            }
        }

        /// <summary>
        /// Adds navigation properties to generated type class.
        /// </summary>
        /// <param name="codeClass">The <see cref="CodeTypeDeclaration"/> to which to add the navigation properties.</param>
        /// <param name="type">The <see cref="EntityType"/> from which to find navigation properties.</param>
        /// <param name="defaultConstructor">The <see cref="CodeConstructor"/>, used to initialize navigation properties to their default values.</param>
        /// <remarks>
        /// Because CodeDom only supports property-level attributes, the get access modifier will be used for the entire property
        /// </remarks>
        protected virtual void AddNavigationProperties(CodeTypeDeclaration codeClass, EntityType type, CodeConstructor defaultConstructor)
        {
            foreach (var prop in type.NavigationProperties)
            {
                string propTypeName = prop.ToAssociationEnd.EntityType.FullName;
                bool isVirtual = prop.Annotations.Any(a => a is VirtualAnnotation);

                CodeTypeReference propType;
                if (prop.ToAssociationEnd.Multiplicity == EndMultiplicity.Many)
                {
                    // Instantiate collection in constructor if it's not overrideable
                    if (!isVirtual)
                    {
                        var instantiateType = Code.GenericType("List", propTypeName);
                        defaultConstructor.Statements.Add(Code.This().Property(prop.Name).Assign(Code.New(instantiateType)));
                    }

                    propType = Code.GenericType("ICollection", propTypeName);
                }
                else
                {
                    propType = new CodeTypeReference(propTypeName);
                }

                var codeProp = codeClass.AddAutoImplementedProperty(propType, prop.Name);

                ApplyPropertyAccessModifier(codeProp, prop.Annotations.OfType<PropertyAccessModifierAnnotation>().SingleOrDefault());

                if (prop.Annotations.Any(a => a is CodeAttributeAnnotation))
                {
                    this.AddCodeAttributeAnnotationAsCustomAttribute(codeProp, prop.Annotations.OfType<CodeAttributeAnnotation>());
                }

                if (isVirtual)
                {
                    codeProp.SetVirtual();
                }
            }
        }

        /// <summary>
        /// Generates and adds stream related attributes and elements to the entity type
        /// </summary>
        /// <param name="entityType">The entity type's metadata</param>
        /// <param name="entityTypeClass">The entity types declaration</param>
        protected override void GenerateHasStreamEntityTypeCodeElements(EntityType entityType, CodeTypeDeclaration entityTypeClass)
        {
            ExceptionUtilities.Assert(entityType.HasStream(), "This method should not be called for entity types without stream.");
            
            ClientMediaEntryAnnotation clientMediaEntryAnnotation = entityType.Annotations.OfType<ClientMediaEntryAnnotation>().FirstOrDefault();
            if (clientMediaEntryAnnotation != null)
            {
                // generate MediaEntry and MimeTypeProperty properties and attributes for V1 style stream support
                var attributeArguments1 = new CodeAttributeArgument[]
                {
                    new CodeAttributeArgument(Code.Primitive(clientMediaEntryAnnotation.MediaEntryName)),
                };
                var attributeArguments2 = new CodeAttributeArgument[]
                {
                    new CodeAttributeArgument(Code.Primitive(clientMediaEntryAnnotation.MediaEntryName)),
                    new CodeAttributeArgument(Code.Primitive(clientMediaEntryAnnotation.MimeTypePropertyName))
                };

                entityTypeClass.AddCustomAttribute(Code.TypeRef("MediaEntry"), attributeArguments1);
                entityTypeClass.AddCustomAttribute(Code.TypeRef("MimeTypeProperty"), attributeArguments2);
                entityTypeClass.AddAutoImplementedProperty(Code.TypeRef<byte[]>(), clientMediaEntryAnnotation.MediaEntryName);
                entityTypeClass.AddAutoImplementedProperty(Code.TypeRef<string>(), clientMediaEntryAnnotation.MimeTypePropertyName);
            }
            else
            {
                // No ClientMediaEntryAnnotation is found, generate HasStream atttribute for V2 and up stream support
                entityTypeClass.AddCustomAttribute(Code.TypeRef("HasStream"));
            }
        }

 /// <summary>
 /// Adds a named stream property to the given type declaration based on the given metadata
 /// </summary>
 /// <param name="namedStreamProperty">The named stream property's metadata</param>
 /// <param name="parentClass">The type declaration</param>
 protected override void DeclareNamedStreamProperty(MemberProperty namedStreamProperty, CodeTypeDeclaration parentClass)
 {
     parentClass.AddAutoImplementedProperty(Code.TypeRef("Microsoft.OData.Client.DataServiceStreamLink"), namedStreamProperty.Name);
 }