fix abstract classes and properly dispose unused processes in single instance

tomysshadow · tomysshadow · commit 227eff476581 · 2023-06-02T23:36:02.000-06:00
diff --git a/FlashpointSecurePlayer/DownloadsBefore.cs b/FlashpointSecurePlayer/DownloadsBefore.cs
@@ -16,10 +16,9 @@ namespace FlashpointSecurePlayer {
     public class DownloadsBefore : Modifications {
         public DownloadsBefore(EventHandler importStart, EventHandler importStop) : base(importStart, importStop) { }
 
-        private void Activate() { }
-
         public async Task ActivateAsync(string templateName, List<string> downloadsBeforeNames) {
             base.Activate(templateName);
+
             //ModificationsElement modificationsElement = GetModificationsElement(true, Name);
 
             // purpose of the following code is to asynchronously
diff --git a/FlashpointSecurePlayer/EnvironmentVariables.cs b/FlashpointSecurePlayer/EnvironmentVariables.cs
@@ -17,9 +17,8 @@
 namespace FlashpointSecurePlayer {
     public class EnvironmentVariables : Modifications {
         private const string __COMPAT_LAYER = nameof(__COMPAT_LAYER);
+
         private IList<string> UnmodifiableComparableNames { get; } = new List<string> { FP_STARTUP_PATH, FP_HTDOCS_FILE }.AsReadOnly();
-        private readonly object activationLock = new object();
-        private readonly object deactivationLock = new object();
 
         public EnvironmentVariables(EventHandler importStart, EventHandler importStop) : base(importStart, importStop) { }
 
@@ -79,7 +78,7 @@ private string GetValue(EnvironmentVariablesElement environmentVariablesElement)
             return value;
         }
 
-        new public void Activate(string templateName) {
+        public override void Activate(string templateName) {
             lock (activationLock) {
                 base.Activate(templateName);
 
@@ -220,11 +219,12 @@ private string GetValue(EnvironmentVariablesElement environmentVariablesElement)
                 }
             }
         }
-        
-        public void Deactivate(MODIFICATIONS_REVERT_METHOD modificationsRevertMethod = MODIFICATIONS_REVERT_METHOD.CRASH_RECOVERY) {
+
+        public void Deactivate(MODIFICATIONS_REVERT_METHOD modificationsRevertMethod) {
             lock (deactivationLock) {
                 // do the reverse of activation because we can
                 base.Deactivate();
+
                 TemplateElement activeTemplateElement = GetActiveTemplateElement(false);
 
                 // if the activation backup doesn't exist, we don't need to do stuff
@@ -357,5 +357,9 @@ public void Deactivate(MODIFICATIONS_REVERT_METHOD modificationsRevertMethod = M
                 }
             }
         }
+
+        public override void Deactivate() {
+            Deactivate(MODIFICATIONS_REVERT_METHOD.CRASH_RECOVERY);
+        }
     }
 }
diff --git a/FlashpointSecurePlayer/Modifications.cs b/FlashpointSecurePlayer/Modifications.cs
@@ -27,7 +27,7 @@ public Modifications(EventHandler importStart, EventHandler importStop) {
             Deactivate();
         }
 
-        protected virtual void OnImportStart(EventArgs e) {
+        private void OnImportStart(EventArgs e) {
             EventHandler eventHandler = importStart;
 
             if (eventHandler == null) {
@@ -37,7 +37,7 @@ protected virtual void OnImportStart(EventArgs e) {
             eventHandler(this, e);
         }
 
-        protected virtual void OnImportStop(EventArgs e) {
+        private void OnImportStop(EventArgs e) {
             EventHandler eventHandler = importStop;
 
             if (eventHandler == null) {
@@ -47,20 +47,25 @@ protected virtual void OnImportStop(EventArgs e) {
             eventHandler(this, e);
         }
 
+        private readonly object importStartedLock = new object();
         private bool importStarted = false;
 
         protected bool ImportStarted {
             get {
-                return importStarted;
+                lock (importStartedLock) {
+                    return importStarted;
+                }
             }
 
             set {
-                importStarted = value;
-
-                if (importStarted) {
-                    OnImportStart(EventArgs.Empty);
-                } else {
-                    OnImportStop(EventArgs.Empty);
+                lock (importStartedLock) {
+                    importStarted = value;
+
+                    if (importStarted) {
+                        OnImportStart(EventArgs.Empty);
+                    } else {
+                        OnImportStop(EventArgs.Empty);
+                    }
                 }
             }
         }
@@ -84,7 +89,7 @@ protected bool ImportPaused {
 
         protected string TemplateName { get; set; } = String.Empty;
 
-        protected void StartImport(string templateName) {
+        public virtual void StartImport(string templateName) {
             if (ImportStarted) {
                 throw new InvalidOperationException("Cannot Start Import when the Import is in progress.");
             }
@@ -108,7 +113,7 @@ protected void StartImport(string templateName) {
         }
 
         // async for inheritence reasons
-        protected void StopImport() {
+        public virtual void StopImport() {
             if (!ImportStarted) {
                 throw new InvalidOperationException("Cannot Stop Import when the Import has not started.");
             }
@@ -125,7 +130,9 @@ protected void StopImport() {
             */
         }
 
-        public void Activate(string templateName) {
+        protected readonly object activationLock = new object();
+
+        public virtual void Activate(string templateName) {
             if (ImportStarted) {
                 throw new InvalidOperationException("Cannot Activate when the Import is in progress.");
             }
@@ -140,7 +147,9 @@ public void Activate(string templateName) {
             //SetFlashpointSecurePlayerSection();
         }
 
-        public void Deactivate() {
+        protected readonly object deactivationLock = new object();
+
+        public virtual void Deactivate() {
             if (ImportStarted) {
                 throw new InvalidOperationException("Cannot Deactivate when the Import is in progress.");
             }
diff --git a/FlashpointSecurePlayer/OldCPUSimulator.cs b/FlashpointSecurePlayer/OldCPUSimulator.cs
@@ -51,7 +51,6 @@ public bool TestRunningWithOldCPUSimulator() {
         }
 
         public void Activate(string templateName, ref ProcessStartInfo softwareProcessStartInfo, out bool softwareIsOldCPUSimulator) {
-            OldCPUSimulatorElement oldCPUSimulatorElement = null;
             softwareIsOldCPUSimulator = false;
 
             base.Activate(templateName);
@@ -74,7 +73,7 @@ public void Activate(string templateName, ref ProcessStartInfo softwareProcessSt
                 return;
             }
 
-            oldCPUSimulatorElement = modificationsElement.OldCPUSimulator;
+            OldCPUSimulatorElement oldCPUSimulatorElement = modificationsElement.OldCPUSimulator;
 
             if (!oldCPUSimulatorElement.ElementInformation.IsPresent) {
                 return;
diff --git a/FlashpointSecurePlayer/RegistryStates.cs b/FlashpointSecurePlayer/RegistryStates.cs
@@ -58,9 +58,6 @@ public enum TYPE {
         private const string IMPORT_RESUME = "FLASHPOINTSECUREPLAYERREGISTRYSTATEIMPORTRESUME";
         private const string IMPORT_PAUSE = "FLASHPOINTSECUREPLAYERREGISTRYSTATEIMPORTPAUSE";
 
-        private readonly object activationLock = new object();
-        private readonly object deactivationLock = new object();
-
         private string fullPath = null;
         private PathNames pathNames = null;
         private EventWaitHandle resumeEventWaitHandle = new ManualResetEvent(false);
@@ -937,7 +934,7 @@ private async Task StopImportAsync(bool sync) {
             }
         }
 
-        new public void StopImport() {
+        public override void StopImport() {
             // do not await this, bool hack
 #pragma warning disable CS4014
             StopImportAsync(true);
@@ -948,7 +945,7 @@ public async Task StopImportAsync() {
             await StopImportAsync(false).ConfigureAwait(false);
         }
 
-        new public void Activate(string templateName) {
+        public override void Activate(string templateName) {
             lock (activationLock) {
                 base.Activate(templateName);
 
@@ -1203,9 +1200,10 @@ public async Task StopImportAsync() {
             }
         }
 
-        public void Deactivate(MODIFICATIONS_REVERT_METHOD modificationsRevertMethod = MODIFICATIONS_REVERT_METHOD.CRASH_RECOVERY) {
+        public void Deactivate(MODIFICATIONS_REVERT_METHOD modificationsRevertMethod) {
             lock (deactivationLock) {
                 base.Deactivate();
+
                 TemplateElement activeTemplateElement = GetActiveTemplateElement(false);
 
                 // if the activation state doesn't exist, we don't need to do stuff
@@ -1507,6 +1505,10 @@ public void Deactivate(MODIFICATIONS_REVERT_METHOD modificationsRevertMethod = M
             }
         }
 
+        public override void Deactivate() {
+            Deactivate(MODIFICATIONS_REVERT_METHOD.CRASH_RECOVERY);
+        }
+
         private void QueueModification(ulong safeKeyHandle, DateTime timeStamp, RegistryStateElement registryStateElement) {
             if (queuedModifications == null) {
                 queuedModifications = new Dictionary<ulong, SortedList<DateTime, List<RegistryStateElement>>>();
diff --git a/FlashpointSecurePlayer/RunAsAdministrator.cs b/FlashpointSecurePlayer/RunAsAdministrator.cs
@@ -14,6 +14,7 @@ public RunAsAdministrator(EventHandler importStart, EventHandler importStop) : b
 
         public void Activate(string templateName, bool runAsAdministrator) {
             base.Activate(templateName);
+
             /*
             ModificationsElement modificationsElement = GetModificationsElement(true, Name);
 
diff --git a/FlashpointSecurePlayer/Shared.cs b/FlashpointSecurePlayer/Shared.cs
@@ -984,7 +984,7 @@ public ConfigurationElement Get(int index) {
                 return BaseGet(index) as ConfigurationElement;
             }
 
-            public ConfigurationElement Get(string name) {
+            public virtual ConfigurationElement Get(string name) {
                 //BaseAdd(modificationsElement);
                 return BaseGet(name) as ConfigurationElement;
             }
@@ -994,7 +994,7 @@ public void Set(ConfigurationElement configurationElement) {
                 BaseAdd(configurationElement);
             }
 
-            public void Remove(string name) {
+            public virtual void Remove(string name) {
                 if (BaseGet(name) != null) {
                     BaseRemove(name);
                 }
@@ -1401,14 +1401,12 @@ protected override ConfigurationElement CreateNewElement() {
                                 return new EnvironmentVariablesElement();
                             }
 
-                            new public ConfigurationElement Get(string name) {
-                                name = name.ToUpperInvariant();
-                                return base.Get(name);
+                            public override ConfigurationElement Get(string name) {
+                                return base.Get(name.ToUpperInvariant());
                             }
 
-                            new public void Remove(string name) {
-                                name = name.ToUpperInvariant();
-                                base.Remove(name);
+                            public override void Remove(string name) {
+                                base.Remove(name.ToUpperInvariant());
                             }
                         }
 
@@ -1636,7 +1634,6 @@ public string Name {
                                         if (!String.IsNullOrEmpty(valueName)) {
                                             valueName = valueName.ToUpperInvariant();
                                         }
-
                                         return keyName + "\\" + valueName;
                                     }
                                 }
@@ -1657,14 +1654,12 @@ protected override ConfigurationElement CreateNewElement() {
                                 return new RegistryStateElement();
                             }
 
-                            new public ConfigurationElement Get(string name) {
-                                name = name.ToUpperInvariant();
-                                return base.Get(name);
+                            public override ConfigurationElement Get(string name) {
+                                return base.Get(name.ToUpperInvariant());
                             }
 
-                            new public void Remove(string name) {
-                                name = name.ToUpperInvariant();
-                                base.Remove(name);
+                            public override void Remove(string name) {
+                                base.Remove(name.ToUpperInvariant());
                             }
                             
                             public BINARY_TYPE BinaryType {
@@ -1874,13 +1869,11 @@ protected override ConfigurationElement CreateNewElement() {
                 }
 
                 new public TemplateElement Get(string name) {
-                    name = name.ToLowerInvariant();
-                    return base.Get(name) as TemplateElement;
+                    return base.Get(name.ToLowerInvariant()) as TemplateElement;
                 }
 
-                new public void Remove(string name) {
-                    name = name.ToLowerInvariant();
-                    base.Remove(name);
+                public override void Remove(string name) {
+                    base.Remove(name.ToLowerInvariant());
                 }
             }
 
diff --git a/FlashpointSecurePlayer/SingleInstance.cs b/FlashpointSecurePlayer/SingleInstance.cs
@@ -55,7 +55,7 @@ public SingleInstance(EventHandler importStart, EventHandler importStop) : base(
             return ShowClosableMessageBox(new Task[] { task }, text, caption, messageBoxButtons, messageBoxIcon);
         }
 
-        new public void Activate(string templateName) {
+        public override void Activate(string templateName) {
             base.Activate(templateName);
 
             if (String.IsNullOrEmpty(TemplateName)) {
@@ -103,6 +103,7 @@ public SingleInstance(EventHandler importStart, EventHandler importStop) : base(
             string processName = null;
             // GetProcessesByName can't have extension (stupidly)
             string activeProcessName = Path.GetFileNameWithoutExtension(executable);
+            bool clear = false;
 
             do {
                 // the strict list is the one which will be checked against for real
@@ -119,13 +120,23 @@ public SingleInstance(EventHandler importStart, EventHandler importStop) : base(
                         if (processesByName[i] != null) {
                             processName = GetProcessName(processesByName[i]).ToString();
 
+                            clear = false;
+
                             try {
-                                if (ComparePaths(executable, processName)) {
-                                    processesByNameStrict.Push(processesByName[i]);
+                                if (!ComparePaths(executable, processName)) {
+                                    clear = true;
                                 }
                             } catch {
                                 // fail silently
                             }
+
+                            if (clear) {
+                                processesByName[i].Dispose();
+                            } else {
+                                processesByNameStrict.Push(processesByName[i]);
+                            }
+
+                            processesByName[i] = null;
                         }
                     }
                 } else {

Original file line number	Diff line number	Diff line change
`@@ -17,9 +17,8 @@`
`17`	`17`	`namespace FlashpointSecurePlayer {`
`18`	`18`	`public class EnvironmentVariables : Modifications {`
`19`	`19`	`private const string __COMPAT_LAYER = nameof(__COMPAT_LAYER);`
	`20`	`+`
`20`	`21`	`private IList<string> UnmodifiableComparableNames { get; } = new List<string> { FP_STARTUP_PATH, FP_HTDOCS_FILE }.AsReadOnly();`
`21`		`- private readonly object activationLock = new object();`
`22`		`- private readonly object deactivationLock = new object();`
`23`	`22`
`24`	`23`	`public EnvironmentVariables(EventHandler importStart, EventHandler importStop) : base(importStart, importStop) { }`
`25`	`24`
`@@ -79,7 +78,7 @@ private string GetValue(EnvironmentVariablesElement environmentVariablesElement)`
`79`	`78`	`return value;`
`80`	`79`	`}`
`81`	`80`
`82`		`- new public void Activate(string templateName) {`
	`81`	`+ public override void Activate(string templateName) {`
`83`	`82`	`lock (activationLock) {`
`84`	`83`	`base.Activate(templateName);`
`85`	`84`
`@@ -220,11 +219,12 @@ private string GetValue(EnvironmentVariablesElement environmentVariablesElement)`
`220`	`219`	`}`
`221`	`220`	`}`
`222`	`221`	`}`
`223`		`-`
`224`		`- public void Deactivate(MODIFICATIONS_REVERT_METHOD modificationsRevertMethod = MODIFICATIONS_REVERT_METHOD.CRASH_RECOVERY) {`
	`222`	`+`
	`223`	`+ public void Deactivate(MODIFICATIONS_REVERT_METHOD modificationsRevertMethod) {`
`225`	`224`	`lock (deactivationLock) {`
`226`	`225`	`// do the reverse of activation because we can`
`227`	`226`	`base.Deactivate();`
	`227`	`+`
`228`	`228`	`TemplateElement activeTemplateElement = GetActiveTemplateElement(false);`
`229`	`229`
`230`	`230`	`// if the activation backup doesn't exist, we don't need to do stuff`
`@@ -357,5 +357,9 @@ public void Deactivate(MODIFICATIONS_REVERT_METHOD modificationsRevertMethod = M`
`357`	`357`	`}`
`358`	`358`	`}`
`359`	`359`	`}`
	`360`	`+`
	`361`	`+ public override void Deactivate() {`
	`362`	`+ Deactivate(MODIFICATIONS_REVERT_METHOD.CRASH_RECOVERY);`
	`363`	`+ }`
`360`	`364`	`}`
`361`	`365`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public Modifications(EventHandler importStart, EventHandler importStop) {`
`27`	`27`	`Deactivate();`
`28`	`28`	`}`
`29`	`29`
`30`		`- protected virtual void OnImportStart(EventArgs e) {`
	`30`	`+ private void OnImportStart(EventArgs e) {`
`31`	`31`	`EventHandler eventHandler = importStart;`
`32`	`32`
`33`	`33`	`if (eventHandler == null) {`
`@@ -37,7 +37,7 @@ protected virtual void OnImportStart(EventArgs e) {`
`37`	`37`	`eventHandler(this, e);`
`38`	`38`	`}`
`39`	`39`
`40`		`- protected virtual void OnImportStop(EventArgs e) {`
	`40`	`+ private void OnImportStop(EventArgs e) {`
`41`	`41`	`EventHandler eventHandler = importStop;`
`42`	`42`
`43`	`43`	`if (eventHandler == null) {`
`@@ -47,20 +47,25 @@ protected virtual void OnImportStop(EventArgs e) {`
`47`	`47`	`eventHandler(this, e);`
`48`	`48`	`}`
`49`	`49`
	`50`	`+ private readonly object importStartedLock = new object();`
`50`	`51`	`private bool importStarted = false;`
`51`	`52`
`52`	`53`	`protected bool ImportStarted {`
`53`	`54`	`get {`
`54`		`- return importStarted;`
	`55`	`+ lock (importStartedLock) {`
	`56`	`+ return importStarted;`
	`57`	`+ }`
`55`	`58`	`}`
`56`	`59`
`57`	`60`	`set {`
`58`		`- importStarted = value;`
`59`		`-`
`60`		`- if (importStarted) {`
`61`		`- OnImportStart(EventArgs.Empty);`
`62`		`- } else {`
`63`		`- OnImportStop(EventArgs.Empty);`
	`61`	`+ lock (importStartedLock) {`
	`62`	`+ importStarted = value;`
	`63`	`+`
	`64`	`+ if (importStarted) {`
	`65`	`+ OnImportStart(EventArgs.Empty);`
	`66`	`+ } else {`
	`67`	`+ OnImportStop(EventArgs.Empty);`
	`68`	`+ }`
`64`	`69`	`}`
`65`	`70`	`}`
`66`	`71`	`}`
`@@ -84,7 +89,7 @@ protected bool ImportPaused {`
`84`	`89`
`85`	`90`	`protected string TemplateName { get; set; } = String.Empty;`
`86`	`91`
`87`		`- protected void StartImport(string templateName) {`
	`92`	`+ public virtual void StartImport(string templateName) {`
`88`	`93`	`if (ImportStarted) {`
`89`	`94`	`throw new InvalidOperationException("Cannot Start Import when the Import is in progress.");`
`90`	`95`	`}`
`@@ -108,7 +113,7 @@ protected void StartImport(string templateName) {`
`108`	`113`	`}`
`109`	`114`
`110`	`115`	`// async for inheritence reasons`
`111`		`- protected void StopImport() {`
	`116`	`+ public virtual void StopImport() {`
`112`	`117`	`if (!ImportStarted) {`
`113`	`118`	`throw new InvalidOperationException("Cannot Stop Import when the Import has not started.");`
`114`	`119`	`}`
`@@ -125,7 +130,9 @@ protected void StopImport() {`
`125`	`130`	`*/`
`126`	`131`	`}`
`127`	`132`
`128`		`- public void Activate(string templateName) {`
	`133`	`+ protected readonly object activationLock = new object();`
	`134`	`+`
	`135`	`+ public virtual void Activate(string templateName) {`
`129`	`136`	`if (ImportStarted) {`
`130`	`137`	`throw new InvalidOperationException("Cannot Activate when the Import is in progress.");`
`131`	`138`	`}`
`@@ -140,7 +147,9 @@ public void Activate(string templateName) {`
`140`	`147`	`//SetFlashpointSecurePlayerSection();`
`141`	`148`	`}`
`142`	`149`
`143`		`- public void Deactivate() {`
	`150`	`+ protected readonly object deactivationLock = new object();`
	`151`	`+`
	`152`	`+ public virtual void Deactivate() {`
`144`	`153`	`if (ImportStarted) {`
`145`	`154`	`throw new InvalidOperationException("Cannot Deactivate when the Import is in progress.");`
`146`	`155`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,6 @@ public bool TestRunningWithOldCPUSimulator() {`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`public void Activate(string templateName, ref ProcessStartInfo softwareProcessStartInfo, out bool softwareIsOldCPUSimulator) {`
`54`		`- OldCPUSimulatorElement oldCPUSimulatorElement = null;`
`55`	`54`	`softwareIsOldCPUSimulator = false;`
`56`	`55`
`57`	`56`	`base.Activate(templateName);`
`@@ -74,7 +73,7 @@ public void Activate(string templateName, ref ProcessStartInfo softwareProcessSt`
`74`	`73`	`return;`
`75`	`74`	`}`
`76`	`75`
`77`		`- oldCPUSimulatorElement = modificationsElement.OldCPUSimulator;`
	`76`	`+ OldCPUSimulatorElement oldCPUSimulatorElement = modificationsElement.OldCPUSimulator;`
`78`	`77`
`79`	`78`	`if (!oldCPUSimulatorElement.ElementInformation.IsPresent) {`
`80`	`79`	`return;`
Original file line number	Diff line number	Diff line change
`@@ -984,7 +984,7 @@ public ConfigurationElement Get(int index) {`
`984`	`984`	`return BaseGet(index) as ConfigurationElement;`
`985`	`985`	`}`
`986`	`986`
`987`		`- public ConfigurationElement Get(string name) {`
	`987`	`+ public virtual ConfigurationElement Get(string name) {`
`988`	`988`	`//BaseAdd(modificationsElement);`
`989`	`989`	`return BaseGet(name) as ConfigurationElement;`
`990`	`990`	`}`
`@@ -994,7 +994,7 @@ public void Set(ConfigurationElement configurationElement) {`
`994`	`994`	`BaseAdd(configurationElement);`
`995`	`995`	`}`
`996`	`996`
`997`		`- public void Remove(string name) {`
	`997`	`+ public virtual void Remove(string name) {`
`998`	`998`	`if (BaseGet(name) != null) {`
`999`	`999`	`BaseRemove(name);`
`1000`	`1000`	`}`
`@@ -1401,14 +1401,12 @@ protected override ConfigurationElement CreateNewElement() {`
`1401`	`1401`	`return new EnvironmentVariablesElement();`
`1402`	`1402`	`}`
`1403`	`1403`
`1404`		`- new public ConfigurationElement Get(string name) {`
`1405`		`- name = name.ToUpperInvariant();`
`1406`		`- return base.Get(name);`
	`1404`	`+ public override ConfigurationElement Get(string name) {`
	`1405`	`+ return base.Get(name.ToUpperInvariant());`
`1407`	`1406`	`}`
`1408`	`1407`
`1409`		`- new public void Remove(string name) {`
`1410`		`- name = name.ToUpperInvariant();`
`1411`		`- base.Remove(name);`
	`1408`	`+ public override void Remove(string name) {`
	`1409`	`+ base.Remove(name.ToUpperInvariant());`
`1412`	`1410`	`}`
`1413`	`1411`	`}`
`1414`	`1412`
`@@ -1636,7 +1634,6 @@ public string Name {`
`1636`	`1634`	`if (!String.IsNullOrEmpty(valueName)) {`
`1637`	`1635`	`valueName = valueName.ToUpperInvariant();`
`1638`	`1636`	`}`
`1639`		`-`
`1640`	`1637`	`return keyName + "\\" + valueName;`
`1641`	`1638`	`}`
`1642`	`1639`	`}`
`@@ -1657,14 +1654,12 @@ protected override ConfigurationElement CreateNewElement() {`
`1657`	`1654`	`return new RegistryStateElement();`
`1658`	`1655`	`}`
`1659`	`1656`
`1660`		`- new public ConfigurationElement Get(string name) {`
`1661`		`- name = name.ToUpperInvariant();`
`1662`		`- return base.Get(name);`
	`1657`	`+ public override ConfigurationElement Get(string name) {`
	`1658`	`+ return base.Get(name.ToUpperInvariant());`
`1663`	`1659`	`}`
`1664`	`1660`
`1665`		`- new public void Remove(string name) {`
`1666`		`- name = name.ToUpperInvariant();`
`1667`		`- base.Remove(name);`
	`1661`	`+ public override void Remove(string name) {`
	`1662`	`+ base.Remove(name.ToUpperInvariant());`
`1668`	`1663`	`}`
`1669`	`1664`
`1670`	`1665`	`public BINARY_TYPE BinaryType {`
`@@ -1874,13 +1869,11 @@ protected override ConfigurationElement CreateNewElement() {`
`1874`	`1869`	`}`
`1875`	`1870`
`1876`	`1871`	`new public TemplateElement Get(string name) {`
`1877`		`- name = name.ToLowerInvariant();`
`1878`		`- return base.Get(name) as TemplateElement;`
	`1872`	`+ return base.Get(name.ToLowerInvariant()) as TemplateElement;`
`1879`	`1873`	`}`
`1880`	`1874`
`1881`		`- new public void Remove(string name) {`
`1882`		`- name = name.ToLowerInvariant();`
`1883`		`- base.Remove(name);`
	`1875`	`+ public override void Remove(string name) {`
	`1876`	`+ base.Remove(name.ToLowerInvariant());`
`1884`	`1877`	`}`
`1885`	`1878`	`}`
`1886`	`1879`