public void RemoveAt(int index) { // TODO: Validations if (internalMembersCollection.Count > index) { // Take a reference to the extended object. CodeTypeMemberExtension memberExtension = internalList[index]; // Remove the type from the CodeNamespace. internalMembersCollection.Remove(memberExtension.ExtendedObject); // Finally remove the extended object. internalList.RemoveAt(index); } }
public void RemoveField(string className, string fieldName) { if (string.IsNullOrEmpty(className)) { throw new ArgumentNullException("className"); } if (string.IsNullOrEmpty(fieldName)) { throw new ArgumentNullException("fieldName"); } string nsName = null; Helpers.GetNamespaceAndClassName(className, out nsName, out className); CodeTypeDeclaration typeDeclaration = GetCodeTypeDeclFromCodeCompileUnit(nsName, className); CodeTypeMemberCollection fields = typeDeclaration.Members; CodeMemberField fieldToRemove = null; if (fields != null) { foreach (CodeTypeMember member in fields) { if (member is CodeMemberField) { CodeMemberField field = (CodeMemberField)member; if (field.Name == fieldName) { fieldToRemove = field; } else if (String.Compare(field.Name, fieldName, StringComparison.OrdinalIgnoreCase) == 0) { fieldToRemove = field; } } } if (fieldToRemove != null) { fields.Remove(fieldToRemove); } } if (fieldToRemove == null) { throw new Exception(fieldName); } ITypeProvider typeProvider = this.ServiceProvider.GetService(typeof(ITypeProvider)) as ITypeProvider; if (typeProvider == null) { throw new InvalidOperationException(typeof(ITypeProvider).FullName); } ((TypeProvider)typeProvider).RefreshCodeCompileUnit(this.loader.CodeBesideCCU, new EventHandler(RefreshCCU)); }
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 Remove() { CodeTypeMember ctm1 = new CodeTypeMember(); CodeTypeMember ctm2 = new CodeTypeMember(); CodeTypeMemberCollection coll = new CodeTypeMemberCollection(); coll.Add(ctm1); coll.Add(ctm2); Assert.AreEqual(2, coll.Count, "#1"); Assert.AreEqual(0, coll.IndexOf(ctm1), "#2"); Assert.AreEqual(1, coll.IndexOf(ctm2), "#3"); coll.Remove(ctm1); Assert.AreEqual(1, coll.Count, "#4"); Assert.AreEqual(-1, coll.IndexOf(ctm1), "#5"); Assert.AreEqual(0, coll.IndexOf(ctm2), "#6"); }
void CompareTypes(CompileUnitPartialType source, CompileUnitPartialType target) { CodeTypeDeclaration sourceType = source.PartialType; CodeTypeMemberCollection targetMembers = target.PartialType.Members; List <CodeTypeMember> membersToRemove = new List <CodeTypeMember> (); foreach (CodeTypeMember member in targetMembers) { if (TypeHasMember(sourceType, member)) { membersToRemove.Add(member); } } foreach (CodeTypeMember member in membersToRemove) { targetMembers.Remove(member); } }
private static void PreProcessMembers(CodeTypeMemberCollection members) { bool hasConstructor = false; List <CodeTypeMember> removeLater = new List <CodeTypeMember>(); //removeLater or indeces would shift for (int i = 0; i < members.Count; i++) { CodeTypeMember current = members[i]; if (supressedMembers.Contains(current.Name) || ((current.Attributes & MemberAttributes.Static) == MemberAttributes.Static)) { Console.WriteLine("Removing member " + current.Name); removeLater.Add(current); } else if (current is CodeTypeDeclaration) { //Console.WriteLine("Found nested type: " + current.Name); if (current.Name.EndsWith("Proxy")) { Console.WriteLine("Removing nested type " + current.Name + " since it's a proxy!"); removeLater.Add(current); } else { PreProcessType((CodeTypeDeclaration)current); } } else if (current is CodeMemberField) { ((CodeMemberField)members[i]).Type = ReplaceDeepVariableTypesInTypeReference(((CodeMemberField)current).Type); } else if (current is CodeMemberProperty) { var property = (CodeMemberProperty)members[i]; property.Type = ReplaceDeepVariableTypesInTypeReference(property.Type); RemoveFeatureReferences(property.SetStatements); } else if (current is CodeMemberMethod) { var method = (CodeMemberMethod)members[i]; ReplaceDeepVaribleTypesInCodeMemberMethod(method); RemoveFeatureReferences(method.Statements); } if (members[i] is CodeConstructor) { hasConstructor = true; } } for (int i = 0; i < removeLater.Count; i++) { members.Remove(removeLater[i]); } if (!hasConstructor) { //create empty constructor to be sure GenerateConstructor is called and therefore all fields get initialized CodeConstructor ctor = new CodeConstructor(); //since the super constructor would have been called, add a call to it //this call needs to be AFTER the _ConstructorFieldInitFunction call to ensure its initialization isnt overriden by it ctor.Statements.Add(new CodeMethodReferenceExpression(new CodeBaseReferenceExpression(), "__init__()")); members.Add(ctor); } }
// CodeTypeMemberCollection public void CodeTypeMemberCollectionExample() { //<Snippet1> //<Snippet2> // Creates an empty CodeTypeMemberCollection. CodeTypeMemberCollection collection = new CodeTypeMemberCollection(); //</Snippet2> //<Snippet3> // Adds a CodeTypeMember to the collection. collection.Add(new CodeMemberField("System.String", "TestStringField")); //</Snippet3> //<Snippet4> // Adds an array of CodeTypeMember objects to the collection. CodeTypeMember[] members = { new CodeMemberField("System.String", "TestStringField1"), new CodeMemberField("System.String", "TestStringField2") }; collection.AddRange(members); // Adds a collection of CodeTypeMember objects to the collection. CodeTypeMemberCollection membersCollection = new CodeTypeMemberCollection(); membersCollection.Add(new CodeMemberField("System.String", "TestStringField1")); membersCollection.Add(new CodeMemberField("System.String", "TestStringField2")); collection.AddRange(membersCollection); //</Snippet4> //<Snippet5> // Tests for the presence of a CodeTypeMember in the collection, // and retrieves its index if it is found. CodeTypeMember testMember = new CodeMemberField("System.String", "TestStringField"); int itemIndex = -1; if (collection.Contains(testMember)) { itemIndex = collection.IndexOf(testMember); } //</Snippet5> //<Snippet6> // Copies the contents of the collection, beginning at index 0, // to the specified CodeTypeMember array. // 'members' is a CodeTypeMember array. collection.CopyTo(members, 0); //</Snippet6> //<Snippet7> // Retrieves the count of the items in the collection. int collectionCount = collection.Count; //</Snippet7> //<Snippet8> // Inserts a CodeTypeMember at index 0 of the collection. collection.Insert(0, new CodeMemberField("System.String", "TestStringField")); //</Snippet8> //<Snippet9> // Removes the specified CodeTypeMember from the collection. CodeTypeMember member = new CodeMemberField("System.String", "TestStringField"); collection.Remove(member); //</Snippet9> //<Snippet10> // Removes the CodeTypeMember at index 0. collection.RemoveAt(0); //</Snippet10> //</Snippet1> }
// Called by the WinForm designer at save time public override void GenerateCodeFromCompileUnit(CodeCompileUnit compileUnit, TextWriter writer, CodeGeneratorOptions options) { // Does that CodeCompileUnit comes from a "Merged" unit ? if (compileUnit is XMergedCodeCompileUnit mergedUnit) { // Retrieve the Form Class CodeTypeDeclaration combinedClass = XSharpCodeDomHelper.FindDesignerClass(compileUnit); // and retrieve the filename of the prg file string prgFileName = mergedUnit.FileName; // Build the Designer FileName // Retrieve Both CodeCompileUnit var formCCU = mergedUnit.FormUnit; var designCCU = mergedUnit.DesignerUnit; string designerPrgFile = designCCU.FileName; var formMembers = new CodeTypeMemberCollection(formCCU.Members); foreach (CodeTypeMember m in formMembers) { m.SetWritten(false); } // suppress generating the "generated code" header in the form.prg formCCU.GenerateHeader = false; CodeTypeDeclaration formClass = formCCU.GetFirstClass(); CodeTypeDeclaration designClass = designCCU.GetFirstClass(); // Now, remove the members CopyClassProperties(combinedClass, formClass); CopyClassProperties(combinedClass, designClass); combinedClass.IsPartial = true; formClass.Members.Clear(); designClass.Members.Clear(); // Now, split the members // And make sure no members are deleted foreach (CodeTypeMember ctm in combinedClass.Members) { // Was it a member that we have found in the original merged CodeCompileUnits ? if (ctm is IXCodeObject xco) { if (ctm.GetFromDesigner()) { // Comes from the Designer.prg file // so go back to Designer.prg designClass.Members.Add(ctm); ctm.SetWritten(true); } else { // Comes from the original Form file formClass.Members.Add(ctm); foreach (CodeTypeMember member in formMembers) { if (member == ctm) { member.SetWritten(true); formMembers.Remove(member); break; } } } } else { // This must be a member generated by the Designer ! // So we will move Methods to the Form and all others to the Designer if (ctm is CodeMemberMethod) { formClass.Members.Add(ctm); ctm.SetWritten(true); } else { designClass.Members.Add(ctm); ctm.SetWritten(true); } } } // Check for members that are not written foreach (CodeTypeMember member in formMembers) { if (!member.WasWritten()) { formClass.Members.Add(member); } } // now, we must save both CodeCompileUnit // The received TextWriter is pointing to the Form // so we must create our own TextWriter for the Designer // First, let's make in Memory String generatedSource; MemoryStream inMemory = new MemoryStream(); StreamWriter designerStream = new StreamWriter(inMemory, Encoding.UTF8); // // Backup original Form file and Form.Designer file // if (XSharpModel.XSettings.FormEditorMakeBackupFiles) { if (File.Exists(prgFileName)) { var bak = Path.ChangeExtension(prgFileName, ".bak"); Utilities.CopyFileSafe(prgFileName, bak); } if (File.Exists(designerPrgFile)) { var bak = Path.ChangeExtension(designerPrgFile, ".bak"); Utilities.CopyFileSafe(designerPrgFile, bak); } } base.GenerateCodeFromCompileUnit(designCCU, designerStream, options); // and force Flush designerStream.Flush(); // Reset and read to String inMemory.Position = 0; StreamReader reader = new StreamReader(inMemory, Encoding.UTF8, true); generatedSource = reader.ReadToEnd(); generatedSource = this._projectNode.SynchronizeKeywordCase(generatedSource, prgFileName); Encoding realencoding = reader.CurrentEncoding; reader.Close(); designerStream.Close(); XSharpFileNode node = _fileNode.FindChild(designerPrgFile) as XSharpFileNode; bool done = false; if (node != null) { // assign the source to the open buffer when possible if (node.DocumentSetText(generatedSource)) { // then use automation to save the file, because that is much easier // since we do not have to worry about the docdata etc. var oaFile = (OAXSharpFileItem)node.GetAutomationObject(); oaFile.Save(designerPrgFile); done = true; } } if (!done) { // File is not open in editor, so write to disk designerStream = new StreamWriter(designerPrgFile, false, realencoding); designerStream.Write(generatedSource); designerStream.Flush(); designerStream.Close(); } // The problem here, is that we "may" have some new members, like EvenHandlers, and we need to update their position (line/col) XSharpCodeParser parser = new XSharpCodeParser(_projectNode, formClass); parser.FileName = designerPrgFile; CodeCompileUnit resultDesigner = parser.Parse(generatedSource); CodeTypeDeclaration resultClass = XSharpCodeDomHelper.FindDesignerClass(resultDesigner); // just to be sure... if (resultClass != null) { // Now push all elements from resultClass to designClass designClass.Members.Clear(); foreach (CodeTypeMember ctm in resultClass.Members) { ctm.SetFromDesigner(true); designClass.Members.Add(ctm); } } // Ok,we MUST do the same thing for the Form file base.GenerateCodeFromCompileUnit(formCCU, writer, options); // BUT, the writer is hold by the Form Designer, don't close it !! writer.Flush(); // Now, we must re-read it and parse again IServiceProvider provider = (DocDataTextWriter)writer; DocData docData = (DocData)provider.GetService(typeof(DocData)); DocDataTextReader ddtr = new DocDataTextReader(docData); // Retrieve generatedSource = ddtr.ReadToEnd(); var newsource = this._projectNode.SynchronizeKeywordCase(generatedSource, prgFileName); if (string.Compare(newsource, generatedSource) != 0) { // get DocDataTextWriter and update the source after the case has been synchronized generatedSource = newsource; DocDataTextWriter dtw = new DocDataTextWriter(docData); dtw.Write(generatedSource); dtw.Flush(); } // Don't forget to set the name of the file where the source is... parser.FileName = prgFileName; resultDesigner = parser.Parse(generatedSource); resultClass = resultDesigner.GetFirstClass(); // just to be sure... if (resultClass != null) { // Now push all elements from resultClass to formClass formClass.Members.Clear(); foreach (CodeTypeMember ctm in resultClass.Members) { ctm.SetFromDesigner(false); formClass.Members.Add(ctm); } } // Ok, it should be ok.... // We have updated the file and the types that are stored inside each CCU that have been merged in compileUnit //XSharpCodeDomHelper.MergeCodeCompileUnit(compileUnit, formCCU, designCCU); // And update... combinedClass.Members.Clear(); combinedClass.Members.AddRange(designClass.Members); combinedClass.Members.AddRange(formClass.Members); } else { var xcompileUnit = ToXCodeCompileUnit(compileUnit); // suppress generating the "generated code" header if (writer is DocDataTextWriter) // Form Editor { compileUnit.SetNoHeader(); } base.GenerateCodeFromCompileUnit(compileUnit, writer, options); writer.Flush(); // Designer gave us these informations // Now, we must re-read it and parse again if (writer is DocDataTextWriter) { CodeTypeDeclaration formClass = compileUnit.GetFirstClass(); IServiceProvider provider = (DocDataTextWriter)writer; DocData docData = (DocData)provider.GetService(typeof(DocData)); DocDataTextReader ddtr = new DocDataTextReader(docData); // Retrieve string generatedSource = ddtr.ReadToEnd(); XSharpCodeParser parser = new XSharpCodeParser(_projectNode); parser.FileName = xcompileUnit.FileName; generatedSource = _projectNode.SynchronizeKeywordCase(generatedSource, parser.FileName); CodeCompileUnit resultCcu = parser.Parse(generatedSource); CodeTypeDeclaration resultClass = resultCcu.GetFirstClass(); // just to be sure... if (resultClass != null) { // Now push all elements from resultClass to formClass formClass.Members.Clear(); foreach (CodeTypeMember ctm in resultClass.Members) { formClass.Members.Add(ctm); } } } } }
public void Remove_Null() { CodeTypeMemberCollection coll = new CodeTypeMemberCollection(); coll.Remove((CodeTypeMember)null); }
public void Remove_NotInCollection() { CodeTypeMemberCollection coll = new CodeTypeMemberCollection(); coll.Remove(new CodeTypeMember()); }