Added the ability to dispose a plugin

Author: niemyjski

Source/Shared/Configuration/ExceptionlessConfiguration.cs

@@ -271,8 +271,10 @@ public void RemovePlugin<T>() where T : IEventPlugin {
         /// </summary>
         /// <param name="key">The key for the plugin to be removed.</param>
         public void RemovePlugin(string key) {
-            if (_plugins.ContainsKey(key))
+            if (_plugins.ContainsKey(key)) {
+                _plugins[key].Dispose();
                 _plugins.Remove(key);
+            }
         }
 
         private int GetPriority(Type type) {
@@ -329,7 +331,7 @@ public ValidationResult() {
         }
 
         [DebuggerDisplay("Key: {Key}, Priority: {Priority}")]
-        public class PluginRegistration {
+        public class PluginRegistration : IDisposable {
             private readonly Lazy<IEventPlugin> _plugin;
             public PluginRegistration(string key, int priority, Lazy<IEventPlugin> plugin) {
                 Key = key;
@@ -346,6 +348,14 @@ public PluginRegistration(string key, int priority, Lazy<IEventPlugin> plugin) {
             public override string ToString() {
                 return $"Key: {Key}, Priority: {Priority}";
             }
+
+            public void Dispose() {
+                if (!_plugin.IsValueCreated)
+                    return;
+
+                var disposable = _plugin.Value as IDisposable;
+                disposable?.Dispose();
+            }
         }
     }
 }

Source/Tests/Plugins/PluginTests.cs

@@ -193,6 +193,74 @@ public void PrivateInformation_WillNotUpdateIdentity() {
             Assert.Equal("Blake", user?.Name);
         }
 
+
+        [Fact]
+        public void LazyLoadAndRemovePlugin() {
+            var configuration = new ExceptionlessConfiguration(DependencyResolver.Default);
+            foreach (var plugin in configuration.Plugins)
+                configuration.RemovePlugin(plugin.Key);
+
+            configuration.AddPlugin<ThrowIfInitializedTestPlugin>();
+            configuration.RemovePlugin<ThrowIfInitializedTestPlugin>();
+        }
+
+        private class ThrowIfInitializedTestPlugin : IEventPlugin, IDisposable {
+            public ThrowIfInitializedTestPlugin() {
+                throw new ApplicationException("Plugin shouldn't be constructed");
+            }
+
+            public void Run(EventPluginContext context) {}
+            
+            public void Dispose() {
+                throw new ApplicationException("Plugin shouldn't be created or disposed");
+            }
+        }
+
+        [Fact]
+        public void CanDisposePlugin() {
+            var configuration = new ExceptionlessConfiguration(DependencyResolver.Default);
+            foreach (var plugin in configuration.Plugins)
+                configuration.RemovePlugin(plugin.Key);
+
+            Assert.Equal(0, CounterTestPlugin.ConstructorCount);
+            Assert.Equal(0, CounterTestPlugin.RunCount);
+            Assert.Equal(0, CounterTestPlugin.DisposeCount);
+
+            configuration.AddPlugin<CounterTestPlugin>();
+            configuration.AddPlugin<CounterTestPlugin>();
+
+            for (int i = 0; i < 2; i++) {
+                foreach (var pluginRegistration in configuration.Plugins)
+                    pluginRegistration.Plugin.Run(new EventPluginContext(new ExceptionlessClient(), new Event()));
+            }
+
+            configuration.RemovePlugin<CounterTestPlugin>();
+            configuration.RemovePlugin<CounterTestPlugin>();
+
+
+            Assert.Equal(1, CounterTestPlugin.ConstructorCount);
+            Assert.Equal(2, CounterTestPlugin.RunCount);
+            Assert.Equal(1, CounterTestPlugin.DisposeCount);
+        }
+
+        public class CounterTestPlugin : IEventPlugin, IDisposable {
+            public static byte ConstructorCount = 0;
+            public static byte RunCount = 0;
+            public static byte DisposeCount = 0;
+
+            public CounterTestPlugin() {
+                ConstructorCount++;
+            }
+
+            public void Run(EventPluginContext context) {
+                RunCount++;
+            }
+            
+            public void Dispose() {
+                DisposeCount++;
+            }
+        }
+
         [Fact]
         public void VerifyPriority() {
             var config = new ExceptionlessConfiguration(DependencyResolver.CreateDefault());