272 lines
10 KiB
C#
272 lines
10 KiB
C#
#region Using Directives
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.Runtime.InteropServices;
|
|
using System.Reflection;
|
|
using System.Security.Permissions;
|
|
|
|
#endregion
|
|
|
|
namespace TestDispatchUtility
|
|
{
|
|
/// <summary>
|
|
/// Provides helper methods for working with COM IDispatch objects that have a registered type library.
|
|
/// </summary>
|
|
public static class DispatchUtility
|
|
{
|
|
#region Private Constants
|
|
|
|
private const int S_OK = 0; //From WinError.h
|
|
private const int LOCALE_SYSTEM_DEFAULT = 2 << 10; //From WinNT.h == 2048 == 0x800
|
|
|
|
#endregion
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Gets whether the specified object implements IDispatch.
|
|
/// </summary>
|
|
/// <param name="obj">An object to check.</param>
|
|
/// <returns>True if the object implements IDispatch. False otherwise.</returns>
|
|
public static bool ImplementsIDispatch(object obj)
|
|
{
|
|
bool result = obj is IDispatchInfo;
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a Type that can be used with reflection.
|
|
/// </summary>
|
|
/// <param name="obj">An object that implements IDispatch.</param>
|
|
/// <param name="throwIfNotFound">Whether an exception should be thrown if a Type can't be obtained.</param>
|
|
/// <returns>A .NET Type that can be used with reflection.</returns>
|
|
/// <exception cref="InvalidCastException">If <paramref name="obj"/> doesn't implement IDispatch.</exception>
|
|
[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
|
|
public static Type GetType(object obj, bool throwIfNotFound)
|
|
{
|
|
RequireReference(obj, "obj");
|
|
Type result = GetType((IDispatchInfo)obj, throwIfNotFound);
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tries to get the DISPID for the requested member name.
|
|
/// </summary>
|
|
/// <param name="obj">An object that implements IDispatch.</param>
|
|
/// <param name="name">The name of a member to lookup.</param>
|
|
/// <param name="dispId">If the method returns true, this holds the DISPID on output.
|
|
/// If the method returns false, this value should be ignored.</param>
|
|
/// <returns>True if the member was found and resolved to a DISPID. False otherwise.</returns>
|
|
/// <exception cref="InvalidCastException">If <paramref name="obj"/> doesn't implement IDispatch.</exception>
|
|
[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
|
|
public static bool TryGetDispId(object obj, string name, out int dispId)
|
|
{
|
|
RequireReference(obj, "obj");
|
|
bool result = TryGetDispId((IDispatchInfo)obj, name, out dispId);
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invokes a member by DISPID.
|
|
/// </summary>
|
|
/// <param name="obj">An object that implements IDispatch.</param>
|
|
/// <param name="dispId">The DISPID of a member. This can be obtained using
|
|
/// <see cref="TryGetDispId(object, string, out int)"/>.</param>
|
|
/// <param name="args">The arguments to pass to the member.</param>
|
|
/// <returns>The member's return value.</returns>
|
|
/// <remarks>
|
|
/// This can invoke a method or a property get accessor.
|
|
/// </remarks>
|
|
public static object Invoke(object obj, int dispId, object[] args)
|
|
{
|
|
string memberName = "[DispId=" + dispId + "]";
|
|
object result = Invoke(obj, memberName, args);
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Invokes a member by name.
|
|
/// </summary>
|
|
/// <param name="obj">An object.</param>
|
|
/// <param name="memberName">The name of the member to invoke.</param>
|
|
/// <param name="args">The arguments to pass to the member.</param>
|
|
/// <returns>The member's return value.</returns>
|
|
/// <remarks>
|
|
/// This can invoke a method or a property get accessor.
|
|
/// </remarks>
|
|
public static object Invoke(object obj, string memberName, object[] args)
|
|
{
|
|
RequireReference(obj, "obj");
|
|
Type type = obj.GetType();
|
|
object result = type.InvokeMember(memberName, BindingFlags.InvokeMethod | BindingFlags.GetProperty,
|
|
null, obj, args, null);
|
|
return result;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Private Methods
|
|
|
|
/// <summary>
|
|
/// Requires that the value is non-null.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of the value.</typeparam>
|
|
/// <param name="value">The value to check.</param>
|
|
/// <param name="name">The name of the value.</param>
|
|
private static void RequireReference<T>(T value, string name) where T : class
|
|
{
|
|
if (value == null)
|
|
{
|
|
throw new ArgumentNullException(name);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a Type that can be used with reflection.
|
|
/// </summary>
|
|
/// <param name="dispatch">An object that implements IDispatch.</param>
|
|
/// <param name="throwIfNotFound">Whether an exception should be thrown if a Type can't be obtained.</param>
|
|
/// <returns>A .NET Type that can be used with reflection.</returns>
|
|
private static Type GetType(IDispatchInfo dispatch, bool throwIfNotFound)
|
|
{
|
|
RequireReference(dispatch, "dispatch");
|
|
|
|
Type result = null;
|
|
int typeInfoCount;
|
|
int hr = dispatch.GetTypeInfoCount(out typeInfoCount);
|
|
if (hr == S_OK && typeInfoCount > 0)
|
|
{
|
|
// Type info isn't usually culture-aware for IDispatch, so we might as well pass
|
|
// the default locale instead of looking up the current thread's LCID each time
|
|
// (via CultureInfo.CurrentCulture.LCID).
|
|
dispatch.GetTypeInfo(0, LOCALE_SYSTEM_DEFAULT, out result);
|
|
}
|
|
|
|
if (result == null && throwIfNotFound)
|
|
{
|
|
// If the GetTypeInfoCount called failed, throw an exception for that.
|
|
Marshal.ThrowExceptionForHR(hr);
|
|
|
|
// Otherwise, throw the same exception that Type.GetType would throw.
|
|
throw new TypeLoadException();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tries to get the DISPID for the requested member name.
|
|
/// </summary>
|
|
/// <param name="dispatch">An object that implements IDispatch.</param>
|
|
/// <param name="name">The name of a member to lookup.</param>
|
|
/// <param name="dispId">If the method returns true, this holds the DISPID on output.
|
|
/// If the method returns false, this value should be ignored.</param>
|
|
/// <returns>True if the member was found and resolved to a DISPID. False otherwise.</returns>
|
|
private static bool TryGetDispId(IDispatchInfo dispatch, string name, out int dispId)
|
|
{
|
|
RequireReference(dispatch, "dispatch");
|
|
RequireReference(name, "name");
|
|
|
|
bool result = false;
|
|
|
|
// Members names aren't usually culture-aware for IDispatch, so we might as well
|
|
// pass the default locale instead of looking up the current thread's LCID each time
|
|
// (via CultureInfo.CurrentCulture.LCID).
|
|
Guid iidNull = Guid.Empty;
|
|
int hr = dispatch.GetDispId(ref iidNull, ref name, 1, LOCALE_SYSTEM_DEFAULT, out dispId);
|
|
|
|
const int DISP_E_UNKNOWNNAME = unchecked((int)0x80020006); //From WinError.h
|
|
const int DISPID_UNKNOWN = -1; //From OAIdl.idl
|
|
if (hr == S_OK)
|
|
{
|
|
result = true;
|
|
}
|
|
else if (hr == DISP_E_UNKNOWNNAME && dispId == DISPID_UNKNOWN)
|
|
{
|
|
// This is the only supported "error" case because it means IDispatch
|
|
// is saying it doesn't know the member we asked about.
|
|
result = false;
|
|
}
|
|
else
|
|
{
|
|
// The other documented result codes are all errors.
|
|
Marshal.ThrowExceptionForHR(hr);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Private Interfaces
|
|
|
|
/// <summary>
|
|
/// A partial declaration of IDispatch used to lookup Type information and DISPIDs.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// This interface only declares the first three methods of IDispatch. It omits the
|
|
/// fourth method (Invoke) because there are already plenty of ways to do dynamic
|
|
/// invocation in .NET. But the first three methods provide dynamic type metadata
|
|
/// discovery, which .NET doesn't provide normally if you have a System.__ComObject
|
|
/// RCW instead of a strongly-typed RCW.
|
|
/// <para/>
|
|
/// Note: The original declaration of IDispatch is in OAIdl.idl.
|
|
/// </remarks>
|
|
[ComImport]
|
|
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
|
|
[Guid("00020400-0000-0000-C000-000000000046")]
|
|
private interface IDispatchInfo
|
|
{
|
|
/// <summary>
|
|
/// Gets the number of Types that the object provides (0 or 1).
|
|
/// </summary>
|
|
/// <param name="typeInfoCount">Returns 0 or 1 for the number of Types provided by <see cref="GetTypeInfo"/>.</param>
|
|
/// <remarks>
|
|
/// http://msdn.microsoft.com/en-us/library/da876d53-cb8a-465c-a43e-c0eb272e2a12(VS.85)
|
|
/// </remarks>
|
|
[PreserveSig]
|
|
int GetTypeInfoCount(out int typeInfoCount);
|
|
|
|
/// <summary>
|
|
/// Gets the Type information for an object if <see cref="GetTypeInfoCount"/> returned 1.
|
|
/// </summary>
|
|
/// <param name="typeInfoIndex">Must be 0.</param>
|
|
/// <param name="lcid">Typically, LOCALE_SYSTEM_DEFAULT (2048).</param>
|
|
/// <param name="typeInfo">Returns the object's Type information.</param>
|
|
/// <remarks>
|
|
/// http://msdn.microsoft.com/en-us/library/cc1ec9aa-6c40-4e70-819c-a7c6dd6b8c99(VS.85)
|
|
/// </remarks>
|
|
void GetTypeInfo(int typeInfoIndex, int lcid, [MarshalAs(UnmanagedType.CustomMarshaler,
|
|
MarshalTypeRef = typeof(System.Runtime.InteropServices.CustomMarshalers.TypeToTypeInfoMarshaler))] out Type typeInfo);
|
|
|
|
/// <summary>
|
|
/// Gets the DISPID of the specified member name.
|
|
/// </summary>
|
|
/// <param name="riid">Must be IID_NULL. Pass a copy of Guid.Empty.</param>
|
|
/// <param name="name">The name of the member to look up.</param>
|
|
/// <param name="nameCount">Must be 1.</param>
|
|
/// <param name="lcid">Typically, LOCALE_SYSTEM_DEFAULT (2048).</param>
|
|
/// <param name="dispId">If a member with the requested <paramref name="name"/>
|
|
/// is found, this returns its DISPID and the method's return value is 0.
|
|
/// If the method returns a non-zero value, then this parameter's output value is
|
|
/// undefined.</param>
|
|
/// <returns>Zero for success. Non-zero for failure.</returns>
|
|
/// <remarks>
|
|
/// http://msdn.microsoft.com/en-us/library/6f6cf233-3481-436e-8d6a-51f93bf91619(VS.85)
|
|
/// </remarks>
|
|
[PreserveSig]
|
|
int GetDispId(ref Guid riid, ref string name, int nameCount, int lcid, out int dispId);
|
|
|
|
// NOTE: The real IDispatch also has an Invoke method next, but we don't need it.
|
|
// We can invoke methods using .NET's Type.InvokeMember method with the special
|
|
// [DISPID=n] syntax for member "names", or we can get a .NET Type using GetTypeInfo
|
|
// and invoke methods on that through reflection.
|
|
// Type.InvokeMember: http://msdn.microsoft.com/en-us/library/de3dhzwy.aspx
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|