aview-app 1.0.2

package/aardio/lib/dotNet/.res/Aardio.InteropServices/CCodeCompiler.cs

@@ -0,0 +1,202 @@
+/*
+可遵循 aardio 用户协议与 aardio 开源许可证在 aardio 程序中自由使用本组件以及本组件源码,
+禁止在非 aardio 开发的程序中引用本组件的任何部份(包含但不限于本组件源码、使用此源码生成的 DLL )
+*/
+using System;
+using System.CodeDom.Compiler;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.IO;
+using System.Web.Services.Description;
+using Microsoft.CSharp;
+using System.Net;
+
+namespace Aardio.InteropServices
+{
+	[ClassInterface(ClassInterfaceType.AutoDispatch), ComVisible(true)]
+	public class CCodeCompiler
+	{
+		private StringBuilder lastErrorText;
+
+		private CompilerParameters parameters;
+
+		private CodeDomProvider provider;
+
+		private object source;
+
+		public string LastError
+		{
+			get
+			{
+				return this.lastErrorText.ToString();
+			}
+		}
+
+		public CompilerParameters Parameters
+		{
+			get
+			{
+				return this.parameters;
+			}
+			set
+			{
+				this.parameters = value;
+			}
+		}
+
+		public CodeDomProvider Provider
+		{
+			get
+			{
+				return this.provider;
+			}
+			set
+			{
+				this.provider = value;
+			}
+		}
+
+		public object Source
+		{
+			get
+			{
+				return this.source;
+			}
+			set
+			{
+				this.source = value;
+			}
+		} 
+
+        public CCodeCompiler(CodeDomProvider p)
+		{
+			this.provider = p;
+			this.parameters = new CompilerParameters();
+			this.parameters.ReferencedAssemblies.Add("System.dll");
+			this.parameters.GenerateExecutable = false;
+			this.parameters.GenerateInMemory = true;
+			this.lastErrorText = new StringBuilder();
+			this.source = null;
+		}
+
+		public Assembly Compile()
+		{
+			this.lastErrorText = new StringBuilder();
+
+			string[] source;
+			if (this.Source is string) source = new string[] { this.Source as string };
+			else source = this.Source as string[];
+			 
+			if (source == null)
+			{
+				this.lastErrorText.Append("Property 'Source' cannot be null!");
+				return null;
+			}
+
+            CompilerResults compilerResults = this.provider.CompileAssemblyFromSource(this.parameters, source);
+			if (!compilerResults.Errors.HasErrors)
+			{
+				return compilerResults.CompiledAssembly;
+			}
+			foreach (CompilerError compilerError in compilerResults.Errors)
+			{
+				this.lastErrorText.Append(string.Format("ErrorNumber:{0} Line:{1} {2}", compilerError.ErrorNumber, compilerError.Line, compilerError.ErrorText));
+				this.lastErrorText.Append("\r\n");
+			}
+			return null;
+		}
+
+		public Assembly CompileWebService(string url, string ns, string protocolName)
+		{
+			this.lastErrorText = new StringBuilder();
+			if (url == null)
+			{
+				this.lastErrorText.Append("未指定服务地址!");
+				return null;
+			}
+
+			WebClient http = new WebClient();
+			Stream stream = http.OpenRead(url + "?WSDL");
+			ServiceDescription serviceDesc = ServiceDescription.Read(stream);
+			ServiceDescriptionImporter sdImporter = new ServiceDescriptionImporter();
+			sdImporter.ProtocolName = protocolName;
+			sdImporter.AddServiceDescription(serviceDesc, "", "");
+
+			foreach (Import schemaImport in serviceDesc.Imports)
+			{
+				Uri baseUri = new Uri(url + "?WSDL");
+				string schemaLocation = schemaImport.Location;
+				if (schemaLocation == null)
+					continue;
+				Uri schemaUri = new Uri(baseUri, schemaLocation);
+
+				using (Stream schemaStream = http.OpenRead(schemaUri))
+				{
+					try
+					{
+						ServiceDescription sdImport = ServiceDescription.Read(schemaStream, true);
+						sdImport.Namespaces.Add("wsdl", schemaImport.Namespace);
+						sdImporter.AddServiceDescription(sdImport, null, null);
+					}
+					catch { }
+				}
+			}
+		
+			foreach (System.Xml.Schema.XmlSchema wsdlSchema in serviceDesc.Types.Schemas)
+			{
+				foreach (System.Xml.Schema.XmlSchemaObject externalSchema in wsdlSchema.Includes)
+				{
+					if (externalSchema is System.Xml.Schema.XmlSchemaImport)
+					{
+						Uri baseUri = new Uri(url + "?WSDL");
+						string exSchemaLocation = ((System.Xml.Schema.XmlSchemaExternal)externalSchema).SchemaLocation;
+						if (string.IsNullOrEmpty(exSchemaLocation))
+							continue;
+
+						Uri schemaUri = new Uri(baseUri, exSchemaLocation);
+
+						using (Stream schemaStream = http.OpenRead(schemaUri))
+						{
+							try
+							{
+								System.Xml.Schema.XmlSchema schema = System.Xml.Schema.XmlSchema.Read(schemaStream, null);
+								sdImporter.Schemas.Add(schema);
+							}
+							catch { }                                                      
+						}
+					}
+				}
+			}
+
+
+			System.CodeDom.CodeNamespace codeNamespace = new System.CodeDom.CodeNamespace(ns);
+			System.CodeDom.CodeCompileUnit codeCompileUnit = new System.CodeDom.CodeCompileUnit();
+			codeCompileUnit.Namespaces.Add(codeNamespace);
+			sdImporter.Import(codeNamespace, codeCompileUnit);
+
+			this.parameters.ReferencedAssemblies.Add("System.XML.dll");
+			this.parameters.ReferencedAssemblies.Add("System.Web.Services.dll");
+			this.parameters.ReferencedAssemblies.Add("System.Data.dll");
+			CompilerResults compilerResults = this.provider.CompileAssemblyFromDom(this.parameters, codeCompileUnit);
+
+			if (true == compilerResults.Errors.HasErrors)
+			{
+				foreach (CompilerError compilerError in compilerResults.Errors)
+				{
+					this.lastErrorText.Append(string.Format("ErrorNumber:{0} Line:{1} {2}", compilerError.ErrorNumber, compilerError.Line, compilerError.ErrorText));
+					this.lastErrorText.Append("\r\n");
+				}
+				return null;
+			}
+
+			return compilerResults.CompiledAssembly; 
+				
+		}
+
+		public void Reference(string assemblyName)
+		{
+			this.parameters.ReferencedAssemblies.Add(assemblyName);
+		}
+	}
+}

