C# 提高SAFEARRAY自定义封送拆收器的性能

我为SAFEARRAY编写了一个自定义封送拆收器，但它的性能大约比默认封送拆收器的性能低两倍。我逐个元素执行数组的封送处理，因为它们可能有超过1-2个维度。我使用了一段代码。我可以提高我的封送员的绩效吗

void ArrayIterator::GetValue(Array^ pManagedArray, Object^% managedObject)
{
    managedObject = pManagedArray->GetValue(m_pManagedArrayIndices);
}

void ArrayIterator::GetValue(SAFEARRAY* pNativeArray, LPVOID* ppNativeValue)
{
    CHECK_HR(::SafeArrayLock(pNativeArray));
    CHECK_HR(::SafeArrayPtrOfIndex(pNativeArray, m_pNativeArrayIndices, ppNativeValue));
    CHECK_HR(::SafeArrayUnlock(pNativeArray));
}

void ArrayIterator::SetValue(Array^ pManagedArray, Object^ managedValue)
{
    pManagedArray->SetValue(managedValue, m_pManagedArrayIndices);
}

void ArrayIterator::SetValue(SAFEARRAY* pNativeArray, LPVOID pNativeValue)
{
    CHECK_HR(::SafeArrayPutElement(pNativeArray, m_pNativeArrayIndices, pNativeValue));
}

void SafeArrayMarshaler::PutManagedElementToNativeArray(SAFEARRAY* pNativeArray, ArrayIterator^ pArrayIterator, ArrayElementType^ pArrayElementType, Object^ pManagedObject)
{
    if (IsBlittableType(pArrayElementType->ManagedType))
    {
        GCHandle^ gcHandle = GCHandle::Alloc(pManagedObject, GCHandleType::Pinned);

        pArrayIterator->SetValue(pNativeArray, gcHandle->AddrOfPinnedObject().ToPointer());

        gcHandle->Free();
    }        
    else if (pArrayElementType->NativeType == VT_BOOL)
    {
        Boolean managedBooleanValue = safe_cast<Boolean>(pManagedObject);
        IntPtr nativeBoolPointer = Marshal::AllocHGlobal(sizeof(VARIANT_BOOL));
        VARIANT_BOOL* pNativeBool = reinterpret_cast<VARIANT_BOOL*>(nativeBoolPointer.ToPointer());

        *pNativeBool = managedBooleanValue == true ? VARIANT_TRUE : VARIANT_FALSE;

        pArrayIterator->SetValue(pNativeArray, pNativeBool);

        Marshal::FreeHGlobal(nativeBoolPointer);
    }
    else if (pArrayElementType->NativeType == VT_DATE)
    {
        DateTime managedDateValue = safe_cast<DateTime>(pManagedObject);
        IntPtr nativeDatePointer = Marshal::AllocHGlobal(sizeof(DATE));
        DATE* pNativeDate = reinterpret_cast<DATE*>(nativeDatePointer.ToPointer());

        *pNativeDate = managedDateValue.ToOADate();

        pArrayIterator->SetValue(pNativeArray, pNativeDate);

        Marshal::FreeHGlobal(nativeDatePointer);
    }
    else if (pArrayElementType->NativeType == VT_BSTR)
    {
        IntPtr nativeBSTRHandle = Marshal::StringToBSTR(safe_cast<String^>(pManagedObject));

        pArrayIterator->SetValue(pNativeArray, nativeBSTRHandle.ToPointer());

        Marshal::FreeBSTR(nativeBSTRHandle);
    }
    else if (pArrayElementType->NativeType == VT_INT)
    {
        IntPtr managedPointer = safe_cast<IntPtr>(pManagedObject);

        pArrayIterator->SetValue(pNativeArray, managedPointer.ToPointer());
    }
    else if (pArrayElementType->NativeType == VT_UINT)
    {
        UIntPtr managedPointer = safe_cast<UIntPtr>(pManagedObject);

        pArrayIterator->SetValue(pNativeArray, managedPointer.ToPointer());
    }
    else if (pArrayElementType->NativeType == VT_DISPATCH)
    {
        IntPtr nativeInterfacePointer = Marshal::GetIDispatchForObject(pManagedObject);

        pArrayIterator->SetValue(pNativeArray, nativeInterfacePointer.ToPointer());

        Marshal::Release(nativeInterfacePointer);
    }
    else if (pArrayElementType->NativeType == VT_UNKNOWN)
    {
        IntPtr nativeInterfacePointer = Marshal::GetIUnknownForObject(pManagedObject);

        pArrayIterator->SetValue(pNativeArray, nativeInterfacePointer.ToPointer());

        Marshal::Release(nativeInterfacePointer);
    }
    else if (pArrayElementType->NativeType == VT_VARIANT)
    {
        IntPtr nativeVariantHandle = Marshal::AllocHGlobal(sizeof(VARIANT));

        Marshal::GetNativeVariantForObject(pManagedObject, nativeVariantHandle);

        pArrayIterator->SetValue(pNativeArray, nativeVariantHandle.ToPointer());

        Marshal::FreeHGlobal(nativeVariantHandle);
    }
    else
    {
        throw gcnew InvalidOperationException();
    }
}

