private static CodeAttributeDeclaration CodeForNameIndexAttribute(Type type, string name, int index) { CodeTypeReference indexAttributeType = new CodeTypeReference(type); CodeAttributeArgument nameAttribute = new CodeAttributeArgument(new CodePrimitiveExpression(name)); CodeAttributeArgument indexAttribute = new CodeAttributeArgument(new CodePrimitiveExpression(index)); return new CodeAttributeDeclaration(indexAttributeType, nameAttribute, indexAttribute); }
protected override void GenerateClassAttributes() { base.GenerateClassAttributes(); if ((base._sourceDataClass != null) && (this.Parser.OutputCacheParameters != null)) { OutputCacheParameters outputCacheParameters = this.Parser.OutputCacheParameters; if (outputCacheParameters.Duration > 0) { CodeAttributeDeclaration declaration = new CodeAttributeDeclaration("System.Web.UI.PartialCachingAttribute"); CodeAttributeArgument argument = new CodeAttributeArgument(new CodePrimitiveExpression(outputCacheParameters.Duration)); declaration.Arguments.Add(argument); argument = new CodeAttributeArgument(new CodePrimitiveExpression(outputCacheParameters.VaryByParam)); declaration.Arguments.Add(argument); argument = new CodeAttributeArgument(new CodePrimitiveExpression(outputCacheParameters.VaryByControl)); declaration.Arguments.Add(argument); argument = new CodeAttributeArgument(new CodePrimitiveExpression(outputCacheParameters.VaryByCustom)); declaration.Arguments.Add(argument); argument = new CodeAttributeArgument(new CodePrimitiveExpression(outputCacheParameters.SqlDependency)); declaration.Arguments.Add(argument); argument = new CodeAttributeArgument(new CodePrimitiveExpression(this.Parser.FSharedPartialCaching)); declaration.Arguments.Add(argument); if (MultiTargetingUtil.IsTargetFramework40OrAbove) { argument = new CodeAttributeArgument("ProviderName", new CodePrimitiveExpression(this.Parser.Provider)); declaration.Arguments.Add(argument); } base._sourceDataClass.CustomAttributes.Add(declaration); } } }
public void DefaultConstructor () { CodeAttributeArgument caa = new CodeAttributeArgument (); Assert.IsNotNull (caa.Name, "#1"); Assert.AreEqual (string.Empty, caa.Name, "#2"); Assert.IsNull (caa.Value, "#3"); }
public DynaAttributeDeclaration(string AttributeName, object[] AttributeArguements) { CodeAttributeArgument[] caa = new CodeAttributeArgument[AttributeArguements.Length]; for (int i = 0; i < caa.Length; i++) caa[i] = new CodeAttributeArgument(new CodePrimitiveExpression(AttributeArguements[i])); cad = new CodeAttributeDeclaration(AttributeName, caa); }
/* * Add metadata attributes to the class */ protected override void GenerateClassAttributes() { base.GenerateClassAttributes(); // If the user control has an OutputCache directive, generate // an attribute with the information about it. if (_sourceDataClass != null && Parser.OutputCacheParameters != null) { OutputCacheParameters cacheSettings = Parser.OutputCacheParameters; if (cacheSettings.Duration > 0) { CodeAttributeDeclaration attribDecl = new CodeAttributeDeclaration( "System.Web.UI.PartialCachingAttribute"); CodeAttributeArgument attribArg = new CodeAttributeArgument( new CodePrimitiveExpression(cacheSettings.Duration)); attribDecl.Arguments.Add(attribArg); attribArg = new CodeAttributeArgument(new CodePrimitiveExpression(cacheSettings.VaryByParam)); attribDecl.Arguments.Add(attribArg); attribArg = new CodeAttributeArgument(new CodePrimitiveExpression(cacheSettings.VaryByControl)); attribDecl.Arguments.Add(attribArg); attribArg = new CodeAttributeArgument(new CodePrimitiveExpression(cacheSettings.VaryByCustom)); attribDecl.Arguments.Add(attribArg); attribArg = new CodeAttributeArgument(new CodePrimitiveExpression(cacheSettings.SqlDependency)); attribDecl.Arguments.Add(attribArg); attribArg = new CodeAttributeArgument(new CodePrimitiveExpression(Parser.FSharedPartialCaching)); attribDecl.Arguments.Add(attribArg); // Use the providerName argument only when targeting 4.0 and above. if (MultiTargetingUtil.IsTargetFramework40OrAbove) { attribArg = new CodeAttributeArgument("ProviderName", new CodePrimitiveExpression(Parser.Provider)); attribDecl.Arguments.Add(attribArg); } _sourceDataClass.CustomAttributes.Add(attribDecl); } } }
public void Constructor1_NullItem () { CodeAttributeArgument[] arguments = new CodeAttributeArgument[] { new CodeAttributeArgument (), null }; CodeAttributeArgumentCollection coll = new CodeAttributeArgumentCollection ( arguments); }
/// <devdoc> /// <para>Copies the elements of an array to the end of the <see cref='System.CodeDom.CodeAttributeArgumentCollection'/>.</para> /// </devdoc> public void AddRange(CodeAttributeArgument[] value) { if (value == null) { throw new ArgumentNullException("value"); } for (int i = 0; ((i) < (value.Length)); i = ((i) + (1))) { this.Add(value[i]); } }
public static CodeAttributeArgument Clone(this CodeAttributeArgument argument) { if (argument == null) return null; CodeAttributeArgument a = new CodeAttributeArgument(); a.Name = argument.Name; a.Value = argument.Value.Clone(); return a; }
public void Constructor0_Deny_Unrestricted () { CodeAttributeArgument caa = new CodeAttributeArgument (); Assert.AreEqual (String.Empty, caa.Name, "Name"); caa.Name = null; Assert.IsNull (caa.Value, "Value"); caa.Value = new CodeExpression (); }
public void Constructor2_Deny_Unrestricted () { CodeExpression value = new CodeExpression (); CodeAttributeArgument caa = new CodeAttributeArgument ("mono", value); Assert.AreEqual ("mono", caa.Name, "Name"); caa.Name = String.Empty; Assert.AreSame (value, caa.Value, "Value"); caa.Value = new CodeExpression (); }
public void AddAttribute(CodeTypeMember member, string attributeType, string expression = null) { // Add [attributeType(expression)] var argument = new CodeAttributeArgument(new CodeSnippetExpression(expression)); var attribute = new CodeAttributeDeclaration(attributeType, argument); member.CustomAttributes.Add(attribute); }
public void Constructor2_Deny_Unrestricted () { CodeAttributeArgument[] args = new CodeAttributeArgument[1] { new CodeAttributeArgument () }; CodeAttributeDeclaration cad = new CodeAttributeDeclaration ("mono", args); Assert.AreEqual (1, cad.Arguments.Count, "Arguments"); Assert.AreEqual ("mono", cad.Name, "Name"); cad.Name = null; Assert.AreEqual ("System.Void", cad.AttributeType.BaseType, "AttributeType.BaseType"); }
private static void AddXmlEnumAttribute(CodeTypeMember member) { CodeTypeReference attributeType = new CodeTypeReference(typeof (XmlEnumAttribute)); CodePrimitiveExpression argumentValue = new CodePrimitiveExpression(member.Name); CodeAttributeArgument argument = new CodeAttributeArgument(argumentValue); CodeAttributeDeclaration attribute = new CodeAttributeDeclaration(attributeType, argument); member.CustomAttributes.Add(attribute); }
internal static void AddCustomAttribute(CodeTypeDeclaration type, string AttributeName, string ArgumentName, object ArgumentValue) { CodeAttributeDeclaration cad = new CodeAttributeDeclaration(AttributeName); CodeAttributeArgument cadarg = new CodeAttributeArgument(); if (ArgumentName != String.Empty) cadarg.Name = ArgumentName; cadarg.Value = new CodePrimitiveExpression(ArgumentValue); cad.Arguments.Add(cadarg); type.CustomAttributes.Add(cad); }
public void AddRange (CodeAttributeArgument [] value ) { if (value == null) { throw new ArgumentNullException ("value"); } for (int i = 0; i < value.Length; i++) { Add (value[i]); } }
private static void AddRootElementName(CodeTypeMember type) { foreach (CodeAttributeDeclaration attribute in type.CustomAttributes) if (attribute.Name == typeof (XmlRootAttribute).FullName) { CodePrimitiveExpression value = new CodePrimitiveExpression(type.Name); CodeAttributeArgument argument = new CodeAttributeArgument("", value); attribute.Arguments.Insert(0, argument); } }
private static void AddGeneratedCodeAttributeforMember(CodeTypeMember typeMember) { CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(new CodeTypeReference(typeof(GeneratedCodeAttribute))) { AttributeType = { Options = CodeTypeReferenceOptions.GlobalReference } }; CodeAttributeArgument argument = new CodeAttributeArgument(new CodePrimitiveExpression(typeof(StronglyTypedResourceBuilder).FullName)); CodeAttributeArgument argument2 = new CodeAttributeArgument(new CodePrimitiveExpression("4.0.0.0")); declaration.Arguments.Add(argument); declaration.Arguments.Add(argument2); typeMember.CustomAttributes.Add(declaration); }
public void NullName () { CodeAttributeArgument caa = new CodeAttributeArgument ((string) null, (CodeExpression) null); Assert.IsNotNull (caa.Name, "#1"); Assert.AreEqual (string.Empty, caa.Name, "#2"); Assert.IsNull (caa.Value, "#3"); caa.Name = null; Assert.IsNotNull (caa.Name, "#4"); Assert.AreEqual (string.Empty, caa.Name, "#5"); }
public void Constructor1 () { CodeAttributeArgument caa1 = new CodeAttributeArgument (); CodeAttributeArgument caa2 = new CodeAttributeArgument (); CodeAttributeArgument[] arguments = new CodeAttributeArgument[] { caa1, caa2 }; CodeAttributeArgumentCollection coll = new CodeAttributeArgumentCollection ( arguments); Assert.AreEqual (2, coll.Count, "#1"); Assert.AreEqual (0, coll.IndexOf (caa1), "#2"); Assert.AreEqual (1, coll.IndexOf (caa2), "#3"); }
public void Constructor2 () { CodeAttributeArgument caa1 = new CodeAttributeArgument (); CodeAttributeArgument caa2 = new CodeAttributeArgument (); CodeAttributeArgumentCollection c = new CodeAttributeArgumentCollection (); c.Add (caa1); c.Add (caa2); CodeAttributeArgumentCollection coll = new CodeAttributeArgumentCollection (c); Assert.AreEqual (2, coll.Count, "#1"); Assert.AreEqual (0, coll.IndexOf (caa1), "#2"); Assert.AreEqual (1, coll.IndexOf (caa2), "#3"); }
public CodeCompileUnit GetCompileUnit(string className) { var codeGenerationHelper = new CodeGenerationHelper(); var compileUnit = codeGenerationHelper.GetCodeCompileUnit(nameSpace, className); var mapper = new DataTypeMapper(); var newType = compileUnit.Namespaces[0].Types[0]; var nameArgument = new CodeAttributeArgument("Name", new CodeSnippetExpression("\"" + className + "\" ")); var nameSpaceArgument = new CodeAttributeArgument("Namespace", new CodeSnippetExpression("\"\"")); newType.CustomAttributes = new CodeAttributeDeclarationCollection {new CodeAttributeDeclaration("DataContract", nameArgument, nameSpaceArgument)}; foreach (var column in table.Columns) { if(column.IsPrimaryKey) { if(appPrefs.IncludeHasMany) foreach (var foreignKeyTable in table.HasManyRelationships) { var fkEntityName = appPrefs.ClassNamePrefix + foreignKeyTable.Reference.MakeSingular().GetPreferenceFormattedText(appPrefs); newType.Members.Add(codeGenerationHelper.CreateAutoPropertyWithDataMemberAttribute("IList<" + fkEntityName + ">", foreignKeyTable.Reference.MakePlural().GetPreferenceFormattedText(appPrefs))); } var primaryKeyType = mapper.MapFromDBType(this.appPrefs.ServerType, column.DataType, column.DataLength, column.DataPrecision, column.DataScale); newType.Members.Add(codeGenerationHelper.CreateAutoPropertyWithDataMemberAttribute(primaryKeyType.Name, "Id")); continue; } if (column.IsForeignKey) { var fKey = column.ForeignKeyTableName; var typeName = appPrefs.ClassNamePrefix + fKey.MakeSingular().GetPreferenceFormattedText(appPrefs); var codeMemberProperty = codeGenerationHelper.CreateAutoPropertyWithDataMemberAttribute(typeName, fKey.MakeSingular().GetPreferenceFormattedText(appPrefs)); newType.Members.Add(codeMemberProperty); continue; } var propertyName = column.Name.GetPreferenceFormattedText(appPrefs); var mapFromDbType = mapper.MapFromDBType(this.appPrefs.ServerType, column.DataType, column.DataLength, column.DataPrecision, column.DataScale); newType.Members.Add(codeGenerationHelper.CreateAutoPropertyWithDataMemberAttribute(mapFromDbType.Name, propertyName)); } return compileUnit; }
static CodeMemberProperty CreateProperty(PropertyNameType nameType, string constantsClassName, string defaultValuesClassName) { CodeMemberProperty publicProp = new CodeMemberProperty(); publicProp.Name = nameType.propertyName; publicProp.Attributes = CodeDomHelperObjects.PublicFinal; publicProp.HasGet = true; publicProp.HasSet = true; publicProp.Type = new CodeTypeReference(nameType.propertyType); CodeAttributeDeclarationCollection attributes = new CodeAttributeDeclarationCollection(); CodeAttributeArgument arg1 = new CodeAttributeArgument( new CodeFieldReferenceExpression( new CodeTypeReferenceExpression(constantsClassName), nameType.propertyName)); CodeAttributeArgument arg2 = new CodeAttributeArgument( PropertyNameConstants.DefaultValueProperty, new CodeFieldReferenceExpression( new CodeTypeReferenceExpression(defaultValuesClassName), Constants.DefaultPrefix + nameType.propertyName)); // Future TODO: Provide a library with attributes that custom channel writes // can use to adorn their properties with default values and validators, we can // then add it here. attributes.Add(new CodeAttributeDeclaration( new CodeTypeReference(TypeNameConstants.ConfigurationProperty), arg1, arg2)); publicProp.CustomAttributes = new CodeAttributeDeclarationCollection(attributes); string nameInConfig = constantsClassName + "." + nameType.propertyName; CodeArrayIndexerExpression baseIndexedProperty = new CodeArrayIndexerExpression( CodeDomHelperObjects.BaseRef, new CodeFieldReferenceExpression( new CodeTypeReferenceExpression(constantsClassName), nameType.propertyName)); publicProp.GetStatements.Add(new CodeMethodReturnStatement( new CodeCastExpression( nameType.propertyType, baseIndexedProperty))); publicProp.SetStatements.Add(new CodeAssignStatement( baseIndexedProperty, new CodePropertySetValueReferenceExpression())); return publicProp; }
protected override void OutputAttributeArgument(CodeAttributeArgument arg) { if ((arg.Name != null) && (arg.Name.Length > 0)) { this.OutputIdentifier(arg.Name); base.Output.Write(":="); } ((ICodeGenerator)this).GenerateCodeFromExpression(arg.Value, ((IndentedTextWriter)base.Output).InnerWriter, base.Options); }
public int Add(CodeAttributeArgument value) => List.Add(value);
// // Methods // public int Add (CodeAttributeArgument value) { return List.Add( value ); }
public CodeAttributeArgumentCollection( CodeAttributeArgument[] value ) { AddRange( value ); }
public bool Contains(CodeAttributeArgument value) { throw new NotImplementedException(); }
public int IndexOf(CodeAttributeArgument value) { throw new NotImplementedException(); }
/// <include file='doc\CodeAttributeArgumentCollection.uex' path='docs/doc[@for="CodeAttributeArgumentCollection.Remove"]/*' /> /// <devdoc> /// <para> Removes a specific <see cref='System.CodeDom.CodeAttributeArgument'/> from the /// <see cref='System.CodeDom.CodeAttributeArgumentCollection'/> .</para> /// </devdoc> public void Remove(CodeAttributeArgument value) { List.Remove(value); }
public int IndexOf(CodeAttributeArgument value) => List.IndexOf(value);
/// <summary> /// Generates the code to store the views in a C# or a VB file based on the /// options passed in by the user. /// </summary> /// <param name="mappingCollection"></param> /// <param name="generatedViews"></param> /// <param name="sourceWriter"></param> /// <param name="provider"></param> /// <returns></returns> private static void GenerateAndStoreViews(StorageMappingItemCollection mappingCollection, Dictionary<EntitySetBase, string> generatedViews, TextWriter sourceWriter, CodeDomProvider provider, IList<EdmSchemaError> schemaErrors) { EdmItemCollection edmCollection = mappingCollection.EdmItemCollection; StoreItemCollection storeCollection = mappingCollection.StoreItemCollection; //Create an emtpty compile unit and build up the generated code CodeCompileUnit compileUnit = new CodeCompileUnit(); //Add the namespace for generated code CodeNamespace codeNamespace = new CodeNamespace(EntityViewGenerationConstants.NamespaceName); //Add copyright notice to the namespace comment. compileUnit.Namespaces.Add(codeNamespace); foreach (var storageEntityContainerMapping in mappingCollection.GetItems<StorageEntityContainerMapping>()) { //Throw warning when containerMapping contains query view for bug 547285. if (HasQueryView(storageEntityContainerMapping)) { schemaErrors.Add(new EdmSchemaError( Strings.UnsupportedQueryViewInEntityContainerMapping(storageEntityContainerMapping.Identity), (int)StorageMappingErrorCode.UnsupportedQueryViewInEntityContainerMapping, EdmSchemaErrorSeverity.Warning)); continue; } #region Class Declaration string edmContainerName = storageEntityContainerMapping.EdmEntityContainer.Name; string storeContainerName = storageEntityContainerMapping.StorageEntityContainer.Name; string hashOverMappingClosure = MetadataMappingHasherVisitor.GetMappingClosureHash(edmCollection.EdmVersion, storageEntityContainerMapping); StringBuilder inputForTypeNameContent = new StringBuilder(hashOverMappingClosure); string viewStorageTypeName = EntityViewGenerationConstants.ViewGenerationTypeNamePrefix + StringHashBuilder.ComputeHash(MetadataHelper.CreateMetadataHashAlgorithm(edmCollection.EdmVersion), inputForTypeNameContent.ToString()).ToUpperInvariant(); //Add typeof expression to get the type that contains ViewGen type. This will help us in avoiding to go through //all the types in the assembly. I have also verified that this works with VB with a root namespace prepended to the //namespace since VB is picking up the type correctly as long as it is in the same assembly even with out the root namespace. CodeTypeOfExpression viewGenTypeOfExpression = new CodeTypeOfExpression(EntityViewGenerationConstants.NamespaceName + "." + viewStorageTypeName); //Add the assembly attribute that marks the assembly as the one that contains the generated views CodeAttributeDeclaration viewGenAttribute = new CodeAttributeDeclaration(EntityViewGenerationConstants.ViewGenerationCustomAttributeName); CodeAttributeArgument viewGenTypeArgument = new CodeAttributeArgument(viewGenTypeOfExpression); viewGenAttribute.Arguments.Add(viewGenTypeArgument); compileUnit.AssemblyCustomAttributes.Add(viewGenAttribute); //Add the type which will be the class that contains all the views in this assembly CodeTypeDeclaration viewStoringType = CreateTypeForStoringViews(viewStorageTypeName); //Add the constructor, this will be the only method that this type will contain //Create empty constructor. CodeConstructor viewStoringTypeConstructor = CreateConstructorForViewStoringType(); viewStoringType.Attributes = MemberAttributes.Public; //Get an expression that expresses this instance CodeThisReferenceExpression thisRef = new CodeThisReferenceExpression(); string viewHash = MetadataHelper.GenerateHashForAllExtentViewsContent(edmCollection.EdmVersion, GenerateDictionaryForEntitySetNameAndView(generatedViews)); CodeAssignStatement EdmEntityContainerNameStatement = new CodeAssignStatement( new CodeFieldReferenceExpression(thisRef, EntityViewGenerationConstants.EdmEntityContainerName), new CodePrimitiveExpression(edmContainerName)); CodeAssignStatement StoreEntityContainerNameStatement = new CodeAssignStatement( new CodeFieldReferenceExpression(thisRef, EntityViewGenerationConstants.StoreEntityContainerName), new CodePrimitiveExpression(storeContainerName)); CodeAssignStatement HashOverMappingClosureStatement = new CodeAssignStatement( new CodeFieldReferenceExpression(thisRef, EntityViewGenerationConstants.HashOverMappingClosure), new CodePrimitiveExpression(hashOverMappingClosure)); CodeAssignStatement HashOverAllExtentViewsStatement = new CodeAssignStatement( new CodeFieldReferenceExpression(thisRef, EntityViewGenerationConstants.HashOverAllExtentViews), new CodePrimitiveExpression(viewHash)); CodeAssignStatement ViewCountStatement = new CodeAssignStatement( new CodeFieldReferenceExpression(thisRef, EntityViewGenerationConstants.ViewCountPropertyName), new CodePrimitiveExpression(generatedViews.Count)); viewStoringTypeConstructor.Statements.Add(EdmEntityContainerNameStatement); viewStoringTypeConstructor.Statements.Add(StoreEntityContainerNameStatement); viewStoringTypeConstructor.Statements.Add(HashOverMappingClosureStatement); viewStoringTypeConstructor.Statements.Add(HashOverAllExtentViewsStatement); viewStoringTypeConstructor.Statements.Add(ViewCountStatement); //Add the constructor to the type viewStoringType.Members.Add(viewStoringTypeConstructor); //Add the method to store views to the type CreateAndAddGetViewAtMethod(viewStoringType, generatedViews); //Add the type to the namespace codeNamespace.Types.Add(viewStoringType); #endregion } if (codeNamespace.Types.Count > 0) { GenerateCode(sourceWriter, provider, compileUnit); sourceWriter.Flush(); } }
public override CodeTypeDeclaration Generate() { var classDeclaration = base.Generate(); GenerateSerializableAttribute(classDeclaration); GenerateTypeAttribute(classDeclaration); classDeclaration.IsClass = true; classDeclaration.IsPartial = true; if (EnableDataBinding) { classDeclaration.Members.Add(new CodeMemberEvent() { Name = "PropertyChanged", Type = new CodeTypeReference("PropertyChangedEventHandler"), Attributes = MemberAttributes.Public, }); var onPropChangedMethod = new CodeMemberMethod { Name = "OnPropertyChanged", Attributes = MemberAttributes.Family, }; var param = new CodeParameterDeclarationExpression(typeof(string), "propertyName"); onPropChangedMethod.Parameters.Add(param); onPropChangedMethod.Statements.Add( new CodeConditionStatement( new CodeBinaryOperatorExpression( new CodeEventReferenceExpression(null, "PropertyChanged"), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)), new CodeExpressionStatement(new CodeDelegateInvokeExpression( new CodeEventReferenceExpression(null, "PropertyChanged"), new CodeThisReferenceExpression(), new CodeObjectCreateExpression( "PropertyChangedEventArgs", new CodeArgumentReferenceExpression("propertyName")) )))); classDeclaration.Members.Add(onPropChangedMethod); } if (BaseClass != null) { if (BaseClass is ClassModel) classDeclaration.BaseTypes.Add(BaseClass.GetReferenceFor(Namespace, false)); else { var typeReference = BaseClass.GetReferenceFor(Namespace, false); var member = new CodeMemberField(typeReference, "Value") { Attributes = MemberAttributes.Public, }; if (EnableDataBinding) { var backingFieldMember = new CodeMemberField(typeReference, member.Name.ToBackingField()) { Attributes = MemberAttributes.Private }; member.Name += PropertyModel.GetAccessors(member.Name, backingFieldMember.Name, BaseClass.GetPropertyValueTypeCode(), false); classDeclaration.Members.Add(backingFieldMember); } else { // hack to generate automatic property member.Name += " { get; set; }"; } var docs = new[] { new DocumentationModel { Language = "en", Text = "Gets or sets the text value." }, new DocumentationModel { Language = "de", Text = "Ruft den Text ab oder legt diesen fest." } }; member.Comments.AddRange(DocumentationModel.GetComments(docs).ToArray()); var attribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(XmlTextAttribute))); var simpleModel = BaseClass as SimpleModel; if (simpleModel != null && (simpleModel.XmlSchemaType.IsDataTypeAttributeAllowed(Configuration) ?? simpleModel.UseDataTypeAttribute)) { var name = BaseClass.GetQualifiedName(); if (name.Namespace == XmlSchema.Namespace) { var dataType = new CodeAttributeArgument("DataType", new CodePrimitiveExpression(name.Name)); attribute.Arguments.Add(dataType); } } member.CustomAttributes.Add(attribute); classDeclaration.Members.Add(member); } } if (EnableDataBinding) classDeclaration.BaseTypes.Add(new CodeTypeReference("INotifyPropertyChanged")); if (Configuration.EntityFramework && (BaseClass == null || !(BaseClass is ClassModel))) { // generate key var keyProperty = Properties.FirstOrDefault(p => p.Name.ToLowerInvariant() == "id") ?? Properties.FirstOrDefault(p => p.Name.ToLowerInvariant() == (Name.ToLowerInvariant() + "id")); if (keyProperty == null) { keyProperty = new PropertyModel(Configuration) { Name = "Id", Type = new SimpleModel(Configuration) { ValueType = typeof(long) }, OwningType = this, Documentation = { new DocumentationModel { Language = "en", Text = "Gets or sets a value uniquely identifying this entity." }, new DocumentationModel { Language = "de", Text = "Ruft einen Wert ab, der diese Entität eindeutig identifiziert, oder legt diesen fest." } } }; Properties.Insert(0, keyProperty); } keyProperty.IsKey = true; } foreach (var property in Properties) property.AddMembersTo(classDeclaration, EnableDataBinding); if (IsMixed && (BaseClass == null || BaseClass is ClassModel)) { var text = new CodeMemberField(typeof(string), "Text"); // hack to generate automatic property text.Name += " { get; set; }"; text.Attributes = MemberAttributes.Public; var xmlTextAttribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(XmlTextAttribute))); text.CustomAttributes.Add(xmlTextAttribute); classDeclaration.Members.Add(text); } classDeclaration.CustomAttributes.Add( new CodeAttributeDeclaration(new CodeTypeReference(typeof(DebuggerStepThroughAttribute)))); if (Configuration.GenerateDesignerCategoryAttribute) { classDeclaration.CustomAttributes.Add( new CodeAttributeDeclaration(new CodeTypeReference(typeof (DesignerCategoryAttribute)), new CodeAttributeArgument(new CodePrimitiveExpression("code")))); } if (RootElementName != null) { var rootAttribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(XmlRootAttribute)), new CodeAttributeArgument(new CodePrimitiveExpression(RootElementName.Name)), new CodeAttributeArgument("Namespace", new CodePrimitiveExpression(RootElementName.Namespace))); classDeclaration.CustomAttributes.Add(rootAttribute); } var derivedTypes = GetAllDerivedTypes(); foreach (var derivedType in derivedTypes.OrderBy(t => t.Name)) { var includeAttribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(XmlIncludeAttribute)), new CodeAttributeArgument(new CodeTypeOfExpression(derivedType.GetReferenceFor(Namespace, false)))); classDeclaration.CustomAttributes.Add(includeAttribute); } classDeclaration.BaseTypes.AddRange(Interfaces.Select(i => i.GetReferenceFor(Namespace, false)).ToArray()); return classDeclaration; }
/// <include file='doc\CodeAttributeArgumentCollection.uex' path='docs/doc[@for="CodeAttributeArgumentCollection.Contains"]/*' /> /// <devdoc> /// <para>Gets a value indicating whether the /// <see cref='System.CodeDom.CodeAttributeArgumentCollection'/> contains the specified <see cref='System.CodeDom.CodeAttributeArgument'/>.</para> /// </devdoc> public bool Contains(CodeAttributeArgument value) { return(List.Contains(value)); }
public void Remove(CodeAttributeArgument value) { throw new NotImplementedException(); }
/// <include file='doc\CodeAttributeArgumentCollection.uex' path='docs/doc[@for="CodeAttributeArgumentCollection.Add"]/*' /> /// <devdoc> /// <para>Adds a <see cref='System.CodeDom.CodeAttributeArgument'/> with the specified value to the /// <see cref='System.CodeDom.CodeAttributeArgumentCollection'/> .</para> /// </devdoc> public int Add(CodeAttributeArgument value) { return(List.Add(value)); }
private static void AddEditorBrowsableAttribute(CodeTypeMember ctmTarget) { CodeFieldReferenceExpression cfre = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(EditorBrowsableState)), "Never"); CodeAttributeArgument caa = new CodeAttributeArgument(cfre); ctmTarget.CustomAttributes.Add(new CodeAttributeDeclaration(typeof(EditorBrowsableAttribute).FullName, caa)); }
private CodeAttributeDeclaration GetAttribute(bool isArray) { CodeAttributeDeclaration attribute; if (IsKey && XmlSchemaName == null) { attribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(XmlIgnoreAttribute))); return attribute; } if (IsAttribute) { if (IsAny) { attribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(XmlAnyAttributeAttribute))); } else { attribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(XmlAttributeAttribute)), new CodeAttributeArgument(new CodePrimitiveExpression(XmlSchemaName.Name))); } } else if (!isArray) { if (IsAny) { attribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(XmlAnyElementAttribute))); } else { attribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(XmlElementAttribute)), new CodeAttributeArgument(new CodePrimitiveExpression(XmlSchemaName.Name))); if (Order != null) attribute.Arguments.Add(new CodeAttributeArgument("Order", new CodePrimitiveExpression(Order.Value))); } } else { attribute = new CodeAttributeDeclaration(new CodeTypeReference(typeof(XmlArrayAttribute)), new CodeAttributeArgument(new CodePrimitiveExpression(XmlSchemaName.Name))); } if (Form == XmlSchemaForm.Qualified) { attribute.Arguments.Add(new CodeAttributeArgument("Namespace", new CodePrimitiveExpression(OwningType.XmlSchemaName.Namespace))); } else if (XmlNamespace != null) { attribute.Arguments.Add(new CodeAttributeArgument("Namespace", new CodePrimitiveExpression(XmlNamespace))); } else if (!IsAny) { attribute.Arguments.Add(new CodeAttributeArgument("Form", new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(new CodeTypeReference(typeof(XmlSchemaForm))), "Unqualified"))); } if (IsNillable) attribute.Arguments.Add(new CodeAttributeArgument("IsNullable", new CodePrimitiveExpression(true))); var simpleModel = Type as SimpleModel; if (simpleModel != null && simpleModel.UseDataTypeAttribute) { var name = Type.XmlSchemaType.GetQualifiedName(); if (name.Namespace == XmlSchema.Namespace) { var dataType = new CodeAttributeArgument("DataType", new CodePrimitiveExpression(name.Name)); attribute.Arguments.Add(dataType); } } return attribute; }
/// <include file='doc\CodeAttributeArgumentCollection.uex' path='docs/doc[@for="CodeAttributeArgumentCollection.IndexOf"]/*' /> /// <devdoc> /// <para>Returns the index of a <see cref='System.CodeDom.CodeAttributeArgument'/> in /// the <see cref='System.CodeDom.CodeAttributeArgumentCollection'/> .</para> /// </devdoc> public int IndexOf(CodeAttributeArgument value) { return(List.IndexOf(value)); }
internal static CodeAttributeDeclaration AddAttribute(CodeAttributeDeclarationCollection col, CodeTypeReference type, CodeExpression[] arguments) { CodeAttributeArgument[] attributeArguments = new CodeAttributeArgument[arguments.Length]; for (int i = 0; i < arguments.Length; i++) { attributeArguments[i] = new CodeAttributeArgument(arguments[i]); } CodeAttributeDeclaration cad = new CodeAttributeDeclaration(type, attributeArguments); col.Add(cad); return cad; }
public void Insert(int index, CodeAttributeArgument value) { throw new NotImplementedException(); }
/// <include file='doc\CodeAttributeArgumentCollection.uex' path='docs/doc[@for="CodeAttributeArgumentCollection.Insert"]/*' /> /// <devdoc> /// <para>Inserts a <see cref='System.CodeDom.CodeAttributeArgument'/> into the <see cref='System.CodeDom.CodeAttributeArgumentCollection'/> at the specified index.</para> /// </devdoc> public void Insert(int index, CodeAttributeArgument value) { List.Insert(index, value); }
public bool Contains(CodeAttributeArgument value) => List.Contains(value);