package/aardio/lib/dotNet/.res/Aardio.InteropServices/DispatchableDelegate.cs

@@ -0,0 +1,362 @@
+/*
+可遵循 aardio 用户协议与 aardio 开源许可证在 aardio 程序中自由使用本组件以及本组件源码,
+禁止在非 aardio 开发的程序中引用本组件的任何部份(包含但不限于本组件源码、使用此源码生成的 DLL )
+*/
+using System;
+using System.Reflection;
+using System.Collections;
+using System.Runtime.InteropServices;
+
+namespace Aardio.InteropServices
+{
+    public class DispatchableDelegate
+    {
+        private object invokeableObj;
+        public DispatchableDelegate(object dispObject) { invokeableObj = dispObject; }
+
+        private bool isComVisible(Type type)
+        {
+            bool comVisible = true;
+            //first check if the type has ComVisible defined for itself
+            var typeAttributes = type.GetCustomAttributes(typeof(ComVisibleAttribute), true);
+            if (typeAttributes.Length > 0)
+            {
+                comVisible = ((ComVisibleAttribute)typeAttributes[0]).Value;
+            }
+            else
+            {
+                //no specific ComVisible attribute defined, return the default for the assembly
+                var assemblyAttributes = type.Assembly.GetCustomAttributes(typeof(ComVisibleAttribute), true);
+                if (assemblyAttributes.Length > 0)
+                {
+                    comVisible = ((ComVisibleAttribute)assemblyAttributes[0]).Value;
+                }
+            }
+            return comVisible;
+        }
+
+
+        static Type ColorType = typeof(System.Drawing.Color);
+        static Type ComVisibleAttributeType = typeof(ComVisibleAttribute);
+        [ComVisible(true)]
+        public object Invoke(params object[] args) {
+
+            if (args != null) {
+                object arg;
+                Type t;
+ 
+                for (int i = 0; i < args.Length; i++)
+                {
+                    arg = args[i];
+                    if (arg != null)
+                    {
+                        t = arg.GetType();
+                        if ( t.IsPrimitive || t.IsEnum ) continue;
+                        if (typeof(string) == t) continue;
+ 
+                        if (t == ColorType)
+                        {
+                            args[i] = ((System.Drawing.Color)arg).ToArgb();
+                            continue;
+                        }
+
+                        //if ( !isComVisible(t) ) args[i] = null;
+
+
+                        if (!t.IsValueType)
+                        {
+                            if (t.IsArray)
+                            {
+                                Type tEle = t.GetElementType();
+                                Array arr = arg as Array;
+
+                                if (arr.GetLength(0) == 0) args[i] = new Aardio.InteropServices.DispatchableObject(arg, false);
+                                else if(typeof(string) == tEle) continue;
+                                else if(tEle.IsArray)
+                                {
+                                    object first = Aardio.InteropServices.Utility.WrapNonPrimitiveValueToAnyObjectRef(arr.GetValue(0));
+                                    if ((first != null) && (first.GetType() == Aardio.InteropServices.Utility.DispatchableObjectType))
+                                    {
+                                        args[i] = new Aardio.InteropServices.DispatchableObject(arg, false);
+                                    }
+                                }
+                                else if (!(tEle.IsPrimitive || tEle.IsEnum))
+                                {
+                                    args[i] = Utility.WrapNonPrimitiveValueToAnyObjectRef(arg);
+                                }
+                            }
+                            else if (t.IsClass)
+                            {
+                                try
+                                {
+                                    var ptr = Marshal.GetIDispatchForObject(arg);
+                                    if (ptr != null) Marshal.Release(ptr);
+                                }
+                                catch (InvalidOperationException)
+                                {
+                                    args[i] = new Aardio.InteropServices.DispatchableObject(arg, false);
+                                }
+                                catch (Exception)
+                                {
+
+                                }
+                            }
+                        }
+
+                    }
+                }
+         
+            }
+             
+            return invokeableObj.GetType().InvokeMember("", BindingFlags.InvokeMethod, null, invokeableObj, args);
+        }
+
+        public TResult Func<TResult>() { return (TResult)Invoke(); }
+        public TResult Func<T, TResult>(T arg) { return (TResult)Invoke(arg); }
+        public TResult Func<T1, T2, TResult>(T1 arg1, T2 arg2) { return (TResult)Invoke(arg1, arg2); }
+        public TResult Func<T1, T2, T3, TResult>(T1 arg1, T2 arg2, T3 arg3) { return (TResult)Invoke(arg1, arg2, arg3); }
+        public TResult Func<T1, T2, T3, T4, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4) { return (TResult)Invoke(arg1, arg2, arg3, arg4); }
+        public TResult Func<T1, T2, T3, T4, T5, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) { return (TResult)Invoke(arg1, arg2, arg3, arg4, arg5); }
+        public TResult Func<T1, T2, T3, T4, T5, T6, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6) { return (TResult)Invoke(arg1, arg2, arg3, arg4, arg5, arg6); }
+        public TResult Func<T1, T2, T3, T4, T5, T6, T7, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7) { return (TResult)Invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7); }
+        public TResult Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8) { return (TResult)Invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); }
+        public TResult Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9) { return (TResult)Invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); }
+        public TResult Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10) { return (TResult)Invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); }
+        public TResult Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11) { return (TResult)Invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); }
+        public TResult Func<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12) { return (TResult)Invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); }
+
+        public void Action() { Invoke(); }
+        public void Action<T>(T arg) { Invoke(arg); }
+        public void Action<T1, T2>(T1 arg1, T2 arg2) { Invoke(arg1, arg2); }
+        public void Action<T1, T2, T3>(T1 arg1, T2 arg2, T3 arg3) { Invoke(arg1, arg2, arg3); }
+        public void Action<T1, T2, T3, T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4) { Invoke(arg1, arg2, arg3, arg4); }
+        public void Action<T1, T2, T3, T4, T5>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) { Invoke(arg1, arg2, arg3, arg4, arg5); }
+        public void Action<T1, T2, T3, T4, T5, T6>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6) { Invoke(arg1, arg2, arg3, arg4, arg5, arg6); }
+        public void Action<T1, T2, T3, T4, T5, T6, T7>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7) { Invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7); }
+        public void Action<T1, T2, T3, T4, T5, T6, T7, T8>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8) { Invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); }
+        public void Action<T1, T2, T3, T4, T5, T6, T7, T8, T9>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9) { Invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); }
+        public void Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10) { Invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); }
+        public void Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11) { Invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); }
+        public void Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12) { Invoke(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12); }
+
+
+        public Delegate CreateDelegate(Type delegateType)
+        {
+            var delegateMethod = delegateType.GetMethod("Invoke");
+            var delegateReturn = delegateMethod.ReturnType;
+            var delegateParameters = delegateMethod.GetParameters();
+            var delegateAction = delegateReturn == typeof(void);
+
+            Type objectType = this.GetType();
+            var methods = objectType.GetMethods();
+
+            MethodInfo method = null;
+            ParameterInfo[] methodParameters = null;
+            Type methodReturn = null;
+
+            var delegateMethodName = delegateAction ? "Action" : "Func";
+            foreach (var methodInfo in methods)
+            {
+                if (methodInfo.Name != delegateMethodName)
+                {
+                    continue;
+                }
+                methodParameters = methodInfo.GetParameters();
+                methodReturn = methodInfo.ReturnType;
+
+                if (methodParameters.Length != delegateParameters.Length)
+                {
+                    continue;
+                }
+
+                method = methodInfo;
+                break;
+            }
+
+            if (method == null)
+            {
+                throw new Exception("DispatchableDelegate: Method not found");
+            }
+
+            if (method.IsGenericMethodDefinition)
+            {
+                var genericArguments = method.GetGenericArguments();
+                var genericParameters = new Type[genericArguments.Length];
+
+                int genericArgumentIndex;
+                if (!delegateAction) { 
+                    genericArgumentIndex = Array.IndexOf(genericArguments, methodReturn);
+                    if (genericArgumentIndex != -1)
+                    {
+                        genericParameters[genericArgumentIndex] = delegateReturn;
+                    }
+                }
+
+                for (int i = 0; i < methodParameters.Length; ++i)
+                {
+                    var methodParameter = methodParameters[i];
+                    genericArgumentIndex = Array.IndexOf(genericArguments, methodParameter.ParameterType);
+
+                    if (genericArgumentIndex == -1) continue;
+                    genericParameters[genericArgumentIndex] = delegateParameters[i].ParameterType;
+                }
+
+                if (Array.IndexOf(genericParameters, null) != -1)
+                {
+                    throw new Exception("DispatchableDelegate: Failed to resolve some generic parameters.");
+                }
+
+                var concreteMethod = method.MakeGenericMethod(genericParameters);
+
+
+                return Delegate.CreateDelegate(delegateType, this, concreteMethod);
+            }
+            else
+            {
+                return Delegate.CreateDelegate(delegateType, this, method);
+            }
+        }
+
+        public static object CreateDelegateByMemberName(object target ,string k, object func)
+        {
+            if (typeof(Delegate).IsAssignableFrom(func.GetType().BaseType)) return func; 
+            Type tAny = target.GetType();
+            
+            FieldInfo fieldInfo = tAny.GetField(k, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.GetProperty | BindingFlags.GetField);
+            if (fieldInfo!=null)
+            {
+                return new DispatchableDelegate(func).CreateDelegate(fieldInfo.FieldType); 
+            }
+            else
+            {
+                PropertyInfo propInfo = tAny.GetProperty(k, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.GetProperty | BindingFlags.GetField);
+                if (propInfo != null)
+                {
+                    return new DispatchableDelegate(func).CreateDelegate(propInfo.PropertyType); 
+                }
+            }
+
+            EventInfo eventInfo = tAny.GetEvent(k);
+            if (eventInfo != null)
+            {
+                return new DispatchableDelegate(func).CreateDelegate(eventInfo.EventHandlerType);
+            }
+
+            return null;
+        }
+        
+
+        public static object CombineDelegateByMemberName(object target, string k, object func)
+        {
+            bool funcIsDelegate = typeof(Delegate).IsAssignableFrom(func.GetType().BaseType);
+            Type tAny = target.GetType();
+
+            FieldInfo fieldInfo = tAny.GetField(k, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.GetProperty | BindingFlags.GetField);
+            if (fieldInfo != null)
+            {
+                if(!funcIsDelegate) func = new DispatchableDelegate(func).CreateDelegate(fieldInfo.FieldType); 
+                object newfunc = Delegate.Combine((Delegate)fieldInfo.GetValue(target), (Delegate)func);
+                fieldInfo.SetValue(target, newfunc);
+            }
+            else
+            {
+                PropertyInfo propInfo = tAny.GetProperty(k, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.GetProperty | BindingFlags.GetField);
+                if (propInfo != null)
+                {
+                    if (!funcIsDelegate) func = new DispatchableDelegate(func).CreateDelegate(propInfo.PropertyType);
+                    object newfunc = Delegate.Combine((Delegate)fieldInfo.GetValue(target), (Delegate)func);
+                    propInfo.SetValue(target, newfunc,null);
+                }
+            }
+
+            EventInfo eventInfo = tAny.GetEvent(k);
+            if (eventInfo != null)
+            {
+                if (!funcIsDelegate) func = new DispatchableDelegate(func).CreateDelegate(eventInfo.EventHandlerType);
+                eventInfo.AddEventHandler(target, (Delegate)func); 
+            }
+
+            return func;
+        }
+
+        public static bool RemoveDelegateByMemberName(object target, string k, object func)
+        {
+            if (!typeof(Delegate).IsAssignableFrom(func.GetType().BaseType)) return false;
+
+            Type tAny = target.GetType();
+
+            FieldInfo fieldInfo = tAny.GetField(k, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.GetProperty | BindingFlags.GetField);
+            if (fieldInfo != null)
+            { 
+                object newfunc = Delegate.RemoveAll((Delegate)fieldInfo.GetValue(target), (Delegate)func);
+                fieldInfo.SetValue(target, newfunc);
+                return true;
+            }
+            else
+            {
+                PropertyInfo propInfo = tAny.GetProperty(k, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.GetProperty | BindingFlags.GetField);
+                if (propInfo != null)
+                { 
+                    object newfunc = Delegate.RemoveAll((Delegate)fieldInfo.GetValue(target), (Delegate)func);
+                    propInfo.SetValue(target, newfunc, null);
+                    return true;
+                }
+            }
+
+            EventInfo eventInfo = tAny.GetEvent(k);
+            if (eventInfo != null)
+            { 
+                eventInfo.RemoveEventHandler(target, (Delegate)func);
+                return true;
+            }
+
+            return false;
+        }
+
+
+        //参数不能为 null , 只能是委托或 aardio 对象,这里不作判断
+        public static  object CombineDelegates(object a, object b)
+        {
+            Type ta = a.GetType();
+            Type tb = b.GetType();
+            bool da = typeof(Delegate).IsAssignableFrom(ta.BaseType);
+            bool db = typeof(Delegate).IsAssignableFrom(tb.BaseType);
+
+            if (da && tb.IsCOMObject)
+            {
+                var disp = new DispatchableDelegate(b);
+                return Delegate.Combine((Delegate)a, (Delegate)disp.CreateDelegate(ta));
+            }
+            else if (db && ta.IsCOMObject)
+            {
+                var disp = new DispatchableDelegate(a);
+                return Delegate.Combine((Delegate)disp.CreateDelegate(tb), (Delegate)b);
+            }
+            else if (da && db)
+            {
+                return Delegate.Combine((Delegate)a, (Delegate)b);
+            }
+            else
+            {
+                throw new Exception("Failed to combine delegates");
+            }
+        }
+
+        public static object RemoveDelegate(object a, object b)
+        {
+            Type ta = a.GetType();
+            Type tb = b.GetType();
+            bool da = typeof(Delegate).IsAssignableFrom(ta.BaseType);
+            bool db = typeof(Delegate).IsAssignableFrom(tb.BaseType);
+
+            if (da && db)
+            { 
+                return Delegate.RemoveAll((Delegate)a, (Delegate)b);
+            } 
+            else
+            {
+                throw new Exception("Failed to remove delegate");
+            }
+        }
+    }
+}