void SafeArrayMarshaler::PutNativeElementToManagedArray(Array^ pManagedArray, ArrayIterator^ pArrayIterator, ArrayElementType^ pArrayElementType, LPVOID pNativeObject)
{
    if (IsBlittableType(pArrayElementType->ManagedType))
    {
        switch (Type::GetTypeCode(pArrayElementType->ManagedType))
        {
            case TypeCode::SByte:
            {
                SByte managedSignedByte = Marshal::ReadByte(IntPtr(pNativeObject));
                pArrayIterator->SetValue(pManagedArray, managedSignedByte);
                break;
            }

            case TypeCode::Byte:
            {
                Byte managedUnsignedByte = Marshal::ReadByte(IntPtr(pNativeObject));
                pArrayIterator->SetValue(pManagedArray, managedUnsignedByte);
                break;
            }

            case TypeCode::Int16:
            {
                Int16 managedValue = Marshal::ReadInt16(IntPtr(pNativeObject));
                pArrayIterator->SetValue(pManagedArray, managedValue);
                break;
            }

            case TypeCode::UInt16:
            {
                UInt16 managedValue = Marshal::ReadInt16(IntPtr(pNativeObject));
                pArrayIterator->SetValue(pManagedArray, managedValue);
                break;
            }

            case TypeCode::Int32:
            {
                Int32 managedValue = Marshal::ReadInt32(IntPtr(pNativeObject));
                pArrayIterator->SetValue(pManagedArray, managedValue);
                break;
            }

            case TypeCode::UInt32:
            {
                UInt32 managedValue = Marshal::ReadInt32(IntPtr(pNativeObject));
                pArrayIterator->SetValue(pManagedArray, managedValue);
                break;
            }

            case TypeCode::Int64:
            {
                Int64 managedValue = Marshal::ReadInt64(IntPtr(pNativeObject));
                pArrayIterator->SetValue(pManagedArray, managedValue);
                break;
            }

            case TypeCode::UInt64:
            {
                UInt64 managedValue = Marshal::ReadInt64(IntPtr(pNativeObject));
                pArrayIterator->SetValue(pManagedArray, managedValue);
                break;
            }

            case TypeCode::Single:
            {
                Single managedValue;
                pin_ptr<Single> pManagedValue = &managedValue;

                ::memcpy_s(pManagedValue, Marshal::SizeOf(Single::typeid), pNativeObject, Marshal::SizeOf(Single::typeid));
                pArrayIterator->SetValue(pManagedArray, managedValue);
                break;
            }

            case TypeCode::Double:
            {
                Double managedValue;
                pin_ptr<Double> pManagedValue = &managedValue;

                ::memcpy_s(pManagedValue, Marshal::SizeOf(Double::typeid), pNativeObject, Marshal::SizeOf(Double::typeid));
                pArrayIterator->SetValue(pManagedArray, managedValue);
                break;
            }

            default:
                throw gcnew NotImplementedException();
        }
    }
    else if (pArrayElementType->NativeType == VT_BOOL)
    {
        VARIANT_BOOL* pNativeBooleanValue = reinterpret_cast<VARIANT_BOOL*>(pNativeObject);

        pArrayIterator->SetValue(pManagedArray, *pNativeBooleanValue == VARIANT_TRUE ? true : false);
    }
    else if (pArrayElementType->NativeType == VT_DATE)
    {
        DATE* pNativeDateValue = reinterpret_cast<DATE*>(pNativeObject);

        pArrayIterator->SetValue(pManagedArray, DateTime::FromOADate(*pNativeDateValue));
    }
    else if (pArrayElementType->NativeType == VT_BSTR)
    {
        String^ pManagedString = Marshal::PtrToStringBSTR(IntPtr(*reinterpret_cast<void**>(pNativeObject)));

        pArrayIterator->SetValue(pManagedArray, pManagedString);
    }
    else if (pArrayElementType->NativeType == VT_INT)
    {
        INT_PTR nativePointer = reinterpret_cast<INT_PTR>(pNativeObject);

        pArrayIterator->SetValue(pManagedArray, IntPtr(nativePointer));
    }
    else if (pArrayElementType->NativeType == VT_UINT)
    {
        UINT_PTR nativePointer = reinterpret_cast<UINT_PTR>(pNativeObject);

        pArrayIterator->SetValue(pManagedArray, UIntPtr(nativePointer));
    }
    else if (pArrayElementType->NativeType == VT_DISPATCH ||
             pArrayElementType->NativeType == VT_UNKNOWN)
    {
        Object^ pManagedObject = Marshal::GetObjectForIUnknown(IntPtr(*reinterpret_cast<void**>(pNativeObject)));

        pArrayIterator->GetValue(pManagedArray, pManagedObject);
    }
    else if (pArrayElementType->NativeType == VT_VARIANT)
    {
        Object^ pManagedObject = Marshal::GetObjectForNativeVariant(IntPtr(pNativeObject));

        pArrayIterator->SetValue(pManagedArray, pManagedObject);
    }
    else
    {
        throw gcnew InvalidOperationException();
    }
}

