public CodeExpression[] Generate(Table table, HardwireCodeGenerationContext generatorContext, CodeTypeMemberCollection members) { string className = "AIDX_" + Guid.NewGuid().ToString("N"); string name = table.Get("name").String; bool setter = table.Get("setter").Boolean; CodeTypeDeclaration classCode = new CodeTypeDeclaration(className); classCode.TypeAttributes = System.Reflection.TypeAttributes.NestedPrivate | System.Reflection.TypeAttributes.Sealed; classCode.BaseTypes.Add(typeof(ArrayMemberDescriptor)); CodeConstructor ctor = new CodeConstructor(); ctor.Attributes = MemberAttributes.Assembly; classCode.Members.Add(ctor); ctor.BaseConstructorArgs.Add(new CodePrimitiveExpression(name)); ctor.BaseConstructorArgs.Add(new CodePrimitiveExpression(setter)); DynValue vparams = table.Get("params"); if (vparams.Type == DataType.Table) { List<HardwireParameterDescriptor> paramDescs = HardwireParameterDescriptor.LoadDescriptorsFromTable(vparams.Table); ctor.BaseConstructorArgs.Add(new CodeArrayCreateExpression(typeof(ParameterDescriptor), paramDescs.Select(e => e.Expression).ToArray())); } members.Add(classCode); return new CodeExpression[] { new CodeObjectCreateExpression(className) }; }
public CodeTypeDeclaration(string name) { this.attributes = System.Reflection.TypeAttributes.Public; this.baseTypes = new CodeTypeReferenceCollection(); this.members = new CodeTypeMemberCollection(); base.Name = name; }
public void Constructor1_NullItem () { CodeTypeMember[] typeMembers = new CodeTypeMember[] { new CodeTypeMember (), null }; CodeTypeMemberCollection coll = new CodeTypeMemberCollection ( typeMembers); }
internal static void AddCallbackDeclaration(CodeTypeMemberCollection members, string callbackMember) { CodeMemberField field = new CodeMemberField { Type = new CodeTypeReference(typeof(SendOrPostCallback)), Name = callbackMember }; members.Add(field); }
public CodeDomArg(CodeExpression codeExpression, IScopeData scope) { MethodIdentifier = Guid.NewGuid().ToString("N"); CodeExpression = codeExpression; Scope = scope; ParentMemberDefinitions = new CodeTypeMemberCollection(); ParentStatements = new CodeStatementCollection(); }
public void Constructor0 () { CodeTypeMemberCollection coll = new CodeTypeMemberCollection (); Assert.IsFalse (((IList) coll).IsFixedSize, "#1"); Assert.IsFalse (((IList) coll).IsReadOnly, "#2"); Assert.AreEqual (0, coll.Count, "#3"); Assert.IsFalse (((ICollection) coll).IsSynchronized, "#4"); Assert.IsNotNull (((ICollection) coll).SyncRoot, "#5"); }
/// <summary> /// Asserts that the specified type contains a member with the given name /// </summary> private void AssertContainsName(CodeTypeMemberCollection coll, string name) { foreach (CodeTypeMember member in coll) { if (name == member.Name) { return; } } Assert.Fail("Failed to find [" + name + "] in CodeTypeMembers"); }
public void AddRange(CodeTypeMemberCollection value) { if (value == null) { throw new ArgumentNullException("value"); } int count = value.Count; for (int i = 0; i < count; i++) { this.Add(value[i]); } }
public CodeExpression[] Generate(Table table, HardwireCodeGenerationContext generatorContext, CodeTypeMemberCollection members) { string className = "DVAL_" + Guid.NewGuid().ToString("N"); DynValue kval = table.Get("value"); DynValue vtype = table.Get("type"); DynValue vstaticType = table.Get("staticType"); string type = (vtype.Type == DataType.String) ? vtype.String : null; string staticType = (vstaticType.Type == DataType.String) ? vstaticType.String : null; CodeTypeDeclaration classCode = new CodeTypeDeclaration(className); classCode.TypeAttributes = System.Reflection.TypeAttributes.NestedPrivate | System.Reflection.TypeAttributes.Sealed; classCode.BaseTypes.Add(typeof(DynValueMemberDescriptor)); CodeConstructor ctor = new CodeConstructor(); ctor.Attributes = MemberAttributes.Assembly; classCode.Members.Add(ctor); if (type == null) { Table tbl = new Table(null); tbl.Set(1, kval); string str = tbl.Serialize(); ctor.BaseConstructorArgs.Add(new CodePrimitiveExpression(table.Get("name").String)); ctor.BaseConstructorArgs.Add(new CodePrimitiveExpression(str)); } else if (type == "userdata") { ctor.BaseConstructorArgs.Add(new CodePrimitiveExpression(table.Get("name").String)); CodeMemberProperty p = new CodeMemberProperty(); p.Name = "Value"; p.Type = new CodeTypeReference(typeof(DynValue)); p.Attributes = MemberAttributes.Override | MemberAttributes.Public; p.GetStatements.Add( new CodeMethodReturnStatement( new CodeMethodInvokeExpression( new CodeTypeReferenceExpression(typeof(UserData)), "CreateStatic", new CodeTypeOfExpression(staticType)))); classCode.Members.Add(p); } members.Add(classCode); return new CodeExpression[] { new CodeObjectCreateExpression(className) }; }
protected override void AddPageFields (CodeTypeMemberCollection members) { base.AddPageFields (members); executableField = new CodeMemberField { Name = "_Executable", Type = new CodeTypeReference(typeof(XQueryExecutable)), Attributes = MemberAttributes.Private | MemberAttributes.Static }; members.Add (executableField); }
public void Constructor1 () { CodeTypeMember tm1 = new CodeTypeMember (); CodeTypeMember tm2 = new CodeTypeMember (); CodeTypeMember[] typeMembers = new CodeTypeMember[] { tm1, tm2 }; CodeTypeMemberCollection coll = new CodeTypeMemberCollection ( typeMembers); Assert.AreEqual (2, coll.Count, "#1"); Assert.AreEqual (0, coll.IndexOf (tm1), "#2"); Assert.AreEqual (1, coll.IndexOf (tm2), "#3"); }
/// <include file='doc\CodeTypeMemberCollection.uex' path='docs/doc[@for="CodeTypeMemberCollection.AddRange1"]/*' /> /// <devdoc> /// <para> /// Adds the contents of another <see cref='System.CodeDom.CodeTypeMemberCollection'/> to the end of the collection. /// </para> /// </devdoc> public void AddRange(CodeTypeMemberCollection value) { if (value == null) { throw new ArgumentNullException("value"); } int currentCount = value.Count; for (int i = 0; i < currentCount; i = ((i) + (1))) { this.Add(value[i]); } }
public void Constructor1_Deny_Unrestricted () { CodeTypeMemberCollection coll = new CodeTypeMemberCollection (array); coll.CopyTo (array, 0); Assert.AreEqual (1, coll.Add (ctm), "Add"); Assert.AreSame (ctm, coll[0], "this[int]"); coll.AddRange (array); coll.AddRange (coll); Assert.IsTrue (coll.Contains (ctm), "Contains"); Assert.AreEqual (0, coll.IndexOf (ctm), "IndexOf"); coll.Insert (0, ctm); coll.Remove (ctm); }
public void AddRange(CodeTypeMemberCollection value) { if (value == null) { throw new ArgumentNullException(nameof(value)); } int currentCount = value.Count; for (int i = 0; i < currentCount; i++) { Add(value[i]); } }
public CodeExpression[] Generate(Table table, HardwireCodeGenerationContext generator, CodeTypeMemberCollection members) { string type = (string)table["$key"]; string className = "TYPE_" + Guid.NewGuid().ToString("N"); CodeTypeDeclaration classCode = new CodeTypeDeclaration(className); classCode.Comments.Add(new CodeCommentStatement("Descriptor of " + type)); classCode.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "Descriptor of " + type)); classCode.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); classCode.TypeAttributes = System.Reflection.TypeAttributes.NestedPrivate | System.Reflection.TypeAttributes.Sealed; classCode.BaseTypes.Add(typeof(HardwiredUserDataDescriptor)); CodeConstructor ctor = new CodeConstructor(); ctor.Attributes = MemberAttributes.Assembly; ctor.BaseConstructorArgs.Add(new CodeTypeOfExpression(type)); classCode.Members.Add(ctor); generator.DispatchTablePairs(table.Get("members").Table, classCode.Members, (key, exp) => { var mname = new CodePrimitiveExpression(key); ctor.Statements.Add(new CodeMethodInvokeExpression( new CodeThisReferenceExpression(), "AddMember", mname, exp)); }); generator.DispatchTablePairs(table.Get("metamembers").Table, classCode.Members, (key, exp) => { var mname = new CodePrimitiveExpression(key); ctor.Statements.Add(new CodeMethodInvokeExpression( new CodeThisReferenceExpression(), "AddMetaMember", mname, exp)); }); members.Add(classCode); return new CodeExpression[] { new CodeObjectCreateExpression(className) }; }
/// <summary> /// Generates the Request-classes for all methods in a resource. /// </summary> public CodeTypeMemberCollection GenerateRequestClasses(CodeTypeDeclaration resourceClass, IResource resource) { CodeTypeMemberCollection newMembers = new CodeTypeMemberCollection(); IList<string> usedNames = new List<string>(GeneratorUtils.GetUsedWordsFromMembers(resourceClass.Members)); foreach (IMethod method in resource.Methods.Values) { // Generate the request class and add it to the result collection. CodeTypeDeclaration requestClass = GenerateRequestClass(resource, method, resourceClass, usedNames); newMembers.Add(requestClass); usedNames.Add(requestClass.Name); } return newMembers; }
public void AddRange(CodeTypeMemberCollection value) { if (value == null) { throw new ArgumentNullException("value"); } int count = value.Count; for (int i = 0; i < count; i++) { Add(value[i]); } }
protected override void AddPageProperties(CodeTypeMemberCollection members) { base.AddPageProperties(members); var executableProperty = new CodeMemberProperty { Name = "Executable", Type = executableField.Type, Attributes = MemberAttributes.Public | MemberAttributes.Override, HasSet = false, HasGet = true, }; executableProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(PageTypeReferenceExpression, executableField.Name))); members.Add(executableProperty); }
public CodeExpression[] Generate(Table table, HardwireCodeGenerationContext generator, CodeTypeMemberCollection members) { MethodMemberDescriptorGenerator mgen = new MethodMemberDescriptorGenerator("VTDC"); Table mt = new Table(null); mt["params"] = new Table(null); mt["name"] = "__new"; mt["type"] = table["type"]; mt["ctor"] = true; mt["extension"] = false; mt["decltype"] = table["type"]; mt["ret"] = table["type"]; mt["special"] = false; return mgen.Generate(mt, generator, members); }
public CodeExpression[] Generate(Table table, HardwireCodeGenerationContext generator, CodeTypeMemberCollection members) { List<CodeExpression> initializers = new List<CodeExpression>(); generator.DispatchTablePairs(table.Get("overloads").Table, members, exp => { initializers.Add(exp); }); var name = new CodePrimitiveExpression((table["name"] as string)); var type = new CodeTypeOfExpression(table["decltype"] as string); var array = new CodeArrayCreateExpression(typeof(IOverloadableMemberDescriptor), initializers.ToArray()); return new CodeExpression[] { new CodeObjectCreateExpression(typeof(OverloadedMethodMemberDescriptor), name, type, array) }; }
protected override void AddPageFields (CodeTypeMemberCollection members) { base.AddPageFields (members); executableField = new CodeMemberField { Name = "_Executable", Type = new CodeTypeReference(typeof(XsltExecutable)), Attributes = MemberAttributes.Private | MemberAttributes.Static }; members.Add (executableField); if (parser.PageType == XsltPageType.AssociatedStylesheet) { initialContextNodeField = new CodeMemberField { Name = "_initialContextNode", Type = new CodeTypeReference(typeof(IXPathNavigable)), Attributes = MemberAttributes.Private | MemberAttributes.Static }; members.Add (initialContextNodeField); } }
public static string GenerateCodeFromMembers(CodeTypeMemberCollection collection) { var type = new CodeTypeDeclaration("DUMMY"); type.Members.AddRange(collection); var cp = new CSharpCodeProvider(); var sb = new StringBuilder(); var strWriter = new StringWriter(sb); var ccu = new CodeCompileUnit(); var ns = new CodeNamespace(); ns.Types.Add(type); ccu.Namespaces.Add(ns); cp.GenerateCodeFromCompileUnit(ccu, strWriter, new CodeGeneratorOptions()); var adjusted = new[] { "" }.Concat( sb.ToString() .Split(new string[] { Environment.NewLine }, StringSplitOptions.None) .Skip(14) .Reverse() .Skip(2) .Reverse()).ToArray(); return string.Join("\r\n", adjusted); }
public CodeTypeMemberCollection(CodeTypeMemberCollection value) { throw new NotImplementedException(); }
public CodeExpression[] Generate(Table table, HardwireCodeGenerationContext generator, CodeTypeMemberCollection members) { generator.Error("Missing code generator for '{0}'.", ManagedType); return new CodeExpression[0]; }
/// <summary> /// Iterates a CodeTypeMemberCollection and returns an array of indexes /// to members that are not marked with the IsAttribute custom attribute. /// </summary> /// <param name="typeMembers">A CodeTypeMemberCollection containing contract members.</param> /// <returns>A integer array containing the indexes of none attribute type members.</returns> /// <remarks>Skip AnyAttr data member because it is moved to the attribute processing order.</remarks> internal static int[] GetListOfMembers(CodeTypeMemberCollection typeMembers) { int[] tempList = new int[typeMembers.Count]; int index = 0; // Add members for (int i = 0; i < typeMembers.Count; ++i) { if (GetCustomAttributeArgumentValue("IsAttribute", typeMembers[i].CustomAttributes) == null) if (typeMembers[i].Name != "AnyAttr") tempList[index++] = i; } int[] sortOrder = new int[index]; Array.Copy(tempList, sortOrder, index); return sortOrder; }
/// <summary> /// Iterates a CodeTypeMemberCollection and returns an array of indexes /// to members that are marked with the IsAttribute custom attribute. /// </summary> /// <param name="typeMembers">A CodeTypeMemberCollection containing contract members.</param> /// <returns>A integer array containing the indexes of attribute type members.</returns> /// <remarks> /// Special provisiong are made to handle AnyAttribute. If an AnyAttr data member is found, /// the index will be moved to the end of the attribute list. This way attribute processing /// can occur before an the next data member element is read. /// </remarks> internal static int[] GetListOfAttributes(CodeTypeMemberCollection typeMembers) { int[] tempList = new int[typeMembers.Count]; int index = 0; int anyAttribIndex = -1; // Add attribute members for (int i = 0; i < typeMembers.Count; ++i) { if (GetCustomAttributeArgumentValue("IsAttribute", typeMembers[i].CustomAttributes) != null) tempList[index++] = i; else if (typeMembers[i].Name == "AnyAttr") anyAttribIndex = i; } int[] sortOrder; if (anyAttribIndex == -1) { sortOrder = new int[index]; Array.Copy(tempList, sortOrder, index); } else { sortOrder = new int[index + 1]; Array.Copy(tempList, sortOrder, index); sortOrder[index] = anyAttribIndex; } return sortOrder; }
/// <summary> /// Iterates a CodeTypeMemberCollection and returns an array of indexes /// representing the collection sorted by attributes and then data members. /// </summary> /// <param name="typeMembers">A CodeTypeMemberCollection containing the contract members to sort.</param> /// <returns>A integer array containing the indexes of members sorted by attributes first then data members.</returns> internal static int[] SortMemberTypes(CodeTypeMemberCollection typeMembers) { int[] attribList = GetListOfAttributes(typeMembers); int[] memberList = GetListOfMembers(typeMembers); int[] sortOrder = new int[typeMembers.Count]; Array.Copy(attribList, sortOrder, attribList.Length); Array.Copy(memberList, 0, sortOrder, attribList.Length, memberList.Length); return sortOrder; }
public CodeTypeMemberCollection ParseMembers() { CodeTypeMemberCollection mc = new CodeTypeMemberCollection(); while (TokenType != CDILToken.EOF && !IsKeyword("end")) { CodeTypeMember member = ParseMember(); mc.Add(member); } return mc; }
public ShaderDom(SourceShader source, string techniqueName, Platform platform, CompileDirectives directives) { this.domList = new List<DomBase>(); this.domList.Add(this); //add custom dom's this.domList.Add(new ShaderBytes(source, techniqueName, platform)); //needs to be passed to the registers as an interface provider ConstantSetup constantes = new ConstantSetup(source, techniqueName, platform); this.domList.Add(new ShaderRegisters(source, techniqueName, platform, constantes)); this.domList.Add(constantes); this.domList.Add(new ShaderTextures(source, techniqueName, platform)); foreach (DomBase dom in domList) dom.Setup(this); this.techniqueName = techniqueName; this.source = source; this.platform = platform; classDom = new CodeTypeDeclaration(techniqueName); classDom.IsClass = true; classDom.Attributes = MemberAttributes.Final | MemberAttributes.Public; classDom.TypeAttributes = TypeAttributes.Sealed | TypeAttributes.Public | TypeAttributes.Class; //provide a useful comment to the class GenerateClassComment(); if (source.GenerateInternalClass) { classDom.Attributes = MemberAttributes.Final | MemberAttributes.Assembly; classDom.TypeAttributes = TypeAttributes.NestedAssembly | TypeAttributes.Class | TypeAttributes.Sealed; } classDom.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(System.Diagnostics.DebuggerStepThroughAttribute)))); classDom.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(System.CodeDom.Compiler.GeneratedCodeAttribute)),new CodeAttributeArgument(new CodePrimitiveExpression(GetType().Assembly.ManifestModule.Name)),new CodeAttributeArgument(new CodePrimitiveExpression(GetType().Assembly.ManifestModule.ModuleVersionId.ToString())))); classDom.BaseTypes.Add(new CodeTypeReference(typeof(BaseShader))); //add custom base types to the shader //these are defined in TechniqueExtraData AsmTechnique asmTechnique = this.source.GetAsmTechnique(this.techniqueName, this.platform); if (asmTechnique.TechniqueExtraData != null && asmTechnique.TechniqueExtraData.ClassBaseTypes != null) { foreach (string baseTypeName in asmTechnique.TechniqueExtraData.ClassBaseTypes) classDom.BaseTypes.Add(new CodeTypeReference(baseTypeName)); } this.directives = directives; SetupMembers(techniqueName); foreach (DomBase dom in domList) dom.SetupMembers(this); CreateConstructor(); CreateStaticGraphicsInitMethod(); CreateBindMethod(); CreateWarmShaderMethod(); CreateChangedMethod(); CreateVertexInputMethods(); CodeTypeMemberCollection pcMembers = new CodeTypeMemberCollection(); CodeTypeMemberCollection xboxMembers = new CodeTypeMemberCollection(); foreach (DomBase dom in this.domList) { dom.AddMembers(this, delegate(CodeTypeMember s, string c) { Comment(s, c); classDom.Members.Add(s); }, Platform.Both); if (!source.DefinePlatform) // no need for specialization when the platform is constant { dom.AddMembers(this, delegate(CodeTypeMember s, string c) { Comment(s, c); pcMembers.Add(s); }, Platform.Windows); dom.AddMembers(this, delegate(CodeTypeMember s, string c) { Comment(s, c); xboxMembers.Add(s); }, Platform.Xbox); } } foreach (DomBase dom in this.domList) { dom.AddReadonlyMembers(this, delegate(CodeTypeMember s, string c) { CodeTypeMember readonlySnip = directives.CreateReadOnlySnippet(); Comment(readonlySnip ?? s, c); if (readonlySnip != null) classDom.Members.Add(readonlySnip); classDom.Members.Add(s); }, Platform.Both); if (!source.DefinePlatform) { dom.AddReadonlyMembers(this, delegate(CodeTypeMember s, string c) { CodeTypeMember readonlySnip = directives.CreateReadOnlySnippet(); Comment(readonlySnip ?? s, c); if (readonlySnip != null) pcMembers.Add(readonlySnip); pcMembers.Add(s); }, Platform.Windows); dom.AddReadonlyMembers(this, delegate(CodeTypeMember s, string c) { CodeTypeMember readonlySnip = directives.CreateReadOnlySnippet(); Comment(readonlySnip ?? s, c); if (readonlySnip != null) xboxMembers.Add(readonlySnip); xboxMembers.Add(s); }, Platform.Xbox); } } if (pcMembers.Count > 0 || xboxMembers.Count > 0) { //add #if / else blocks classDom.Members.Add(directives.IfXboxStatement); foreach (CodeTypeMember type in xboxMembers) classDom.Members.Add(type); classDom.Members.Add(directives.ElseStatement); foreach (CodeTypeMember type in pcMembers) classDom.Members.Add(type); classDom.Members.Add(directives.EndifStatement); } //finally, create the attribute setters CreateSetAttributeMethod(typeof(float), "SetAttributeImpl", "attribute"); CreateSetAttributeMethod(typeof(Vector2), "SetAttributeImpl", "attribute"); CreateSetAttributeMethod(typeof(Vector3), "SetAttributeImpl", "attribute"); CreateSetAttributeMethod(typeof(Vector4), "SetAttributeImpl", "attribute"); CreateSetAttributeMethod(typeof(Matrix), "SetAttributeImpl", "attribute"); CreateSetAttributeMethod(typeof(bool), "SetAttributeImpl", "attribute"); CreateSetAttributeMethod(typeof(float[]), "SetAttributeImpl", "attribute"); CreateSetAttributeMethod(typeof(Vector2[]), "SetAttributeImpl", "attribute"); CreateSetAttributeMethod(typeof(Vector3[]), "SetAttributeImpl", "attribute"); CreateSetAttributeMethod(typeof(Vector4[]), "SetAttributeImpl", "attribute"); CreateSetAttributeMethod(typeof(Matrix[]), "SetAttributeImpl", "attribute"); CreateSetAttributeMethod(typeof(Xen.Graphics.TextureSamplerState), "SetSamplerStateImpl", "sampler"); CreateSetAttributeMethod(typeof(Texture), "SetTextureImpl", "texture"); CreateSetAttributeMethod(typeof(Texture2D), "SetTextureImpl", "texture"); CreateSetAttributeMethod(typeof(Texture3D), "SetTextureImpl", "texture"); CreateSetAttributeMethod(typeof(TextureCube), "SetTextureImpl", "texture"); }
public CodeTypeMemberCollection(CodeTypeMemberCollection value) { AddRange(value); }
protected override void DbusServiceTargetField(CodeTypeReference typerefDbusInterface, CodeTypeReference typerefDbusMarshal, CodeTypeMemberCollection members) { CodeMemberField memberProxy = new CodeMemberField(typerefDbusInterface, CodeBuilderCommon.targetName); memberProxy.Attributes = MemberAttributes.Private; members.Add(memberProxy); }
static CodeTypeMemberCollection BuildOneToManyRelationships(EntityMetadata entity, ServiceProvider serviceProvider) { var members = new CodeTypeMemberCollection(); if (entity.OneToManyRelationships != null) { foreach (var metadata in from metadata in entity.OneToManyRelationships orderby metadata.SchemaName select metadata) { var entityMetadata = GetEntityMetadata(metadata.ReferencingEntity, serviceProvider); if (string.Equals(metadata.SchemaName, "calendar_calendar_rules", StringComparison.Ordinal) || string.Equals(metadata.SchemaName, "service_calendar_rules", StringComparison.Ordinal)) { members.Add(BuildCalendarRuleAttribute(entity, entityMetadata, metadata, serviceProvider)); } else if (serviceProvider.CodeFilterService.GenerateEntity(entityMetadata, serviceProvider) && serviceProvider.CodeFilterService.GenerateRelationship(metadata, entityMetadata, serviceProvider)) { members.Add(BuildOneToMany(entity, entityMetadata, metadata, serviceProvider)); } else { Trace.TraceInformation("Skipping {0}.OneToMany {1} from being generated.", new object[] {entity.LogicalName, metadata.SchemaName}); } } } return members; }
static CodeTypeMemberCollection BuildManyToManyRelationships(EntityMetadata entity, ServiceProvider serviceProvider) { var members = new CodeTypeMemberCollection(); if (entity.ManyToManyRelationships != null) { foreach (var metadata in from metadata in entity.ManyToManyRelationships orderby metadata.SchemaName select metadata) { var entityLogicalName = (entity.LogicalName != metadata.Entity1LogicalName) ? metadata.Entity1LogicalName : metadata.Entity2LogicalName; var entityMetadata = GetEntityMetadata(entityLogicalName, serviceProvider); if (serviceProvider.CodeFilterService.GenerateEntity(entityMetadata, serviceProvider) && serviceProvider.CodeFilterService.GenerateRelationship(metadata, entityMetadata, serviceProvider)) { if (entityMetadata.LogicalName != entity.LogicalName) { EntityRole? reflexiveRole = null; var propertyName = serviceProvider.NamingService.GetNameForRelationship(entity, metadata, reflexiveRole, serviceProvider); EntityRole? entityRole = null; var member = BuildManyToMany(entity, entityMetadata, metadata, propertyName, entityRole, serviceProvider); members.Add(member); } else { var str3 = serviceProvider.NamingService.GetNameForRelationship(entity, metadata, 0, serviceProvider); var member2 = BuildManyToMany(entity, entityMetadata, metadata, str3, 0, serviceProvider); members.Add(member2); var str4 = serviceProvider.NamingService.GetNameForRelationship(entity, metadata, EntityRole.Referenced, serviceProvider); var member3 = BuildManyToMany(entity, entityMetadata, metadata, str4, EntityRole.Referenced, serviceProvider); members.Add(member3); } } else { Trace.TraceInformation("Skipping {0}.ManyToMany {1} from being generated.", new object[] {entity.LogicalName, metadata.SchemaName}); } } } return members; }
public void AddRange(CodeTypeMemberCollection !value) { Contract.Requires(value != null); }
public void AddRange(CodeTypeMemberCollection value) { throw new NotImplementedException(); }
static CodeTypeMemberCollection BuildManyToOneRelationships(EntityMetadata entity, ServiceProvider serviceProvider) { var members = new CodeTypeMemberCollection(); if (entity.ManyToOneRelationships != null) { foreach (var metadata in from metadata in entity.ManyToOneRelationships orderby metadata.SchemaName select metadata) { var entityMetadata = GetEntityMetadata(metadata.ReferencedEntity, serviceProvider); if (serviceProvider.CodeFilterService.GenerateEntity(entityMetadata, serviceProvider) && serviceProvider.CodeFilterService.GenerateRelationship(metadata, entityMetadata, serviceProvider)) { var member = BuildManyToOne(entity, entityMetadata, metadata, serviceProvider); members.Add(member); } else { Trace.TraceInformation("Skipping {0}.ManyToOne {1} from being generated.", new object[] {entity.LogicalName, metadata.SchemaName}); } } } return members; }
public CodeTypeMemberCollection(CodeTypeMemberCollection value) { return(default(CodeTypeMemberCollection)); }