VARIANT
VARIANTARG describes arguments passed within DISPPARAMS, and VARIANT to specify variant data that cannot be passed by reference.
using System;
using System.CodeDom.Compiler;
using System.Diagnostics.CodeAnalysis;
using System.Private.Windows.Core.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using Windows.Win32.Foundation;
using Windows.Win32.System.Com;
using Windows.Win32.System.Com.StructuredStorage;
using Windows.Win32.System.Ole;
namespace Windows.Win32.System.Variant
{
[GeneratedCode("Microsoft.Windows.CsWin32", "0.3.151+58e949951d.RR")]
internal struct VARIANT : IDisposable
{
[StructLayout(LayoutKind.Explicit)]
[GeneratedCode("Microsoft.Windows.CsWin32", "0.3.151+58e949951d.RR")]
internal struct _Anonymous_e__Union
{
[GeneratedCode("Microsoft.Windows.CsWin32", "0.3.151+58e949951d.RR")]
internal struct _Anonymous_e__Struct
{
[StructLayout(LayoutKind.Explicit)]
[GeneratedCode("Microsoft.Windows.CsWin32", "0.3.151+58e949951d.RR")]
internal struct _Anonymous_e__Union
{
[GeneratedCode("Microsoft.Windows.CsWin32", "0.3.151+58e949951d.RR")]
internal struct _Anonymous_e__Struct
{
internal unsafe void* pvRecord;
internal unsafe IRecordInfo* pRecInfo;
}
[FieldOffset(0)]
public unsafe Guid* puuid;
[FieldOffset(0)]
public FILETIME filetime;
[FieldOffset(0)]
public CA ca;
[FieldOffset(0)]
internal long llVal;
[FieldOffset(0)]
internal int lVal;
[FieldOffset(0)]
internal byte bVal;
[FieldOffset(0)]
internal short iVal;
[FieldOffset(0)]
internal float fltVal;
[FieldOffset(0)]
internal double dblVal;
[FieldOffset(0)]
internal VARIANT_BOOL boolVal;
[FieldOffset(0)]
internal VARIANT_BOOL __OBSOLETE__VARIANT_BOOL;
[FieldOffset(0)]
internal int scode;
[FieldOffset(0)]
internal CY cyVal;
[FieldOffset(0)]
internal double date;
[FieldOffset(0)]
internal BSTR bstrVal;
[FieldOffset(0)]
internal unsafe IUnknown* punkVal;
[FieldOffset(0)]
internal unsafe IDispatch* pdispVal;
[FieldOffset(0)]
internal unsafe SAFEARRAY* parray;
[FieldOffset(0)]
internal unsafe byte* pbVal;
[FieldOffset(0)]
internal unsafe short* piVal;
[FieldOffset(0)]
internal unsafe int* plVal;
[FieldOffset(0)]
internal unsafe long* pllVal;
[FieldOffset(0)]
internal unsafe float* pfltVal;
[FieldOffset(0)]
internal unsafe double* pdblVal;
[FieldOffset(0)]
internal unsafe VARIANT_BOOL* pboolVal;
[FieldOffset(0)]
internal unsafe VARIANT_BOOL* __OBSOLETE__VARIANT_PBOOL;
[FieldOffset(0)]
internal unsafe int* pscode;
[FieldOffset(0)]
internal unsafe CY* pcyVal;
[FieldOffset(0)]
internal unsafe double* pdate;
[FieldOffset(0)]
internal unsafe BSTR* pbstrVal;
[FieldOffset(0)]
internal unsafe IUnknown** ppunkVal;
[FieldOffset(0)]
internal unsafe IDispatch** ppdispVal;
[FieldOffset(0)]
internal unsafe SAFEARRAY** pparray;
[FieldOffset(0)]
internal unsafe VARIANT* pvarVal;
[FieldOffset(0)]
internal unsafe void* byref;
[FieldOffset(0)]
internal CHAR cVal;
[FieldOffset(0)]
internal ushort uiVal;
[FieldOffset(0)]
internal uint ulVal;
[FieldOffset(0)]
internal ulong ullVal;
[FieldOffset(0)]
internal int intVal;
[FieldOffset(0)]
internal uint uintVal;
[FieldOffset(0)]
internal unsafe DECIMAL* pdecVal;
[FieldOffset(0)]
internal PSTR pcVal;
[FieldOffset(0)]
internal unsafe ushort* puiVal;
[FieldOffset(0)]
internal unsafe uint* pulVal;
[FieldOffset(0)]
internal unsafe ulong* pullVal;
[FieldOffset(0)]
internal unsafe int* pintVal;
[FieldOffset(0)]
internal unsafe uint* puintVal;
[FieldOffset(0)]
internal _Anonymous_e__Struct Anonymous;
}
internal VARENUM vt;
internal ushort wReserved1;
internal ushort wReserved2;
internal ushort wReserved3;
internal _Anonymous_e__Union Anonymous;
}
[FieldOffset(0)]
internal _Anonymous_e__Struct Anonymous;
[FieldOffset(0)]
internal DECIMAL decVal;
}
internal _Anonymous_e__Union Anonymous;
public static VARIANT Empty { get; }
public static VARIANT True { get; } = CreateBoolVariant(true);
public static VARIANT False { get; } = CreateBoolVariant(false);
public bool IsEmpty {
get {
if (vt == VARENUM.VT_EMPTY)
return data.llVal == 0;
return false;
}
}
public VARENUM Type => vt & VARENUM.VT_BSTR_BLOB;
public bool Byref => vt.HasFlag(VARENUM.VT_BYREF);
[UnscopedRef]
public ref VARENUM vt {
get {
return ref Anonymous.Anonymous.vt;
}
}
[UnscopedRef]
public ref _Anonymous_e__Union._Anonymous_e__Struct._Anonymous_e__Union data {
get {
return ref Anonymous.Anonymous.Anonymous;
}
}
private static VARIANT CreateBoolVariant(bool value)
{
VARIANT vARIANT = default(VARIANT);
vARIANT.vt = VARENUM.VT_BOOL;
VARIANT result = vARIANT;
result.data.boolVal = (value ? VARIANT_BOOL.VARIANT_TRUE : VARIANT_BOOL.VARIANT_FALSE);
return result;
}
public unsafe void Clear()
{
fixed (VARIANT* ptr = &this) {
void* pvar = ptr;
PInvokeCore.PropVariantClear((PROPVARIANT*)pvar);
}
Anonymous.Anonymous.vt = VARENUM.VT_EMPTY;
Anonymous.Anonymous.Anonymous = default(_Anonymous_e__Union._Anonymous_e__Struct._Anonymous_e__Union);
}
public void Dispose()
{
Clear();
}
[NullableContext(2)]
public unsafe object ToObject()
{
if (vt != VARENUM.VT_DECIMAL) {
fixed (VARIANT* ptr = &this) {
void* ptr2 = &ptr->Anonymous.Anonymous.Anonymous;
if (Byref) {
ptr2 = (void*)(long)(*(IntPtr*)ptr2);
if (ptr2 == null && Type != 0 && Type != VARENUM.VT_NULL)
throw new ArgumentException("Invalid Variant");
}
if ((int)(vt & ~(VARENUM.VT_VECTOR | VARENUM.VT_ARRAY | VARENUM.VT_BYREF)) >= 128)
throw new InvalidOleVariantTypeException();
if ((vt & VARENUM.VT_VECTOR) != 0)
return ToVector(ref ptr->data.ca, vt);
if ((vt & VARENUM.VT_ARRAY) != 0)
return ToArray((SAFEARRAY*)(long)(*(IntPtr*)ptr2), vt);
return ToObject(Type, Byref, ptr2);
}
}
return Anonymous.decVal.ToDecimal();
}
[return: Nullable(2)]
private unsafe static object ToObject(VARENUM type, bool byRef, void* data)
{
switch (type) {
case VARENUM.VT_EMPTY:
if (byRef) {
if (IntPtr.Size != 8)
return (uint)data;
return (ulong)data;
}
return null;
case VARENUM.VT_NULL:
return Convert.DBNull;
case VARENUM.VT_I1:
return *(sbyte*)data;
case VARENUM.VT_UI1:
return *(byte*)data;
case VARENUM.VT_I2:
return *(short*)data;
case VARENUM.VT_UI2:
return *(ushort*)data;
case VARENUM.VT_I4:
case VARENUM.VT_ERROR:
case VARENUM.VT_INT:
case VARENUM.VT_HRESULT:
return *(int*)data;
case VARENUM.VT_UI4:
case VARENUM.VT_UINT:
return *(uint*)data;
case VARENUM.VT_I8:
return *(long*)data;
case VARENUM.VT_UI8:
return (ulong)(*(long*)data);
case VARENUM.VT_R4:
return *(float*)data;
case VARENUM.VT_R8:
return *(double*)data;
case VARENUM.VT_CY:
return decimal.FromOACurrency(*(long*)data);
case VARENUM.VT_DATE:
return DateTime.FromOADate(*(double*)data);
case VARENUM.VT_BSTR:
case VARENUM.VT_LPWSTR:
return Marshal.PtrToStringUni(*(IntPtr*)data);
case VARENUM.VT_LPSTR:
return Marshal.PtrToStringAnsi(*(IntPtr*)data);
case VARENUM.VT_DISPATCH:
case VARENUM.VT_UNKNOWN: {
IUnknown* ptr = (IUnknown*)(long)(*(IntPtr*)data);
if (ptr == null)
return null;
return ComHelpers.GetObjectForIUnknown(ptr);
}
case VARENUM.VT_DECIMAL:
return ((DECIMAL*)data)->ToDecimal();
case VARENUM.VT_BOOL:
return *(VARIANT_BOOL*)data != VARIANT_BOOL.VARIANT_FALSE;
case VARENUM.VT_VARIANT:
if (byRef) {
if (((VARIANT*)data)->Byref)
throw new InvalidOleVariantTypeException();
return ((VARIANT*)data)->ToObject();
}
break;
case VARENUM.VT_CLSID:
if (!byRef)
return *(Guid*)(long)(*(IntPtr*)data);
break;
case VARENUM.VT_FILETIME:
if (!byRef)
return ((FILETIME*)data)->ToDateTime();
break;
case VARENUM.VT_VOID:
return null;
case VARENUM.VT_RECORD:
if (((_Anonymous_e__Union._Anonymous_e__Struct._Anonymous_e__Union._Anonymous_e__Struct*)data)->pRecInfo == null)
throw new ArgumentException("Specified OLE variant is invalid.");
if (((_Anonymous_e__Union._Anonymous_e__Struct._Anonymous_e__Union._Anonymous_e__Struct*)data)->pvRecord == null)
return null;
throw new ArgumentException("Record marshalling doesn't actually work in .NET Core. Matching that behaviour.");
}
throw new ArgumentException(string.Format(SR.COM2UnhandledVT, type));
}
[return: Nullable(1)]
private unsafe static Type GetRecordElementType(IRecordInfo* record)
{
Guid clsid = default(Guid);
record->GetGuid(&clsid);
Type typeFromCLSID = global::System.Type.GetTypeFromCLSID(clsid);
if ((object)typeFromCLSID == null || !typeFromCLSID.IsValueType)
throw new ArgumentException("The specified record cannot be mapped to a managed value class.");
return typeFromCLSID;
}
[return: Nullable(2)]
private unsafe static Array ToArray(SAFEARRAY* psa, VARENUM vt)
{
if (psa == null)
return null;
VARENUM vARENUM = vt & ~VARENUM.VT_ARRAY;
if (vARENUM != VARENUM.VT_RECORD) {
Array array = CreateArrayFromSafeArray(psa, vARENUM);
GCHandle gCHandle = default(GCHandle);
try {
gCHandle = GCHandle.Alloc(array, GCHandleType.Pinned);
} catch (ArgumentException) {
}
PInvokeCore.SafeArrayLock(psa);
try {
if (array.Rank == 1) {
switch (vARENUM) {
case VARENUM.VT_I1:
new Span<sbyte>(psa->pvData, array.Length).CopyTo(GetSpan<sbyte>(array));
return array;
case VARENUM.VT_UI1:
new Span<byte>(psa->pvData, array.Length).CopyTo(GetSpan<byte>(array));
return array;
case VARENUM.VT_I2:
new Span<short>(psa->pvData, array.Length).CopyTo(GetSpan<short>(array));
return array;
case VARENUM.VT_UI2:
new Span<ushort>(psa->pvData, array.Length).CopyTo(GetSpan<ushort>(array));
return array;
case VARENUM.VT_I4:
case VARENUM.VT_INT:
new Span<int>(psa->pvData, array.Length).CopyTo(GetSpan<int>(array));
return array;
case VARENUM.VT_ERROR:
case VARENUM.VT_UI4:
case VARENUM.VT_UINT:
new Span<uint>(psa->pvData, array.Length).CopyTo(GetSpan<uint>(array));
return array;
case VARENUM.VT_I8:
new Span<long>(psa->pvData, array.Length).CopyTo(GetSpan<long>(array));
return array;
case VARENUM.VT_UI8:
new Span<ulong>(psa->pvData, array.Length).CopyTo(GetSpan<ulong>(array));
return array;
case VARENUM.VT_R4:
new Span<float>(psa->pvData, array.Length).CopyTo(GetSpan<float>(array));
return array;
case VARENUM.VT_R8:
new Span<double>(psa->pvData, array.Length).CopyTo(GetSpan<double>(array));
return array;
case VARENUM.VT_BOOL: {
Span<VARIANT_BOOL> span3 = new Span<VARIANT_BOOL>(psa->pvData, array.Length);
Span<bool> span4 = GetSpan<bool>(array);
for (int j = 0; j < span3.Length; j++) {
span4[j] = (span3[j] != VARIANT_BOOL.VARIANT_FALSE);
}
return array;
}
case VARENUM.VT_DECIMAL: {
Span<DECIMAL> span13 = new Span<DECIMAL>(psa->pvData, array.Length);
Span<decimal> span14 = GetSpan<decimal>(array);
for (int num = 0; num < span13.Length; num++) {
span14[num] = span13[num].ToDecimal();
}
return array;
}
case VARENUM.VT_CY: {
Span<long> span11 = new Span<long>(psa->pvData, array.Length);
Span<decimal> span12 = GetSpan<decimal>(array);
for (int n = 0; n < span11.Length; n++) {
span12[n] = decimal.FromOACurrency(span11[n]);
}
return array;
}
case VARENUM.VT_DATE: {
Span<double> span9 = new Span<double>(psa->pvData, array.Length);
Span<DateTime> span10 = GetSpan<DateTime>(array);
for (int m = 0; m < span9.Length; m++) {
span10[m] = DateTime.FromOADate(span9[m]);
}
return array;
}
case VARENUM.VT_BSTR: {
Span<IntPtr> span7 = new Span<IntPtr>(psa->pvData, array.Length);
Span<string> span8 = GetSpan<string>(array);
for (int l = 0; l < span7.Length; l++) {
span8[l] = Marshal.PtrToStringUni(span7[l]);
}
return array;
}
case VARENUM.VT_DISPATCH:
case VARENUM.VT_UNKNOWN: {
Span<IntPtr> span5 = new Span<IntPtr>(psa->pvData, array.Length);
Span<object> span6 = GetSpan<object>(array);
for (int k = 0; k < span5.Length; k++) {
span6[k] = ((span5[k] == IntPtr.Zero) ? null : ComHelpers.GetObjectForIUnknown((IUnknown*)(long)span5[k]));
}
return array;
}
case VARENUM.VT_VARIANT: {
Span<VARIANT> span = new Span<VARIANT>(psa->pvData, array.Length);
Span<object> span2 = GetSpan<object>(array);
for (int i = 0; i < span.Length; i++) {
span2[i] = span[i].ToObject();
}
return array;
}
default:
throw new ArgumentException(string.Format(SR.COM2UnhandledVT, vt));
}
}
if (array.Length == 0)
return array;
TransposeArray(psa, array, vARENUM);
return array;
} finally {
if (gCHandle.IsAllocated)
gCHandle.Free();
PInvokeCore.SafeArrayUnlock(psa);
}
}
throw new ArgumentException(string.Format(SR.COM2UnhandledVT, vARENUM));
}
private unsafe static void TransposeArray(SAFEARRAY* psa, [Nullable(1)] Array array, VARENUM arrayType)
{
if (array.Rank <= 32)
<TransposeArray>g__StackTransposeArray|26_0(psa, array, arrayType);
else
<TransposeArray>g__HeapTransposeArray|26_1(psa, array, arrayType);
}
private unsafe static void SetArrayValue(SAFEARRAY* psa, [Nullable(1)] Array array, Span<int> indices, Span<int> lowerBounds, VARENUM arrayType)
{
switch (arrayType) {
case VARENUM.VT_I1:
<SetArrayValue>g__SetValue|27_0(array, psa->GetValue<sbyte>(indices), indices, lowerBounds);
break;
case VARENUM.VT_UI1:
<SetArrayValue>g__SetValue|27_0(array, psa->GetValue<byte>(indices), indices, lowerBounds);
break;
case VARENUM.VT_I2:
<SetArrayValue>g__SetValue|27_0(array, psa->GetValue<short>(indices), indices, lowerBounds);
break;
case VARENUM.VT_UI2:
<SetArrayValue>g__SetValue|27_0(array, psa->GetValue<ushort>(indices), indices, lowerBounds);
break;
case VARENUM.VT_I4:
case VARENUM.VT_INT:
<SetArrayValue>g__SetValue|27_0(array, psa->GetValue<int>(indices), indices, lowerBounds);
break;
case VARENUM.VT_ERROR:
case VARENUM.VT_UI4:
case VARENUM.VT_UINT:
<SetArrayValue>g__SetValue|27_0(array, psa->GetValue<uint>(indices), indices, lowerBounds);
break;
case VARENUM.VT_I8:
<SetArrayValue>g__SetValue|27_0(array, psa->GetValue<long>(indices), indices, lowerBounds);
break;
case VARENUM.VT_UI8:
<SetArrayValue>g__SetValue|27_0(array, psa->GetValue<ulong>(indices), indices, lowerBounds);
break;
case VARENUM.VT_R4:
<SetArrayValue>g__SetValue|27_0(array, psa->GetValue<float>(indices), indices, lowerBounds);
break;
case VARENUM.VT_R8:
<SetArrayValue>g__SetValue|27_0(array, psa->GetValue<double>(indices), indices, lowerBounds);
break;
case VARENUM.VT_BOOL: {
VARIANT_BOOL value5 = psa->GetValue<VARIANT_BOOL>(indices);
<SetArrayValue>g__SetValue|27_0(array, value5 != VARIANT_BOOL.VARIANT_FALSE, indices, lowerBounds);
break;
}
case VARENUM.VT_DECIMAL:
<SetArrayValue>g__SetValue|27_0(array, psa->GetValue<DECIMAL>(indices).ToDecimal(), indices, lowerBounds);
break;
case VARENUM.VT_CY: {
long value4 = psa->GetValue<long>(indices);
<SetArrayValue>g__SetValue|27_0(array, decimal.FromOACurrency(value4), indices, lowerBounds);
break;
}
case VARENUM.VT_DATE: {
double value3 = psa->GetValue<double>(indices);
<SetArrayValue>g__SetValue|27_0(array, DateTime.FromOADate(value3), indices, lowerBounds);
break;
}
case VARENUM.VT_BSTR: {
IntPtr value2 = psa->GetValue<IntPtr>(indices);
<SetArrayValue>g__SetValue|27_0(array, Marshal.PtrToStringUni(value2), indices, lowerBounds);
break;
}
case VARENUM.VT_DISPATCH:
case VARENUM.VT_UNKNOWN: {
IntPtr value = psa->GetValue<IntPtr>(indices);
if (value == IntPtr.Zero)
<SetArrayValue>g__SetValue|27_0<object>(array, null, indices, lowerBounds);
else
<SetArrayValue>g__SetValue|27_0(array, ComHelpers.GetObjectForIUnknown((IUnknown*)(long)value), indices, lowerBounds);
break;
}
case VARENUM.VT_VARIANT:
<SetArrayValue>g__SetValue|27_0(array, psa->GetValue<VARIANT>(indices).ToObject(), indices, lowerBounds);
break;
default:
throw new ArgumentException(string.Format(SR.COM2UnhandledVT, arrayType));
}
}
[return: Nullable(1)]
private unsafe static Array CreateArrayFromSafeArray(SAFEARRAY* psa, VARENUM vt)
{
if (vt == VARENUM.VT_EMPTY)
throw new InvalidOleVariantTypeException();
VARENUM varType = psa->VarType;
if (varType == VARENUM.VT_EMPTY) {
if (psa->cbElements != GetElementSizeForVarType(vt))
throw new SafeArrayTypeMismatchException();
} else if (varType != vt && (vt != VARENUM.VT_INT || varType != VARENUM.VT_I4) && (vt != VARENUM.VT_UINT || varType != VARENUM.VT_UI4) && (vt != VARENUM.VT_I4 || varType != VARENUM.VT_INT) && (vt != VARENUM.VT_UI4 || varType != VARENUM.VT_UINT) && (vt != VARENUM.VT_UNKNOWN || varType != VARENUM.VT_DISPATCH) && varType != VARENUM.VT_RECORD) {
throw new SafeArrayTypeMismatchException();
}
Type typeFromHandle;
switch (vt) {
case VARENUM.VT_I1:
typeFromHandle = typeof(sbyte);
break;
case VARENUM.VT_UI1:
typeFromHandle = typeof(byte);
break;
case VARENUM.VT_I2:
typeFromHandle = typeof(short);
break;
case VARENUM.VT_UI2:
typeFromHandle = typeof(ushort);
break;
case VARENUM.VT_I4:
case VARENUM.VT_INT:
typeFromHandle = typeof(int);
break;
case VARENUM.VT_I8:
typeFromHandle = typeof(long);
break;
case VARENUM.VT_UI8:
typeFromHandle = typeof(ulong);
break;
case VARENUM.VT_ERROR:
case VARENUM.VT_UI4:
case VARENUM.VT_UINT:
typeFromHandle = typeof(uint);
break;
case VARENUM.VT_R4:
typeFromHandle = typeof(float);
break;
case VARENUM.VT_R8:
typeFromHandle = typeof(double);
break;
case VARENUM.VT_BOOL:
typeFromHandle = typeof(bool);
break;
case VARENUM.VT_CY:
case VARENUM.VT_DECIMAL:
typeFromHandle = typeof(decimal);
break;
case VARENUM.VT_DATE:
typeFromHandle = typeof(DateTime);
break;
case VARENUM.VT_BSTR:
typeFromHandle = typeof(string);
break;
case VARENUM.VT_DISPATCH:
case VARENUM.VT_VARIANT:
case VARENUM.VT_UNKNOWN:
typeFromHandle = typeof(object);
break;
default:
throw new ArgumentException(string.Format(SR.COM2UnhandledVT, vt));
}
Type elementType = typeFromHandle;
if (psa->cDims == 1 && psa->GetBounds(0).lLbound == 0)
return Array.CreateInstance(elementType, (int)psa->GetBounds(0).cElements);
int[] array = new int[psa->cDims];
int[] array2 = new int[psa->cDims];
int num = 0;
for (int num2 = psa->cDims - 1; num2 >= 0; num2--) {
array[num] = (int)psa->GetBounds(num2).cElements;
array2[num] = psa->GetBounds(num2).lLbound;
num++;
}
return Array.CreateInstance(elementType, array, array2);
}
private unsafe static uint GetElementSizeForVarType(VARENUM vt)
{
switch (vt) {
case VARENUM.VT_EMPTY:
case VARENUM.VT_NULL:
case VARENUM.VT_VOID:
return 0;
case VARENUM.VT_I1:
case VARENUM.VT_UI1:
return 1;
case VARENUM.VT_I2:
case VARENUM.VT_BOOL:
case VARENUM.VT_UI2:
return 2;
case VARENUM.VT_I4:
case VARENUM.VT_R4:
case VARENUM.VT_ERROR:
case VARENUM.VT_UI4:
case VARENUM.VT_INT:
case VARENUM.VT_UINT:
case VARENUM.VT_HRESULT:
return 4;
case VARENUM.VT_R8:
case VARENUM.VT_CY:
case VARENUM.VT_DATE:
case VARENUM.VT_I8:
case VARENUM.VT_UI8:
return 8;
case VARENUM.VT_DECIMAL:
return (uint)sizeof(DECIMAL);
case VARENUM.VT_VARIANT:
return (uint)sizeof(VARIANT);
case VARENUM.VT_BSTR:
case VARENUM.VT_DISPATCH:
case VARENUM.VT_UNKNOWN:
case VARENUM.VT_PTR:
case VARENUM.VT_SAFEARRAY:
case VARENUM.VT_CARRAY:
case VARENUM.VT_USERDEFINED:
case VARENUM.VT_LPSTR:
case VARENUM.VT_LPWSTR:
return (uint)IntPtr.Size;
default:
if ((vt & VARENUM.VT_ARRAY) != 0)
return (uint)sizeof(SAFEARRAY*);
return 0;
}
}
[NullableContext(1)]
private unsafe static object ToVector([In] [IsReadOnly] ref CA ca, VARENUM vectorType)
{
VARENUM vARENUM = vectorType & ~VARENUM.VT_VECTOR;
switch (vARENUM) {
case VARENUM.VT_I1:
return new Span<sbyte>(ca.pElems, (int)ca.cElems).ToArray();
case VARENUM.VT_UI1:
return new Span<byte>(ca.pElems, (int)ca.cElems).ToArray();
case VARENUM.VT_I2:
return new Span<short>(ca.pElems, (int)ca.cElems).ToArray();
case VARENUM.VT_UI2:
return new Span<ushort>(ca.pElems, (int)ca.cElems).ToArray();
case VARENUM.VT_BOOL: {
Span<VARIANT_BOOL> span5 = new Span<VARIANT_BOOL>(ca.pElems, (int)ca.cElems);
bool[] array5 = new bool[span5.Length];
for (int m = 0; m < span5.Length; m++) {
array5[m] = (span5[m] != VARIANT_BOOL.VARIANT_FALSE);
}
return array5;
}
case VARENUM.VT_I4:
case VARENUM.VT_INT:
return new Span<int>(ca.pElems, (int)ca.cElems).ToArray();
case VARENUM.VT_ERROR:
case VARENUM.VT_UI4:
case VARENUM.VT_UINT:
return new Span<uint>(ca.pElems, (int)ca.cElems).ToArray();
case VARENUM.VT_I8:
return new Span<long>(ca.pElems, (int)ca.cElems).ToArray();
case VARENUM.VT_UI8:
return new Span<ulong>(ca.pElems, (int)ca.cElems).ToArray();
case VARENUM.VT_R4:
return new Span<float>(ca.pElems, (int)ca.cElems).ToArray();
case VARENUM.VT_R8:
return new Span<double>(ca.pElems, (int)ca.cElems).ToArray();
case VARENUM.VT_CY: {
Span<long> span7 = new Span<long>(ca.pElems, (int)ca.cElems);
decimal[] array7 = new decimal[span7.Length];
for (int num = 0; num < span7.Length; num++) {
array7[num] = decimal.FromOACurrency(span7[num]);
}
return array7;
}
case VARENUM.VT_DATE: {
Span<double> span6 = new Span<double>(ca.pElems, (int)ca.cElems);
DateTime[] array6 = new DateTime[span6.Length];
for (int n = 0; n < span6.Length; n++) {
array6[n] = DateTime.FromOADate(span6[n]);
}
return array6;
}
case VARENUM.VT_FILETIME: {
Span<FILETIME> span4 = new Span<FILETIME>(ca.pElems, (int)ca.cElems);
DateTime[] array4 = new DateTime[span4.Length];
for (int l = 0; l < span4.Length; l++) {
array4[l] = span4[l].ToDateTime();
}
return array4;
}
case VARENUM.VT_CLSID:
return new Span<Guid>(ca.pElems, (int)ca.cElems).ToArray();
case VARENUM.VT_BSTR:
case VARENUM.VT_LPWSTR: {
Span<IntPtr> span3 = new Span<IntPtr>(ca.pElems, (int)ca.cElems);
string[] array3 = new string[span3.Length];
for (int k = 0; k < span3.Length; k++) {
array3[k] = Marshal.PtrToStringUni(span3[k]);
}
return array3;
}
case VARENUM.VT_LPSTR: {
Span<IntPtr> span2 = new Span<IntPtr>(ca.pElems, (int)ca.cElems);
string[] array2 = new string[span2.Length];
for (int j = 0; j < span2.Length; j++) {
array2[j] = Marshal.PtrToStringAnsi(span2[j]);
}
return array2;
}
case VARENUM.VT_VARIANT: {
Span<VARIANT> span = new Span<VARIANT>(ca.pElems, (int)ca.cElems);
object[] array = new object[span.Length];
for (int i = 0; i < span.Length; i++) {
array[i] = span[i].ToObject();
}
return array;
}
default:
throw new ArgumentException(string.Format(SR.COM2UnhandledVT, vARENUM));
}
}
[NullableContext(1)]
[return: Nullable(new byte[] {
0,
1
})]
private unsafe static Span<T> GetSpan<[Nullable(2)] T>(Array array)
{
return MemoryMarshal.CreateSpan(ref Unsafe.AsRef<T>(Marshal.UnsafeAddrOfPinnedArrayElement(array, 0).ToPointer()), array.Length);
}
public static explicit operator bool(VARIANT value)
{
if (value.vt != VARENUM.VT_BOOL)
return ThrowInvalidCast<bool>();
return value.data.boolVal != VARIANT_BOOL.VARIANT_FALSE;
}
public static explicit operator VARIANT(bool value)
{
if (!value)
return False;
return True;
}
public static explicit operator short(VARIANT value)
{
if (value.vt != VARENUM.VT_I2)
return ThrowInvalidCast<short>();
return value.data.iVal;
}
public static explicit operator VARIANT(short value)
{
VARIANT result = default(VARIANT);
result.vt = VARENUM.VT_I2;
result.data = new _Anonymous_e__Union._Anonymous_e__Struct._Anonymous_e__Union {
iVal = value
};
return result;
}
public static explicit operator int(VARIANT value)
{
VARENUM vt = value.vt;
if ((vt != VARENUM.VT_I4 && vt != VARENUM.VT_INT) || 1 == 0)
return ThrowInvalidCast<int>();
return value.data.intVal;
}
public static explicit operator VARIANT(int value)
{
VARIANT result = default(VARIANT);
result.vt = VARENUM.VT_I4;
result.data = new _Anonymous_e__Union._Anonymous_e__Struct._Anonymous_e__Union {
intVal = value
};
return result;
}
public static explicit operator uint(VARIANT value)
{
VARENUM vt = value.vt;
if ((vt != VARENUM.VT_UI4 && vt != VARENUM.VT_UINT) || 1 == 0)
return ThrowInvalidCast<uint>();
return value.data.uintVal;
}
public static explicit operator VARIANT(uint value)
{
VARIANT result = default(VARIANT);
result.vt = VARENUM.VT_UI4;
result.data = new _Anonymous_e__Union._Anonymous_e__Struct._Anonymous_e__Union {
uintVal = value
};
return result;
}
public static explicit operator BSTR(VARIANT value)
{
if (value.vt != VARENUM.VT_BSTR)
return ThrowInvalidCast<BSTR>();
return value.data.bstrVal;
}
public static explicit operator VARIANT(string value)
{
VARIANT result = default(VARIANT);
result.vt = VARENUM.VT_BSTR;
result.data = new _Anonymous_e__Union._Anonymous_e__Struct._Anonymous_e__Union {
bstrVal = new BSTR(value)
};
return result;
}
public static explicit operator VARIANT(BSTR value)
{
VARIANT result = default(VARIANT);
result.vt = VARENUM.VT_BSTR;
result.data = new _Anonymous_e__Union._Anonymous_e__Struct._Anonymous_e__Union {
bstrVal = value
};
return result;
}
public static explicit operator CY(VARIANT value)
{
if (value.vt != VARENUM.VT_CY)
return ThrowInvalidCast<CY>();
return value.data.cyVal;
}
public static explicit operator decimal(VARIANT value)
{
switch (value.vt) {
case VARENUM.VT_DECIMAL:
return value.Anonymous.decVal.ToDecimal();
case VARENUM.VT_CY:
return decimal.FromOACurrency(value.data.cyVal.int64);
default:
return ThrowInvalidCast<decimal>();
}
}
public unsafe static explicit operator VARIANT(IUnknown* value)
{
VARIANT result = default(VARIANT);
result.vt = VARENUM.VT_UNKNOWN;
result.data = new _Anonymous_e__Union._Anonymous_e__Struct._Anonymous_e__Union {
punkVal = value
};
return result;
}
public unsafe static explicit operator IUnknown*(VARIANT value)
{
if (value.vt != VARENUM.VT_UNKNOWN)
throw new InvalidCastException();
return value.data.punkVal;
}
public static explicit operator double(VARIANT value)
{
if (value.vt != VARENUM.VT_R8)
return ThrowInvalidCast<double>();
return value.data.dblVal;
}
public static explicit operator VARIANT(double value)
{
VARIANT result = default(VARIANT);
result.vt = VARENUM.VT_R8;
result.data = new _Anonymous_e__Union._Anonymous_e__Struct._Anonymous_e__Union {
dblVal = value
};
return result;
}
[MethodImpl(MethodImplOptions.NoInlining)]
[NullableContext(1)]
private static T ThrowInvalidCast<[Nullable(2)] T>()
{
throw new InvalidCastException();
}
[NullableContext(2)]
public unsafe static VARIANT FromObject(object value)
{
if (value == null)
return Empty;
string text = value as string;
if (text != null)
return (VARIANT)text;
if (value is bool) {
bool value2 = (bool)value;
return (VARIANT)value2;
}
if (value is short) {
short value3 = (short)value;
return (VARIANT)value3;
}
if (value is int) {
int value4 = (int)value;
return (VARIANT)value4;
}
if (value is uint) {
uint value5 = (uint)value;
return (VARIANT)value5;
}
if (value is double) {
double value6 = (double)value;
return (VARIANT)value6;
}
VARIANT result = default(VARIANT);
Marshal.GetNativeVariantForObject(value, (IntPtr)(&result));
return result;
}
}
}