private string GetTypeName(TYPEDESC desc, ITypeInfo info)
{
var vt = (VarEnum)desc.vt;
TYPEDESC tdesc;
switch (vt)
{
case VarEnum.VT_PTR:
tdesc = (TYPEDESC)Marshal.PtrToStructure(desc.lpValue, typeof(TYPEDESC));
return(GetTypeName(tdesc, info));
case VarEnum.VT_USERDEFINED:
unchecked
{
var href = desc.lpValue.ToInt32();
ITypeInfo refTypeInfo;
info.GetRefTypeInfo(href, out refTypeInfo);
return(GetTypeName(refTypeInfo));
}
case VarEnum.VT_CARRAY:
tdesc = (TYPEDESC)Marshal.PtrToStructure(desc.lpValue, typeof(TYPEDESC));
return(GetTypeName(tdesc, info) + "()");
default:
string result;
if (TypeNames.TryGetValue(vt, out result))
{
return(result);
}
break;
}
return("UNKNOWN");
}
private void AnalyzeElement(ITypeInfo typeInfo, System.Runtime.InteropServices.ComTypes.ELEMDESC elementDesc)
{
System.Runtime.InteropServices.ComTypes.TYPEDESC tdesc = elementDesc.tdesc;
while ((tdesc.vt == 0x1a) || (tdesc.vt == 0x1b))
{
tdesc = (System.Runtime.InteropServices.ComTypes.TYPEDESC)Marshal.PtrToStructure(tdesc.lpValue, typeof(System.Runtime.InteropServices.ComTypes.TYPEDESC));
}
if (tdesc.vt == 0x1d)
{
IntPtr lpValue = tdesc.lpValue;
IFixedTypeInfo ppTI = null;
try
{
((IFixedTypeInfo)typeInfo).GetRefTypeInfo(lpValue, out ppTI);
this.AnalyzeTypeInfo((ITypeInfo)ppTI);
}
finally
{
if (ppTI != null)
{
this.marshalReleaseComObject(ppTI);
}
}
}
}
private void GetParameterType(TYPEDESC desc, ITypeInfo info)
{
var vt = (VarEnum)desc.vt;
TYPEDESC tdesc;
switch (vt)
{
case VarEnum.VT_PTR:
tdesc = (TYPEDESC)Marshal.PtrToStructure(desc.lpValue, typeof(TYPEDESC));
GetParameterType(tdesc, info);
IsByRef = true;
break;
case VarEnum.VT_USERDEFINED:
int href;
unchecked
{
href = (int)(desc.lpValue.ToInt64() & 0xFFFFFFFF);
}
try
{
ITypeInfo refTypeInfo;
info.GetRefTypeInfo(href, out refTypeInfo);
IntPtr attribPtr;
refTypeInfo.GetTypeAttr(out attribPtr);
var attribs = (TYPEATTR)Marshal.PtrToStructure(attribPtr, typeof(TYPEATTR));
if (attribs.typekind == TYPEKIND.TKIND_ENUM)
{
_enumGuid = attribs.guid;
}
_type = new ComDocumentation(refTypeInfo, -1).Name;
refTypeInfo.ReleaseTypeAttr(attribPtr);
}
catch (COMException) { }
break;
case VarEnum.VT_SAFEARRAY:
case VarEnum.VT_CARRAY:
case VarEnum.VT_ARRAY:
tdesc = (TYPEDESC)Marshal.PtrToStructure(desc.lpValue, typeof(TYPEDESC));
GetParameterType(tdesc, info);
IsArray = true;
break;
default:
string result;
if (ComVariant.TypeNames.TryGetValue(vt, out result))
{
_type = result;
}
break;
}
}
internal static ComTypes.ITypeInfo GetRefTypeInfo(ComTypes.TYPEDESC tdesc, ComTypes.ITypeInfo context)
{
int href;
unchecked
{
href = (int)(tdesc.lpValue.ToInt64() & 0xFFFFFFFF);
}
ComTypes.ITypeInfo refTypeInfo;
context.GetRefTypeInfo(href, out refTypeInfo);
return(refTypeInfo);
}
protected string GetComType(ITypeInfo typeInfo, TYPEDESC typeDesc)
{
VarEnum varEnum = (VarEnum)typeDesc.vt;
switch (varEnum)
{
case VarEnum.VT_PTR:
TYPEDESC ptrTypedesc = (TYPEDESC)Marshal.PtrToStructure(typeDesc.lpValue, typeof(TYPEDESC));
return(GetComType(typeInfo, ptrTypedesc) + "*");
case VarEnum.VT_SAFEARRAY:
TYPEDESC arrayTypedesc = (TYPEDESC)Marshal.PtrToStructure(typeDesc.lpValue, typeof(TYPEDESC));
return(ComBrowserSettings.GetKeyword(VarEnum.VT_SAFEARRAY) + "("
+ GetComType(typeInfo, arrayTypedesc) + ")");
case VarEnum.VT_CARRAY:
TYPEDESC carrayTypedesc = (TYPEDESC)Marshal.PtrToStructure(typeDesc.lpValue, typeof(TYPEDESC));
return(GetComType(typeInfo, carrayTypedesc) + "[]");
case VarEnum.VT_USERDEFINED:
// The .NET definition of GetRefTypeInfo() incorrectly takes an int instead of IntPtr, which fails
// on 64-bit machines. At least don't throw an unhandled exception here.
if ((long)typeDesc.lpValue > int.MaxValue)
{
return("<GetRefTypeInfo bug>");
}
int hreftype = (int)typeDesc.lpValue;
ITypeInfo refTypeInfo;
try
{
typeInfo.GetRefTypeInfo(hreftype, out refTypeInfo);
}
catch (COMException)
{
return("<GetRefTypeInfo failed>");
}
try
{
return(Marshal.GetTypeInfoName(refTypeInfo));
}
finally
{
Marshal.ReleaseComObject(refTypeInfo);
}
default:
return(GetComType(varEnum));
}
}
private ComParameter GetParameterInfo(TYPEDESC desc, ITypeInfo info)
{
var vt = (VarEnum)desc.vt;
TYPEDESC tdesc;
switch (vt)
{
case VarEnum.VT_PTR:
tdesc = (TYPEDESC)Marshal.PtrToStructure(desc.lpValue, typeof(TYPEDESC));
var pointer = GetParameterInfo(tdesc, info);
pointer.IsByRef = true;
return(pointer);
case VarEnum.VT_USERDEFINED:
int href;
unchecked
{
href = (int)(desc.lpValue.ToInt64() & 0xFFFFFFFF);
}
try
{
ITypeInfo refTypeInfo;
info.GetRefTypeInfo(href, out refTypeInfo);
return(new ComParameter(GetTypeName(refTypeInfo), false));
}
catch (Exception)
{
return(new ComParameter("Object", false));
}
case VarEnum.VT_SAFEARRAY:
case VarEnum.VT_CARRAY:
case VarEnum.VT_ARRAY:
tdesc = (TYPEDESC)Marshal.PtrToStructure(desc.lpValue, typeof(TYPEDESC));
var array = GetParameterInfo(tdesc, info);
array.IsArray = true;
array.Name += "()";
return(array);
default:
string result;
if (TypeNames.TryGetValue(vt, out result))
{
return(new ComParameter(result, false));
}
break;
}
return(new ComParameter("Object", false));
}
private void GetFieldType(TYPEDESC desc, ITypeInfo info)
{
var vt = (VarEnum)desc.vt;
TYPEDESC tdesc;
if (vt == VarEnum.VT_PTR)
{
tdesc = Marshal.PtrToStructure <TYPEDESC>(desc.lpValue);
GetFieldType(tdesc, info);
}
else if (vt == VarEnum.VT_USERDEFINED)
{
int href;
unchecked
{
//The href is a long, but the size of lpValue depends on the platform, so truncate it after the lword.
href = (int)(desc.lpValue.ToInt64() & 0xFFFFFFFF);
}
try
{
info.GetRefTypeInfo(href, out ITypeInfo refTypeInfo);
refTypeInfo.GetTypeAttr(out IntPtr attribPtr);
using (DisposalActionContainer.Create(attribPtr, refTypeInfo.ReleaseTypeAttr))
{
var attribs = Marshal.PtrToStructure <TYPEATTR>(attribPtr);
if (attribs.typekind == TYPEKIND.TKIND_ENUM)
{
_enumGuid = attribs.guid;
}
IsReferenceType = ReferenceTypeKinds.Contains(attribs.typekind);
_valueType = new ComDocumentation(refTypeInfo, ComDocumentation.LibraryIndex).Name;
}
}
catch (COMException) { }
}
else if (vt == VarEnum.VT_SAFEARRAY || vt == VarEnum.VT_CARRAY || vt.HasFlag(VarEnum.VT_ARRAY))
{
tdesc = Marshal.PtrToStructure <TYPEDESC>(desc.lpValue);
GetFieldType(tdesc, info);
IsArray = true;
}
else
{
if (ComVariant.TypeNames.TryGetValue(vt, out string result))
{
_valueType = result;
}
}
}
public ComTypeInfo LookupUserDefined(System.Runtime.InteropServices.ComTypes.TYPEDESC typeDesc, ComTypeInfo comTypeInfo)
{
if (comTypeInfo == null)
{
return(null);
}
ITypeInfo refTypeInfo = null;
VarEnum variantType = (VarEnum)typeDesc.vt;
if (variantType == VarEnum.VT_USERDEFINED)
{
IFixedTypeInfo fixedTypeInfo = (IFixedTypeInfo)comTypeInfo.GetITypeInfo();
fixedTypeInfo.GetRefTypeInfo(typeDesc.lpValue, out refTypeInfo);
return(ComTypeManager.Instance.FromITypeInfo(refTypeInfo));
}
return(null);
}
public static string TypeDescToString(System.Runtime.InteropServices.ComTypes.TYPEDESC typeDesc, ITypeInfo typeInfo)
{
ITypeInfo refTypeInfo = null;
VarEnum variantType = (VarEnum)typeDesc.vt;
System.Runtime.InteropServices.ComTypes.TYPEDESC ptrTypeDesc;
switch (variantType)
{
case VarEnum.VT_PTR:
ptrTypeDesc = typeDesc.lpValue.ToStructure <System.Runtime.InteropServices.ComTypes.TYPEDESC>();
return(TypeDescToString(ptrTypeDesc, typeInfo));
case VarEnum.VT_USERDEFINED:
//int href = (int)(typeDesc.lpValue.ToInt64() & int.MaxValue);
//typeInfo.GetRefTypeInfo(href, out refTypeInfo);
IFixedTypeInfo fixedTypeInfo = (IFixedTypeInfo)typeInfo;
fixedTypeInfo.GetRefTypeInfo(typeDesc.lpValue, out refTypeInfo);
ComTypeInfo refComTypeInfo = ComTypeManager.Instance.FromITypeInfo(refTypeInfo);
return(refComTypeInfo.FullName);
case VarEnum.VT_SAFEARRAY:
string s = TypeDescToString(typeDesc.lpValue.ToStructure <System.Runtime.InteropServices.ComTypes.TYPEDESC>(), typeInfo);
return(String.Format("{0}[]", s));
case VarEnum.VT_VOID:
return("void");
default:
Type t = VariantTypeToType(variantType);
if (t != null)
{
return(t.Name);
}
break;
}
return("");
}
/// <summary>
/// Determine .net type for the given type descriptor.
/// </summary>
/// <param name="typedesc">COM type descriptor to convert.</param>
/// <returns>Type represented by the typedesc.</returns>
internal static Type GetTypeFromTypeDesc(COM.TYPEDESC typedesc)
{
VarEnum vt = (VarEnum)typedesc.vt;
return(VarEnumSelector.GetTypeForVarEnum(vt));
}
// Disable obsolete warning about VarEnum in CoreCLR
#pragma warning disable 618
/// <summary>
/// This function gets a string representation of the Type Descriptor
/// This is used in generating signature for Properties and Methods.
/// </summary>
/// <param name="typeinfo">Reference to the type info to which the type descriptor belongs.</param>
/// <param name="typedesc">Reference to type descriptor which is being converted to string from.</param>
/// <returns>String representation of the type descriptor.</returns>
private static string GetStringFromTypeDesc(COM.ITypeInfo typeinfo, COM.TYPEDESC typedesc)
{
if ((VarEnum)typedesc.vt == VarEnum.VT_PTR)
{
COM.TYPEDESC refdesc = Marshal.PtrToStructure <COM.TYPEDESC>(typedesc.lpValue);
return(GetStringFromTypeDesc(typeinfo, refdesc));
}
if ((VarEnum)typedesc.vt == VarEnum.VT_SAFEARRAY)
{
COM.TYPEDESC refdesc = Marshal.PtrToStructure <COM.TYPEDESC>(typedesc.lpValue);
return("SAFEARRAY(" + GetStringFromTypeDesc(typeinfo, refdesc) + ")");
}
if ((VarEnum)typedesc.vt == VarEnum.VT_USERDEFINED)
{
return(GetStringFromCustomType(typeinfo, typedesc.lpValue));
}
switch ((VarEnum)typedesc.vt)
{
case VarEnum.VT_I1:
return("char");
case VarEnum.VT_I2:
return("short");
case VarEnum.VT_I4:
case VarEnum.VT_INT:
case VarEnum.VT_HRESULT:
return("int");
case VarEnum.VT_I8:
return("int64");
case VarEnum.VT_R4:
return("float");
case VarEnum.VT_R8:
return("double");
case VarEnum.VT_UI1:
return("byte");
case VarEnum.VT_UI2:
return("ushort");
case VarEnum.VT_UI4:
case VarEnum.VT_UINT:
return("uint");
case VarEnum.VT_UI8:
return("uint64");
case VarEnum.VT_BSTR:
case VarEnum.VT_LPSTR:
case VarEnum.VT_LPWSTR:
return("string");
case VarEnum.VT_DATE:
return("Date");
case VarEnum.VT_BOOL:
return("bool");
case VarEnum.VT_CY:
return("currency");
case VarEnum.VT_DECIMAL:
return("decimal");
case VarEnum.VT_CLSID:
return("clsid");
case VarEnum.VT_DISPATCH:
return("IDispatch");
case VarEnum.VT_UNKNOWN:
return("IUnknown");
case VarEnum.VT_VARIANT:
return("Variant");
case VarEnum.VT_VOID:
return("void");
case VarEnum.VT_ARRAY:
return("object[]");
case VarEnum.VT_EMPTY:
return(string.Empty);
default:
return("Unknown!");
}
}
public VbaType GetVbaType(ComTypes.TYPEDESC tdesc, ComTypes.ITypeInfo context)
{
var vt = (VarEnum)tdesc.vt;
ComTypes.TYPEDESC tdesc2;
switch (vt)
{
case VarEnum.VT_PTR:
tdesc2 = (ComTypes.TYPEDESC)Marshal.PtrToStructure(tdesc.lpValue, typeof(ComTypes.TYPEDESC));
return(GetVbaType(tdesc2, context));
case VarEnum.VT_USERDEFINED:
if (context == null)
{
throw new InvalidOperationException($"{nameof(context)} is null. This is required for {VarEnum.VT_USERDEFINED}");
}
var refTypeInfo = ComHelper.GetRefTypeInfo(tdesc, context);
var loadedType = FindOrLoadType(refTypeInfo);
return(loadedType);
case VarEnum.VT_UNKNOWN:
var stdOleLib = _typeLibraries.LoadLibrary(TypeLibraries.StdOleLibGuid);
return(stdOleLib.UserDefinedTypes.First(t => t.Name == "IUnknown"));
case VarEnum.VT_CARRAY:
tdesc2 = (ComTypes.TYPEDESC)Marshal.PtrToStructure(tdesc.lpValue, typeof(ComTypes.TYPEDESC));
dynamic arrayType = GetVbaType(tdesc2, context);
return(Array.GetInstance(arrayType));
// lpValue is actually an ARRAYDESC structure containing dimension info.
case VarEnum.VT_BOOL:
return(Boolean.Instance);
case VarEnum.VT_LPSTR:
case VarEnum.VT_LPWSTR:
case VarEnum.VT_BSTR:
return(String.Instance);
case VarEnum.VT_ERROR:
case VarEnum.VT_INT:
case VarEnum.VT_I4:
return(Long.Instance);
case VarEnum.VT_I2:
return(Integer.Instance);
case VarEnum.VT_UINT:
case VarEnum.VT_UI4:
case VarEnum.VT_UI2:
return(UnsupportedVariant.Instance);
case VarEnum.VT_UI8:
case VarEnum.VT_I1:
case VarEnum.VT_VARIANT:
return(Variant.Instance);
case VarEnum.VT_UI1:
return(Byte.Instance);
case VarEnum.VT_R4:
return(Single.Instance);
case VarEnum.VT_R8:
return(Double.Instance);
case VarEnum.VT_DISPATCH:
case VarEnum.VT_BLOB:
case VarEnum.VT_STREAM:
case VarEnum.VT_STORAGE:
case VarEnum.VT_STREAMED_OBJECT:
case VarEnum.VT_STORED_OBJECT:
case VarEnum.VT_BLOB_OBJECT:
return(Object.Instance);
case VarEnum.VT_CY:
return(Currency.Instance);
case VarEnum.VT_DATE:
return(Date.Instance);
case VarEnum.VT_VOID:
return(Any.Instance);
case VarEnum.VT_HRESULT:
return(HResult.Instance); // TODO this should be removed, errors are returned as exceptions
case VarEnum.VT_SAFEARRAY:
return(SafeArray.Instance); // TODO should get more info for this type
case VarEnum.VT_DECIMAL:
// Currency?
case VarEnum.VT_I8:
// TODO this is a LongLong on 64 bit Office
case VarEnum.VT_NULL:
case VarEnum.VT_EMPTY:
case VarEnum.VT_CLSID:
case VarEnum.VT_RECORD:
case VarEnum.VT_FILETIME:
case VarEnum.VT_CF:
case VarEnum.VT_VECTOR:
case VarEnum.VT_ARRAY:
case VarEnum.VT_BYREF:
default:
throw new NotImplementedException();
}
}
private void GetParameterType(TYPEDESC desc, ITypeInfo info)
{
var vt = (VarEnum)desc.vt;
TYPEDESC tdesc;
if (vt == VarEnum.VT_PTR)
{
tdesc = Marshal.PtrToStructure <TYPEDESC>(desc.lpValue);
GetParameterType(tdesc, info);
IsByRef = true;
}
else if (vt == VarEnum.VT_USERDEFINED)
{
int href;
unchecked
{
href = (int)(desc.lpValue.ToInt64() & 0xFFFFFFFF);
}
try
{
info.GetRefTypeInfo(href, out ITypeInfo refTypeInfo);
refTypeInfo.GetTypeAttr(out IntPtr attribPtr);
using (DisposalActionContainer.Create(attribPtr, refTypeInfo.ReleaseTypeAttr))
{
var attribs = Marshal.PtrToStructure <TYPEATTR>(attribPtr);
var type = new ComDocumentation(refTypeInfo, ComDocumentation.LibraryIndex).Name;
if (attribs.typekind == TYPEKIND.TKIND_ENUM)
{
_typeName = new ComTypeName(Project, type, attribs.guid, Guid.Empty);
}
else if (attribs.typekind == TYPEKIND.TKIND_ALIAS)
{
_typeName = new ComTypeName(Project, type, Guid.Empty, attribs.guid);
}
else
{
_typeName = new ComTypeName(Project, type);
}
}
}
catch (COMException)
{
_typeName = new ComTypeName(Project, Tokens.Object);
}
}
else if (vt == VarEnum.VT_SAFEARRAY || vt == VarEnum.VT_CARRAY || vt.HasFlag(VarEnum.VT_ARRAY))
{
tdesc = Marshal.PtrToStructure <TYPEDESC>(desc.lpValue);
GetParameterType(tdesc, info);
IsArray = true;
}
else if (vt == VarEnum.VT_HRESULT)
{
_typeName = new ComTypeName(Project, Tokens.Long);
}
else
{
_typeName = new ComTypeName(Project, (ComVariant.TypeNames.TryGetValue(vt, out string result)) ? result : Tokens.Object);
}
}
private static IEnumerable <ITypeInfo> GetReferencedEnums(ITypeLib typeLib, ITypeInfo typeInfo, TYPEDESC typeDesc, Dictionary <Guid, ITypeInfo> processedTypeInfo)
{
if ((typeDesc.vt == (short)VarEnum.VT_PTR) || (typeDesc.vt == (short)VarEnum.VT_CARRAY))
{
return(GetReferencedEnums(typeLib, typeInfo, (TYPEDESC)Marshal.PtrToStructure(typeDesc.lpValue, typeof(TYPEDESC)), processedTypeInfo));
}
if (typeDesc.vt == (short)VarEnum.VT_USERDEFINED)
{
typeInfo.GetRefTypeInfo(unchecked ((int)typeDesc.lpValue.ToInt64()), out var refTypeInfo);
return(GetReferencedEnums(typeLib, refTypeInfo, processedTypeInfo));
}
return(Enumerable.Empty <ITypeInfo>());
}
private static string GetStringFromTypeDesc(ITypeInfo typeinfo, System.Runtime.InteropServices.ComTypes.TYPEDESC typedesc)
{
if (typedesc.vt == 0x1a)
{
System.Runtime.InteropServices.ComTypes.TYPEDESC typedesc2 = (System.Runtime.InteropServices.ComTypes.TYPEDESC)Marshal.PtrToStructure(typedesc.lpValue, typeof(System.Runtime.InteropServices.ComTypes.TYPEDESC));
return(GetStringFromTypeDesc(typeinfo, typedesc2));
}
if (typedesc.vt == 0x1b)
{
System.Runtime.InteropServices.ComTypes.TYPEDESC typedesc3 = (System.Runtime.InteropServices.ComTypes.TYPEDESC)Marshal.PtrToStructure(typedesc.lpValue, typeof(System.Runtime.InteropServices.ComTypes.TYPEDESC));
return("SAFEARRAY(" + GetStringFromTypeDesc(typeinfo, typedesc3) + ")");
}
if (typedesc.vt == 0x1d)
{
return(GetStringFromCustomType(typeinfo, typedesc.lpValue));
}
switch (((VarEnum)typedesc.vt))
{
case VarEnum.VT_EMPTY:
return("");
case VarEnum.VT_I2:
return("short");
case VarEnum.VT_I4:
case VarEnum.VT_INT:
case VarEnum.VT_HRESULT:
return("int");
case VarEnum.VT_R4:
return("float");
case VarEnum.VT_R8:
return("double");
case VarEnum.VT_CY:
return("currency");
case VarEnum.VT_DATE:
return("Date");
case VarEnum.VT_BSTR:
case VarEnum.VT_LPSTR:
case VarEnum.VT_LPWSTR:
return("string");
case VarEnum.VT_DISPATCH:
return("IDispatch");
case VarEnum.VT_BOOL:
return("bool");
case VarEnum.VT_VARIANT:
return("Variant");
case VarEnum.VT_UNKNOWN:
return("IUnknown");
case VarEnum.VT_DECIMAL:
return("decimal");
case VarEnum.VT_I1:
return("char");
case VarEnum.VT_UI1:
return("byte");
case VarEnum.VT_UI2:
return("ushort");
case VarEnum.VT_UI4:
case VarEnum.VT_UINT:
return("int");
case VarEnum.VT_I8:
return("int64");
case VarEnum.VT_UI8:
return("int64");
case VarEnum.VT_VOID:
return("void");
case VarEnum.VT_CLSID:
return("clsid");
case VarEnum.VT_ARRAY:
return("object[]");
}
return("Unknown!");
}
internal static Type GetTypeFromTypeDesc(System.Runtime.InteropServices.ComTypes.TYPEDESC typedesc)
{
switch (((VarEnum)typedesc.vt))
{
case VarEnum.VT_I2:
return(typeof(short));
case VarEnum.VT_I4:
case VarEnum.VT_INT:
case VarEnum.VT_HRESULT:
return(typeof(int));
case VarEnum.VT_R4:
return(typeof(float));
case VarEnum.VT_R8:
return(typeof(double));
case VarEnum.VT_CY:
case VarEnum.VT_DECIMAL:
return(typeof(decimal));
case VarEnum.VT_DATE:
return(typeof(DateTime));
case VarEnum.VT_BSTR:
case VarEnum.VT_LPSTR:
case VarEnum.VT_LPWSTR:
return(typeof(string));
case VarEnum.VT_BOOL:
return(typeof(bool));
case VarEnum.VT_I1:
return(typeof(sbyte));
case VarEnum.VT_UI1:
return(typeof(byte));
case VarEnum.VT_UI2:
return(typeof(ushort));
case VarEnum.VT_UI4:
case VarEnum.VT_UINT:
return(typeof(int));
case VarEnum.VT_I8:
return(typeof(long));
case VarEnum.VT_UI8:
return(typeof(ulong));
case VarEnum.VT_VOID:
return(typeof(void));
case VarEnum.VT_CLSID:
return(typeof(Guid));
case VarEnum.VT_ARRAY:
return(typeof(object[]));
}
return(typeof(object));
}
internal static Type GetTypeFromTypeDesc(System.Runtime.InteropServices.ComTypes.TYPEDESC typedesc)
{
Type type;
switch ((VarEnum)typedesc.vt)
{
case VarEnum.VT_I2:
type = typeof(short);
break;
case VarEnum.VT_I4:
case VarEnum.VT_INT:
case VarEnum.VT_HRESULT:
type = typeof(int);
break;
case VarEnum.VT_R4:
type = typeof(float);
break;
case VarEnum.VT_R8:
type = typeof(double);
break;
case VarEnum.VT_CY:
case VarEnum.VT_DECIMAL:
type = typeof(Decimal);
break;
case VarEnum.VT_DATE:
type = typeof(DateTime);
break;
case VarEnum.VT_BSTR:
case VarEnum.VT_LPSTR:
case VarEnum.VT_LPWSTR:
type = typeof(string);
break;
case VarEnum.VT_BOOL:
type = typeof(bool);
break;
case VarEnum.VT_I1:
type = typeof(sbyte);
break;
case VarEnum.VT_UI1:
type = typeof(byte);
break;
case VarEnum.VT_UI2:
type = typeof(ushort);
break;
case VarEnum.VT_UI4:
case VarEnum.VT_UINT:
type = typeof(uint);
break;
case VarEnum.VT_I8:
type = typeof(long);
break;
case VarEnum.VT_UI8:
type = typeof(ulong);
break;
case VarEnum.VT_VOID:
type = typeof(void);
break;
case VarEnum.VT_CLSID:
type = typeof(Guid);
break;
case VarEnum.VT_ARRAY:
type = typeof(object[]);
break;
default:
type = typeof(object);
break;
}
return(type);
}
