public static void MethodWithoutSafeMode(COMObject comObject, string name, object[] paramsArray)
{
try
{
comObject.InstanceType.InvokeMember(name, BindingFlags.InvokeMethod | BindingFlags.GetProperty, null, comObject.UnderlyingObject, paramsArray, Settings.ThreadCulture);
}
catch (Exception throwedException)
{
DebugConsole.WriteException(throwedException);
throw new System.Runtime.InteropServices.COMException(_exceptionMessage, throwedException);
}
}
/// <summary>
/// returns enumerator with scalar variables
/// </summary>
/// <param name="comObject"></param>
/// <returns></returns>
public static IEnumerator GetScalarEnumeratorAsProperty(COMObject comObject)
{
object enumProxy = Invoker.PropertyGet(comObject, "_NewEnum");
COMObject enumerator = new COMObject(comObject, enumProxy, true);
Invoker.MethodWithoutSafeMode(enumerator, "Reset", null);
bool isMoveNextTrue = (bool)Invoker.MethodReturnWithoutSafeMode(enumerator, "MoveNext", null);
while (true == isMoveNextTrue)
{
object item = Invoker.PropertyGetWithoutSafeMode(enumerator, "Current", null);
isMoveNextTrue = (bool)Invoker.MethodReturnWithoutSafeMode(enumerator, "MoveNext", null);
yield return item;
}
}
/// <summary>
/// returns enumerator with com proxies
/// </summary>
/// <param name="comObject"></param>
/// <returns></returns>
public static IEnumerator GetProxyEnumeratorAsMethod(COMObject comObject)
{
object enumProxy = Invoker.MethodReturn(comObject, "_NewEnum");
COMObject enumerator = new COMObject(comObject, enumProxy, true);
Invoker.MethodWithoutSafeMode(enumerator, "Reset", null);
bool isMoveNextTrue = (bool)Invoker.MethodReturnWithoutSafeMode(enumerator, "MoveNext", null);
while (true == isMoveNextTrue)
{
object itemProxy = Invoker.PropertyGetWithoutSafeMode(enumerator, "Current", null);
COMObject returnClass = LateBindingApi.Core.Factory.CreateObjectFromComProxy(enumerator, itemProxy);
isMoveNextTrue = (bool)Invoker.MethodReturnWithoutSafeMode(enumerator, "MoveNext", null);
yield return returnClass;
}
}
/// <summary>
/// perform method as latebind call with parameters
/// </summary>
/// <param name="comObject">target object</param>
/// <param name="name">name of method</param>
/// <param name="paramsArray">array with parameters</param>
public static void Method(COMObject comObject, string name, object[] paramsArray)
{
try
{
if( (Settings.EnableSafeMode) && (!comObject.EntityIsAvailable(name,SupportEntityType.Method)))
throw new EntityNotSupportedException(string.Format("Method {0} is not available.", name));
comObject.InstanceType.InvokeMember(name, BindingFlags.InvokeMethod | BindingFlags.GetProperty, null, comObject.UnderlyingObject, paramsArray, Settings.ThreadCulture);
}
catch (Exception throwedException)
{
DebugConsole.WriteException(throwedException);
throw new System.Runtime.InteropServices.COMException(_exceptionMessage, throwedException);
}
}
public COMObject(COMObject replacedObject)
{
// copy proxy
_underlyingObject = replacedObject.UnderlyingObject;
_parentObject = replacedObject.ParentObject;
_instanceType = replacedObject.InstanceType;
// copy childs
foreach (COMObject item in replacedObject.ListChildObjects)
AddChildObject(item);
// remove old object from parent chain
if (null != replacedObject.ParentObject)
{
COMObject parentObject = replacedObject.ParentObject;
parentObject.RemoveChildObject(replacedObject);
// add himself as child to parent object
parentObject.AddChildObject(this);
}
Factory.RemoveObjectFromList(replacedObject);
Factory.AddObjectToList(this);
}
/// <summary>
/// perform property set as latebind call
/// </summary>
/// <param name="comObject">target object</param>
/// <param name="name">name of property</param>
/// <param name="value">value array to be set</param>
/// <param name="paramModifiers">array with modifiers correspond paramsArray</param>
public static void PropertySet(COMObject comObject, string name, object[] value, ParameterModifier[] paramModifiers)
{
try
{
if ((Settings.EnableSafeMode) && (!comObject.EntityIsAvailable(name, SupportEntityType.Property)))
throw new EntityNotSupportedException(string.Format("Property {0} is not available.", name));
comObject.InstanceType.InvokeMember(name, BindingFlags.SetProperty, null, comObject.UnderlyingObject, value, paramModifiers, Settings.ThreadCulture, null);
}
catch (Exception throwedException)
{
DebugConsole.WriteException(throwedException);
throw new System.Runtime.InteropServices.COMException(_exceptionMessage, throwedException);
}
}
public static string GetConnectionPoint(COMObject comProxy, ref IConnectionPoint point, params string[] sinkIds)
{
if (null == sinkIds)
return null;
IConnectionPointContainer connectionPointContainer = (IConnectionPointContainer)comProxy.UnderlyingObject;
if (Settings.EnableDebugOutput)
DebugConsole.WriteLine(comProxy.UnderlyingTypeName + ".GetConnectionPoint");
if (Settings.EnableDebugOutput)
DebugConsole.WriteLine(comProxy.UnderlyingTypeName + ".FindConnectionPoint");
string id = FindConnectionPoint(connectionPointContainer, ref point, sinkIds);
if (Settings.EnableDebugOutput)
DebugConsole.WriteLine(comProxy.UnderlyingTypeName + ".FindConnectionPoint sucseed");
if (null == id)
{
if (Settings.EnableDebugOutput)
DebugConsole.WriteLine(comProxy.UnderlyingTypeName + ".EnumConnectionPoint");
id = EnumConnectionPoint(connectionPointContainer, ref point, sinkIds);
if (Settings.EnableDebugOutput)
DebugConsole.WriteLine(comProxy.UnderlyingTypeName + ".EnumConnectionPoint sucseed");
}
if (Settings.EnableDebugOutput)
DebugConsole.WriteLine(comProxy.UnderlyingTypeName + ".GetConnectionPoint passed.");
if (null != id)
return id;
else
throw new COMException("Specified instance doesnt implement the target event interface.");
}
/// <summary>
/// perform method as latebind call without parameters
/// </summary>
/// <param name="comObject">target object</param>
/// <param name="name">name of method</param>
public static void Method(COMObject comObject, string name)
{
Method(comObject, name, null);
}
/// <summary>
/// perform property set as latebind call
/// </summary>
/// <param name="comObject">target object</param>
/// <param name="name">name of property</param>
/// <param name="paramsArray">array with parameters</param>
/// <param name="value">value to be set</param>
public static void PropertySet(COMObject comObject, string name, object[] paramsArray, object value)
{
try
{
if ((Settings.EnableSafeMode) && (!comObject.EntityIsAvailable(name, SupportEntityType.Property)))
throw new EntityNotSupportedException(string.Format("Property {0} is not available.", name));
object[] newParamsArray = new object[paramsArray.Length + 1];
for (int i = 0; i < paramsArray.Length; i++)
newParamsArray[i] = paramsArray[i];
newParamsArray[newParamsArray.Length - 1] = value;
comObject.InstanceType.InvokeMember(name, BindingFlags.SetProperty, null, comObject.UnderlyingObject, newParamsArray, Settings.ThreadCulture);
}
catch (Exception throwedException)
{
DebugConsole.WriteException(throwedException);
throw new System.Runtime.InteropServices.COMException(_exceptionMessage, throwedException);
}
}
public IRibbonControl_SinkHelper(COMObject eventClass, IConnectionPoint connectPoint): base(eventClass)
{
_eventClass = eventClass;
_eventBinding = (IEventBinding)eventClass;
SetupEventBinding(connectPoint);
}
/// <summary>
/// perform property get as latebind call with return value
/// </summary>
/// <param name="comObject">target object</param>
/// <param name="name">name of property</param>
/// <returns>any return value</returns>
public static object PropertyGet(COMObject comObject, string name)
{
try
{
if ((Settings.EnableSafeMode) && (!comObject.EntityIsAvailable(name, SupportEntityType.Property)))
throw new EntityNotSupportedException(string.Format("Property {0} is not available.", name));
object returnValue = comObject.InstanceType.InvokeMember(name, BindingFlags.GetProperty, null, comObject.UnderlyingObject, null, Settings.ThreadCulture);
return returnValue;
}
catch (Exception throwedException)
{
DebugConsole.WriteException(throwedException);
throw new System.Runtime.InteropServices.COMException(_exceptionMessage, throwedException);
}
}
public Global(COMObject parentObject, object comProxy, NetRuntimeSystem.Type comProxyType) : base(parentObject, comProxy, comProxyType)
{
}
/// <summary>
/// creates a new COMObject array
/// </summary>
/// <param name="caller">parent there have created comProxy</param>
/// <param name="comProxyArray">new created proxy array</param>
/// <returns>corresponding Wrapper class Instance array or plain COMObject array</returns>
public static COMObject[] CreateObjectArrayFromComProxy(COMObject caller, object[] comProxyArray)
{
bool isLocked = false;
try
{
if (null == comProxyArray)
return null;
if (Settings.EnableThreadSafe)
{
Monitor.Enter(_comObjectLock);
isLocked = true;
}
Type comVariantType = null;
COMObject[] newVariantArray = new COMObject[comProxyArray.Length];
for (int i = 0; i < comProxyArray.Length; i++)
{
comVariantType = comProxyArray[i].GetType();
IFactoryInfo factoryInfo = GetFactoryInfo(comProxyArray[i]);
string className = TypeDescriptor.GetClassName(comProxyArray[i]);
string fullClassName = factoryInfo.AssemblyNamespace + "." + className;
newVariantArray[i] = CreateObjectFromComProxy(factoryInfo, caller, comProxyArray[i], comVariantType, className, fullClassName);
}
return newVariantArray;
}
catch (Exception throwedException)
{
DebugConsole.WriteException(throwedException);
throw throwedException;
}
finally
{
if (isLocked)
{
Monitor.Exit(_comObjectLock);
isLocked = false;
}
}
}
/// <summary>
/// NetOffice method: dispose instance and all child instances
/// </summary>
/// <param name="disposeEventBinding">dispose event exported proxies with one or more event recipients</param>
public virtual void Dispose(bool disposeEventBinding)
{
// in case object export events and
// disposeEventBinding == true we dont remove the object from parents child list
bool removeFromParent = true;
// set disposed flag
_isCurrentlyDisposing = true;
// in case of object implements also event binding we dispose them
IEventBinding eventBind = this as IEventBinding;
if (disposeEventBinding)
{
if (null != eventBind)
eventBind.DisposeEventBridge();
}
else
{
if ((null != eventBind) && (eventBind.EventBridgeInitialized))
removeFromParent = false;
}
// child proxy dispose
DisposeChildInstances(disposeEventBinding);
// remove himself from parent childlist
if ((null != _parentObject) && (true == removeFromParent))
{
_parentObject.RemoveChildObject(this);
_parentObject = null;
}
// call quit automaticly if wanted
if (_callQuitInDispose)
CallQuit(_underlyingObject);
// release proxy
ReleaseCOMProxy();
// clear supportList reference
_listSupportedEntities = null;
_isDisposed = true;
_isCurrentlyDisposing = false;
}
/// <summary>
/// creates a new COMObject based on classType of comProxy
/// </summary>
/// <param name="caller">parent there have created comProxy</param>
/// <param name="comProxy">new created proxy</param>
/// <param name="comProxyType">Type of comProxy</param>
/// <returns>corresponding Wrapper class Instance or plain COMObject</returns>
public static COMObject CreateObjectFromComProxy(COMObject caller, object comProxy, Type comProxyType)
{
bool isLocked = false;
try
{
if (null == comProxy)
return null;
if (Settings.EnableThreadSafe)
{
Monitor.Enter(_comObjectLock);
isLocked = true;
}
IFactoryInfo factoryInfo = GetFactoryInfo(comProxy);
string className = TypeDescriptor.GetClassName(comProxy);
string fullClassName = factoryInfo.AssemblyNamespace + "." + className;
// create new classType
COMObject newObject = CreateObjectFromComProxy(factoryInfo, caller, comProxy, comProxyType, className, fullClassName);
return newObject;
}
catch (Exception throwedException)
{
DebugConsole.WriteException(throwedException);
throw throwedException;
}
finally
{
if (isLocked)
{
Monitor.Exit(_comObjectLock);
isLocked = false;
}
}
}
public void RemoveChildObject(COMObject childObject)
{
bool isLocked = false;
try
{
_listChildObjects.Remove(childObject);
}
catch (Exception throwedException)
{
DebugConsole.WriteException(throwedException);
throw (throwedException);
}
finally
{
if (isLocked)
{
Monitor.Exit(_childListLock);
isLocked = false;
}
}
}
public void AddChildObject(COMObject childObject)
{
bool isLocked = false;
try
{
if (Settings.EnableThreadSafe)
{
Monitor.Enter(_childListLock);
isLocked = true;
}
_listChildObjects.Add(childObject);
}
catch (Exception throwedException)
{
DebugConsole.WriteException(throwedException);
throw (throwedException);
}
finally
{
if (isLocked)
{
Monitor.Exit(_childListLock);
isLocked = false;
}
}
}
public COMObject(COMObject parentObject, object comProxy, Type comProxyType)
{
_parentObject = parentObject;
_underlyingObject = comProxy;
_instanceType = comProxyType;
if (null != parentObject)
_parentObject.AddChildObject(this);
Factory.AddObjectToList(this);
}
public COMObject(COMObject parentObject, object comProxy, bool isEnumerator)
{
_parentObject = parentObject;
_underlyingObject = comProxy;
_isEnumerator = isEnumerator;
_instanceType = comProxy.GetType();
if (null != parentObject)
_parentObject.AddChildObject(this);
Factory.AddObjectToList(this);
}
/// <summary>
/// remove object from global list
/// </summary>
/// <param name="proxy"></param>
internal static void RemoveObjectFromList(COMObject proxy)
{
bool isLocked = false;
try
{
if (Settings.EnableThreadSafe)
{
Monitor.Enter(_globalObjectList);
isLocked = true;
}
_globalObjectList.Remove(proxy);
if (null != ProxyCountChanged)
ProxyCountChanged(_globalObjectList.Count);
}
catch (Exception throwedException)
{
DebugConsole.WriteException(throwedException);
}
finally
{
if (isLocked)
{
Monitor.Exit(_globalObjectList);
isLocked = false;
}
}
}
/// <param name="parentObject">object there has created the proxy</param>
/// <param name="comProxy">inner wrapped COM proxy</param>
public Global(COMObject parentObject, object comProxy) : base(parentObject, comProxy)
{
}
/// <summary>
/// creates a new COMObject array based on wrapperClassType
/// </summary>
/// <param name="caller"></param>
/// <param name="comProxyArray"></param>
/// <param name="wrapperClassType"></param>
/// <returns></returns>
public static COMObject[] CreateKnownObjectArrayFromComProxy(COMObject caller, object[] comProxyArray, Type wrapperClassType)
{
bool isLocked = false;
try
{
if (null == comProxyArray)
return null;
if (Settings.EnableThreadSafe)
{
Monitor.Enter(_comObjectLock);
isLocked = true;
}
Type comVariantType = null;
COMObject[] newVariantArray = new COMObject[comProxyArray.Length];
for (int i = 0; i < comProxyArray.Length; i++)
newVariantArray[i] = Activator.CreateInstance(wrapperClassType, new object[] { caller, comProxyArray[i], comVariantType }) as COMObject;
return newVariantArray;
}
catch (Exception throwedException)
{
DebugConsole.WriteException(throwedException);
throw throwedException;
}
finally
{
if (isLocked)
{
Monitor.Exit(_comObjectLock);
isLocked = false;
}
}
}
public Global(COMObject replacedObject) : base(replacedObject)
{
}
/// <summary>
/// creates a new COMObject from factoryInfo
/// </summary>
/// <param name="factoryInfo">Factory Info from Wrapper Assemblies</param>
/// <param name="caller">parent there have created comProxy</param>
/// <param name="comProxy">new created proxy</param>
/// <param name="comProxyType">Type of comProxy</param>
/// <param name="className">name of COMServer proxy class</param>
/// <param name="fullClassName">full namespace and name of COMServer proxy class</param>
/// <returns>corresponding Wrapper class Instance or plain COMObject</returns>
public static COMObject CreateObjectFromComProxy(IFactoryInfo factoryInfo, COMObject caller, object comProxy, Type comProxyType, string className, string fullClassName)
{
bool isLocked = false;
try
{
if (Settings.EnableThreadSafe)
{
Monitor.Enter(_comObjectLock);
isLocked = true;
}
Type classType = null;
if (true == _wrapperTypeCache.TryGetValue(fullClassName, out classType))
{
// cached classType
object newClass = Activator.CreateInstance(classType, new object[] { caller, comProxy });
return newClass as COMObject;
}
else
{
// create new classType
classType = factoryInfo.Assembly.GetType(fullClassName, false, true);
if (null == classType)
throw new ArgumentException("Class not exists: " + fullClassName);
_wrapperTypeCache.Add(fullClassName, classType);
COMObject newClass = Activator.CreateInstance(classType, new object[] { caller, comProxy, comProxyType }) as COMObject;
return newClass;
}
}
catch (Exception throwedException)
{
DebugConsole.WriteException(throwedException);
throw throwedException;
}
finally
{
if (isLocked)
{
Monitor.Exit(_comObjectLock);
isLocked = false;
}
}
}
/// <summary>
/// creates instance
/// </summary>
/// <param name="eventClass"></param>
public SinkHelper(COMObject eventClass)
{
_eventClass = eventClass;
}
/// <summary>
/// creates a new COMObject based on wrapperClassType
/// </summary>
/// <param name="caller"></param>
/// <param name="comProxy"></param>
/// <param name="wrapperClassType"></param>
/// <returns></returns>
public static COMObject CreateKnownObjectFromComProxy(COMObject caller, object comProxy, Type wrapperClassType)
{
bool isLocked = false;
try
{
if (null == comProxy)
return null;
if (Settings.EnableThreadSafe)
{
Monitor.Enter(_comObjectLock);
isLocked = true;
}
// create new proxyType
Type comProxyType = null;
if (false == _proxyTypeCache.TryGetValue(wrapperClassType.FullName, out comProxyType))
{
comProxyType = comProxy.GetType();
_proxyTypeCache.Add(wrapperClassType.FullName, comProxyType);
}
COMObject newClass = Activator.CreateInstance(wrapperClassType, new object[] { caller, comProxy, comProxyType }) as COMObject;
return newClass;
}
catch (Exception throwedException)
{
DebugConsole.WriteException(throwedException);
throw throwedException;
}
finally
{
if (isLocked)
{
Monitor.Exit(_comObjectLock);
isLocked = false;
}
}
}