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());
}