void ArrayIterator:：GetValue（数组^pManagedArray，对象^%managedObject）
{
managedObject=pManagedArray->GetValue（m_pManagedArray索引）；
}
void ArrayIterator:：GetValue（安全数组*pNativeArray，LPVOID*pNativeValue）
{
检查人力资源（：：安全防盗锁（PNATIVEARLAY））；
检查人力资源（：：安全arrayProfIndex（pNativeArray、m_pNativeArrayIndex、pNativeValue））；
检查人力资源（：：安全阵列锁定（pNativeArray））；
}
void ArrayIterator:：SetValue（数组^pManagedArray，对象^managedValue）
{
pManagedArray->SetValue（managedValue，mpmanagedarray索引）；
}
void ArrayIterator:：SetValue（安全数组*pNativeArray，LPVOID pNativeValue）
{
检查人力资源（：：SafeArrayPutElement（pNativeArray，m_pnativeArrayIndex，pNativeValue））；
}
void SafeArrayMarshaler:：PutManagedElementToNativeArray（SAFEARRAY*PnaviArray，ArrayIterator^ pArrayIterator，ArrayElementType^ pArrayElementType，Object^ pManagedObject）
{
if（IsBlittableType（pArrayElementType->ManagedType））
{
GCHandle^GCHandle=GCHandle:：Alloc（pManagedObject，GCHandleType:：pinted）；
pArrayIterator->SetValue（pNativeArray，gcHandle->AddRofPindedObject（）.ToPointer（））；
gcHandle->Free（）；
}        
否则如果（pArrayElementType->NativeType==VT_BOOL）
{
布尔managedBooleanValue=safe_cast（pManagedObject）；
IntPtr nativeBoolPointer=Marshal:：AllocHGlobal（sizeof（VARIANT_BOOL））；
VARIANT_BOOL*pNativeBool=reinterpret_cast（nativeBoolPointer.ToPointer（））；
*pNativeBool=managedBooleanValue==true？VARIANT\u true：VARIANT\u FALSE；
pArrayIterator->SetValue（pNativeArray，pNativeBool）；
元帅：FreeHGlobal（nativeBoolPointer）；
}
否则如果（pArrayElementType->NativeType==VT_日期）
{
DateTime managedDateValue=safe_cast（pManagedObject）；
IntPtr nativeDatePointer=Marshal:：AllocHGlobal（sizeof（DATE））；
DATE*pNativeDate=reinterpret_cast（nativeDatePointer.ToPointer（））；
*pNativeDate=managedDateValue.ToOADate（）；
pArrayIterator->SetValue（pNaviArray，pNaviEdate）；
Marshal:：FreeHGlobal（nativeDatePointer）；
}
否则如果（pArrayElementType->NativeType==VT\u BSTR）
{
IntPtr nativeBSTRHandle=Marshal:：StringToBSTR（safe_cast（pManagedObject））；
pArrayIterator->SetValue（pNativeArray，nativeBSTRHandle.ToPointer（））；
元帅：FreeBSTR（nativeBSTRHandle）；
}
else if（pArrayElementType->NativeType==VT_INT）
{
IntPtr managedPointer=safe_cast（pManagedObject）；
pArrayIterator->SetValue（pNativeArray，managedPointer.ToPointer（））；
}
否则如果（pArrayElementType->NativeType==VT_UINT）
{
uintpttr managedPointer=safe_cast（pManagedObject）；
pArrayIterator->SetValue（pNativeArray，managedPointer.ToPointer（））；
}
否则如果（pArrayElementType->NativeType==VT\U调度）
{
IntPtr nativeInterfacePointer=Marshal:：GetIDispatchForObject（pManagedObject）；
pArrayIterator->SetValue（pNativeArray，nativeInterfacePointer.ToPointer（））；
封送：释放（nativeInterfacePointer）；
}
否则如果（pArrayElementType->NativeType==VT_未知）
{
IntPtr nativeInterfacePointer=Marshal:：getiunknownfobject（pManagedObject）；
pArrayIterator->SetValue（pNativeArray，nativeInterfacePointer.ToPointer（））；
封送：释放（nativeInterfacePointer）；
}
else if（pArrayElementType->NativeType==VT_变量）
{
IntPtr nativeVariantHandle=Marshal:：AllocHGlobal（sizeof（VARIANT））；
Marshal:：GetNativeVariantForObject（pManagedObject，nativeVariantHandle）；
pArrayIterator->SetValue（pNativeArray，nativeVariantHandle.ToPointer（））；
元帅：弗里赫全球（nativeVariantHandle）；
}
其他的
{
抛出新的InvalidOperationException（）；
}
}
void SafeArrayMarshaler:：PutNativeElementToManagedArray（数组^pManagedArray、ArrayIterator、pArrayIterator、ArrayElementType^ pArrayElementType、LPVOID pNactiveObject）
{
if（IsBlittableType（pArrayElementType->ManagedType））
{
开关（类型：：GetTypeCode（pArrayElementType->ManagedType））
{
案例类型代码：：SByte:
{
SByte managedSignedByte=Marshal:：ReadByte（IntPtr（pNativeObject））；
pArrayIterator->SetValue（pManagedArray，managedSignedByte）；
打破
}
大小写类型代码：：字节：
{
字节managedSignedByte=Marshal:：ReadByte（IntPtr（pNativeObject））；
pArrayIterator->SetValue（pManagedArray，managedUnsignedByte）；
打破
}
案例类型代码：：Int16：
{
Int16 managedValue=Marshal:：ReadInt16（IntPtr（pNativeObject））；
pArrayIterator->SetValue（pManagedArray，managedValue）；
打破
}
案例类型代码：：UInt16：
{
UInt16 managedValue=Marshal:：ReadInt16（IntPtr（pNativeObject））；
pArrayIterator->SetValue（pManagedArray，managedValue）；
打破
}
案例类型代码：：Int32：
{
Int32 managedValue=Marshal:：ReadInt32（IntPtr（pNativeObject））；
pArrayIterator->SetValue（pManagedArray，managedValue）；
打破
}
案例类型代码：：UInt32：
{
UInt32 managedValue=Marshal:：ReadInt32（IntPtr（pNativeObject））；
pArrayIterator->SetValue（pManagedArray，managedValue）；
打破
}
案例类型代码：：Int64：
{
Int64管理