Marshal

src\Compilers\Shared\BuildClient.cs (1)

364var commandLine = Marshal.PtrToStringUni(ptr)!;

src\Compilers\Shared\BuildServerConnection.cs (2)

473startInfo.cb = Marshal.SizeOf(startInfo); 507logger.LogError("Failed to create process. GetLastError={0}", Marshal.GetLastWin32Error());

Microsoft\Tools\ServiceModel\SvcUtil\InputModule.cs (1)

142&& Marshal.GetHRForException(ie) == ToolInputException.COR_E_ASSEMBLYEXPECTED)

FrameworkFork\Microsoft.CodeDom\Compiler\TempFiles.cs (1)

228if (retryCount == 0 || Marshal.GetHRForException(e) != HR_ERROR_FILE_EXISTS)

src\tools\illink\src\ILLink.Shared\TrimAnalysis\IntrinsicId.cs (5)

214 /// <see cref="System.Runtime.InteropServices.Marshal.SizeOf(System.Type)"/> 218 /// <see cref="System.Runtime.InteropServices.Marshal.OffsetOf(System.Type, string)"/> 222 /// <see cref="System.Runtime.InteropServices.Marshal.PtrToStructure(nint, System.Type)"/> 226 /// <see cref="System.Runtime.InteropServices.Marshal.DestroyStructure(nint, System.Type)"/> 230 /// <see cref="System.Runtime.InteropServices.Marshal.GetDelegateForFunctionPointer(nint, System.Type)"/>

src\tools\illink\src\ILLink.Shared\TrimAnalysis\IntrinsicId.cs (5)

214 /// <see cref="System.Runtime.InteropServices.Marshal.SizeOf(System.Type)"/> 218 /// <see cref="System.Runtime.InteropServices.Marshal.OffsetOf(System.Type, string)"/> 222 /// <see cref="System.Runtime.InteropServices.Marshal.PtrToStructure(nint, System.Type)"/> 226 /// <see cref="System.Runtime.InteropServices.Marshal.DestroyStructure(nint, System.Type)"/> 230 /// <see cref="System.Runtime.InteropServices.Marshal.GetDelegateForFunctionPointer(nint, System.Type)"/>

Rendering\EndpointHtmlRenderer.Streaming.cs (1)

131var bufSizeRequired = count * Marshal.SizeOf<ComponentIdAndDepth>();

BlazorPack\SequenceOfT.cs (1)

23private static readonly int DefaultLengthFromArrayPool = 1 + (4095 / Marshal.SizeOf<T>());

SafeHandles\LocalAllocHandle.cs (1)

21Marshal.FreeHGlobal(handle); // actually calls LocalFree

SafeHandles\SafeLibraryHandle.cs (3)

103return Marshal.GetDelegateForFunctionPointer<TDelegate>(pfnProc); 201int hr = Marshal.GetHRForLastWin32Error(); 202Marshal.ThrowExceptionForHR(hr);

SafeHandles\SecureLocalAllocHandle.cs (1)

46handle = Marshal.AllocHGlobal(cb); // actually calls LocalAlloc

UnsafeNativeMethods.cs (1)

478var lastError = Marshal.GetLastWin32Error();

Cng\DpapiSecretSerializerHelper.cs (5)

98var errorCode = Marshal.GetLastWin32Error(); 104Marshal.Copy((IntPtr)dataOut.pbData, retVal, 0, dataLength); 113Marshal.FreeHGlobal((IntPtr)dataOut.pbData); 241var errorCode = Marshal.GetLastWin32Error(); 254Marshal.FreeHGlobal((IntPtr)dataOut.pbData);

DumpCollector\DumpCollector.Windows.cs (2)

25var err = Marshal.GetHRForLastWin32Error(); 26Marshal.ThrowExceptionForHR(err);

AuthenticationManager.cs (1)

23Marshal.SizeOf<HTTP_SERVER_AUTHENTICATION_INFO>();

HttpSysException.cs (1)

17: base(Marshal.GetLastWin32Error())

NativeInterop\RequestQueue.cs (7)

58pSecurityDescriptor = Marshal.AllocHGlobal(securityDescriptorBytes.Length); 59Marshal.Copy(securityDescriptorBytes, 0, pSecurityDescriptor.Value, securityDescriptorBytes.Length); 65nLength = (uint)Marshal.SizeOf<SECURITY_ATTRIBUTES>(), 113throw new HttpSysException(Marshal.GetLastWin32Error()); 129Marshal.FreeHGlobal(pSecurityDescriptor.Value); 150&length, (uint)Marshal.SizeOf<long>()); 166&verbosity, (uint)Marshal.SizeOf<long>());

NativeInterop\SafeLibraryHandle.cs (3)

48return Marshal.GetDelegateForFunctionPointer<TDelegate>(pfnProc); 95int hr = Marshal.GetHRForLastWin32Error(); 96Marshal.ThrowExceptionForHR(hr);

NativeInterop\UrlGroup.cs (3)

16Marshal.SizeOf<HTTP_BINDING_INFO>(); 18Marshal.SizeOf<HTTP_QOS_SETTING_INFO>(); 20Marshal.SizeOf<HTTP_BINDING_INFO>();

RequestProcessing\ClientCertLoader.cs (2)

130_memoryBlob = (HTTP_SSL_CLIENT_CERT_INFO*)Marshal.UnsafeAddrOfPinnedArrayElement(_backingBuffer, 0); 279Marshal.Copy((IntPtr)pClientCertInfo->pCertEncoded, certEncoded, 0, certEncoded.Length);

RequestProcessing\RequestContext.cs (1)

333return Marshal.PtrToStructure<HTTP_REQUEST_PROPERTY_SNI>((IntPtr)pBuffer);

RequestProcessing\RequestStreamAsyncResult.cs (1)

31_pinnedBuffer = (Marshal.UnsafeAddrOfPinnedArrayElement(buffer, offset));

RequestProcessing\ResponseStreamAsyncResult.cs (4)

80_dataChunks[currentChunk].Anonymous.FromMemory.pBuffer = (void*)Marshal.UnsafeAddrOfPinnedArrayElement(chunkHeaderBuffer.Array!, chunkHeaderBuffer.Offset); 84_dataChunks[currentChunk].Anonymous.FromMemory.pBuffer = (void*)Marshal.UnsafeAddrOfPinnedArrayElement(data.Array!, data.Offset); 152_dataChunks[0].Anonymous.FromMemory.pBuffer = (void*)Marshal.UnsafeAddrOfPinnedArrayElement(chunkHeaderBuffer.Array!, chunkHeaderBuffer.Offset); 219return (HTTP_DATA_CHUNK*)(Marshal.UnsafeAddrOfPinnedArrayElement(_dataChunks, 0));

src\Shared\HttpSys\NativeInterop\CookedUrl.cs (4)

23return Marshal.PtrToStringUni((IntPtr)_nativeCookedUrl.pFullUrl.Value, _nativeCookedUrl.FullUrlLength / 2); 32return Marshal.PtrToStringUni((IntPtr)_nativeCookedUrl.pHost.Value, _nativeCookedUrl.HostLength / 2); 41return Marshal.PtrToStringUni((IntPtr)_nativeCookedUrl.pAbsPath.Value, _nativeCookedUrl.AbsPathLength / 2); 50return Marshal.PtrToStringUni((IntPtr)_nativeCookedUrl.pQueryString.Value, _nativeCookedUrl.QueryStringLength / 2);

src\Shared\HttpSys\RequestProcessing\NativeRequestContext.cs (2)

278return Marshal.PtrToStringAnsi((IntPtr)NativeRequest->pRawUrl.Value, NativeRequest->RawUrlLength); 821Marshal.Copy((IntPtr)clientCert, certEncoded, 0, certEncoded.Length);

TimeoutManager.cs (1)

19Marshal.SizeOf<HTTP_TIMEOUT_LIMIT_INFO>();

DelegateTests.cs (1)

330Marshal.Copy(new IntPtr(pSecurityDescriptor.Value), securityDescriptorBytes, 0, length);

HttpsTests.cs (1)

218tlsCopy = Marshal.PtrToStructure<HTTP_SSL_PROTOCOL_INFO>((IntPtr)handle.Pointer);

RequestHeaderBenchmarks.cs (3)

72var dataDestination = nativeMemory[Marshal.SizeOf<HTTP_REQUEST_V1>()..]; 87var unknownHeaderStructureDestination = nativeMemory[Marshal.SizeOf<HTTP_REQUEST_V1>()..]; 94var unknownHeadersSize = Marshal.SizeOf<HTTP_UNKNOWN_HEADER>();

RequestHeaderTests.cs (6)

359var dataDestination = nativeMemory.Slice(Marshal.SizeOf<HTTP_REQUEST_V1>()); 383var dataDestination = nativeMemory.Slice(Marshal.SizeOf<HTTP_REQUEST_V1>()); 402var unknownHeaderStructureDestination = nativeMemory.Slice(Marshal.SizeOf<HTTP_REQUEST_V1>()); 409var unknownHeadersSize = Marshal.SizeOf<HTTP_UNKNOWN_HEADER>(); 440var unknownHeaderStructureDestination = nativeMemory.Slice(Marshal.SizeOf<HTTP_REQUEST_V1>()); 449var unknownHeadersSize = Marshal.SizeOf<HTTP_UNKNOWN_HEADER>();

Core\IISConfigurationData.cs (9)

41native.pwzFullApplicationPath = managed.pwzFullApplicationPath is null ? IntPtr.Zero : Marshal.StringToBSTR(managed.pwzFullApplicationPath); 42native.pwzVirtualApplicationPath = managed.pwzVirtualApplicationPath is null ? IntPtr.Zero : Marshal.StringToBSTR(managed.pwzVirtualApplicationPath); 46native.pwzBindings = managed.pwzBindings is null ? IntPtr.Zero : Marshal.StringToBSTR(managed.pwzBindings); 55Marshal.FreeBSTR(native.pwzFullApplicationPath); 59Marshal.FreeBSTR(native.pwzVirtualApplicationPath); 63Marshal.FreeBSTR(native.pwzBindings); 72pwzFullApplicationPath = native.pwzFullApplicationPath == IntPtr.Zero ? string.Empty : Marshal.PtrToStringBSTR(native.pwzFullApplicationPath), 73pwzVirtualApplicationPath = native.pwzVirtualApplicationPath == IntPtr.Zero ? string.Empty : Marshal.PtrToStringBSTR(native.pwzVirtualApplicationPath), 77pwzBindings = native.pwzBindings == IntPtr.Zero ? string.Empty : Marshal.PtrToStringBSTR(native.pwzBindings),

Core\IISHttpContext.cs (1)

433return statusCode == NativeMethods.HR_OK ? Marshal.PtrToStructure<HTTP_REQUEST_PROPERTY_SNI>((IntPtr)pBuffer) : default;

Core\IISHttpContext.FeatureCollection.cs (1)

395Marshal.Copy((IntPtr)NativeRequest->pSslInfo->pClientCertInfo->pCertEncoded, rawCertificateCopy, 0, rawCertificateCopy.Length);

Core\IO\AsyncIOOperation.cs (1)

104_exception = new ConnectionResetException("The client has disconnected", Marshal.GetExceptionForHR(hr)!);

NativeMethods.cs (1)

358throw Marshal.GetExceptionForHR(hr)!;

src\Shared\HttpSys\NativeInterop\CookedUrl.cs (4)

23return Marshal.PtrToStringUni((IntPtr)_nativeCookedUrl.pFullUrl.Value, _nativeCookedUrl.FullUrlLength / 2); 32return Marshal.PtrToStringUni((IntPtr)_nativeCookedUrl.pHost.Value, _nativeCookedUrl.HostLength / 2); 41return Marshal.PtrToStringUni((IntPtr)_nativeCookedUrl.pAbsPath.Value, _nativeCookedUrl.AbsPathLength / 2); 50return Marshal.PtrToStringUni((IntPtr)_nativeCookedUrl.pQueryString.Value, _nativeCookedUrl.QueryStringLength / 2);

src\Shared\HttpSys\RequestProcessing\NativeRequestContext.cs (2)

278return Marshal.PtrToStringAnsi((IntPtr)NativeRequest->pRawUrl.Value, NativeRequest->RawUrlLength); 821Marshal.Copy((IntPtr)clientCert, certEncoded, 0, certEncoded.Length);

IISExpressDeployer.cs (2)

508throw new InvalidOperationException($"Unable to get window class name: {Marshal.GetLastWin32Error()}"); 522throw new InvalidOperationException($"Unable to PostMessage to process {pid}. LastError: {Marshal.GetLastWin32Error()}");

ProcessTracker.cs (4)

34var length = Marshal.SizeOf(typeof(JOBOBJECT_EXTENDED_LIMIT_INFORMATION)); 35var extendedInfoPtr = Marshal.AllocHGlobal(length); 38Marshal.StructureToPtr(extendedInfo, extendedInfoPtr, false); 48Marshal.FreeHGlobal(extendedInfoPtr);

src\Shared\HttpSys\NativeInterop\CookedUrl.cs (4)

23return Marshal.PtrToStringUni((IntPtr)_nativeCookedUrl.pFullUrl.Value, _nativeCookedUrl.FullUrlLength / 2); 32return Marshal.PtrToStringUni((IntPtr)_nativeCookedUrl.pHost.Value, _nativeCookedUrl.HostLength / 2); 41return Marshal.PtrToStringUni((IntPtr)_nativeCookedUrl.pAbsPath.Value, _nativeCookedUrl.AbsPathLength / 2); 50return Marshal.PtrToStringUni((IntPtr)_nativeCookedUrl.pQueryString.Value, _nativeCookedUrl.QueryStringLength / 2);

src\Shared\HttpSys\RequestProcessing\NativeRequestContext.cs (2)

278return Marshal.PtrToStringAnsi((IntPtr)NativeRequest->pRawUrl.Value, NativeRequest->RawUrlLength); 821Marshal.Copy((IntPtr)clientCert, certEncoded, 0, certEncoded.Length);

BackEnd\Components\Communications\NodeLauncher.cs (3)

63startInfo.cb = Marshal.SizeOf<BackendNativeMethods.STARTUP_INFO>(); 147processSecurityAttributes.nLength = Marshal.SizeOf<BackendNativeMethods.SECURITY_ATTRIBUTES>(); 148threadSecurityAttributes.nLength = Marshal.SizeOf<BackendNativeMethods.SECURITY_ATTRIBUTES>();

CommunicationsUtilities.cs (2)

283throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());

InprocTrackingNativeMethods.cs (12)

Instance\RunningObjectTable.cs (1)

80Marshal.ThrowExceptionForHR(hr);

NativeWin32Exception.cs (1)

15/// associated recent error code (<see cref="System.Runtime.InteropServices.Marshal.GetLastWin32Error" />). The <see cref="Exception.Message" />

WindowsFileSystem.cs (2)

137int hr = Marshal.GetLastWin32Error(); 190int hr = Marshal.GetLastWin32Error();

WindowsFileSystem.cs (2)

137int hr = Marshal.GetLastWin32Error(); 190int hr = Marshal.GetLastWin32Error();

BackEnd\TargetUpToDateChecker_Tests.cs (6)

1036Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); 1050Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); 1058Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());

EnvironmentUtilities.cs (1)

16public static bool Is64BitProcess => Marshal.SizeOf<IntPtr>() == 8;

NativeMethods.cs (12)

297_length = (uint)Marshal.SizeOf<MemoryStatus>(); 402_nLength = (uint)Marshal.SizeOf<SecurityAttributes>(); 523Marshal.GetLastWin32Error() == ERROR_INSUFFICIENT_BUFFER) 1035int errorCode = Marshal.GetLastWin32Error(); 1041errorCode = Marshal.GetLastWin32Error(); 1075int errorCode = Marshal.GetLastWin32Error(); 1081errorCode = Marshal.GetLastWin32Error(); 1132errorMessage = symbolicLinkCreated ? null : Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()).Message; 1137errorMessage = symbolicLinkCreated ? null : Marshal.GetLastWin32Error().ToString(); 1300Marshal.ThrowExceptionForHR(errorCode); 1582int code = Marshal.GetLastWin32Error();

RCWForCurrentContext.cs (5)

40IntPtr iunknownPtr = Marshal.GetIUnknownForObject(rcw); 45objInCurrentCtx = Marshal.GetObjectForIUnknown(iunknownPtr); 49Marshal.Release(iunknownPtr); 116Marshal.IsComObject(_rcwForCurrentCtx)) 121Marshal.ReleaseComObject(_rcwForCurrentCtx);

src\Compilers\Shared\BuildServerConnection.cs (2)

473startInfo.cb = Marshal.SizeOf(startInfo); 507logger.LogError("Failed to create process. GetLastError={0}", Marshal.GetLastWin32Error());

BootstrapperUtil\ResourceUpdater.cs (7)

51while (IntPtr.Zero == hUpdate && Marshal.GetHRForLastWin32Error() == ERROR_SHARING_VIOLATION && beginUpdateRetries > 0) // If it equals 0x80070020 (ERROR_SHARING_VIOLATION), sleep & retry 63$"Unable to begin updating resource for {filename} with error {Marshal.GetHRForLastWin32Error():X}")); 78$"Unable to update resource for {filename} with error {Marshal.GetHRForLastWin32Error():X}")); 90$"Unable to update count resource for {filename} with error {Marshal.GetHRForLastWin32Error():X}")); 112$"Unable to update data resource for {filename} with error {Marshal.GetHRForLastWin32Error():X}")); 122$"Unable to update key resource for {filename} with error {Marshal.GetHRForLastWin32Error():X}")); 136$"Unable to finish updating resource for {filename} with error {Marshal.GetHRForLastWin32Error():X}"));

Copy.cs (1)

977int code = Marshal.GetHRForException(e);

FileState.cs (1)

110int error = Marshal.GetLastWin32Error();

ManifestUtil\ComImporter.cs (2)

67var typeLibAttr = (TYPELIBATTR)Marshal.PtrToStructure(typeLibAttrPtr, typeof(TYPELIBATTR)); 91TYPEATTR tinfoAttr = (TYPEATTR)Marshal.PtrToStructure(tinfoAttrPtr, typeof(TYPEATTR));

ManifestUtil\EmbeddedManifestReader.cs (1)

55Marshal.Copy(hResource, buffer, 0, buffer.Length);

ManifestUtil\mansign2.cs (9)

429string issuerKeyHash = Marshal.PtrToStringUni(pIssuerKeyHash); 545string publicKeyToken = Marshal.PtrToStringUni(pPublicKeyToken); 812throw new CryptographicException(Marshal.GetLastWin32Error()); 816var timestampContext = (Win32.CRYPT_TIMESTAMP_CONTEXT)Marshal.PtrToStructure(ppTsContext, typeof(Win32.CRYPT_TIMESTAMP_CONTEXT)); 818Marshal.Copy(timestampContext.pbEncoded, encodedBytes, 0, (int)timestampContext.cbEncoded); 890Marshal.Copy(timestampBlob.pbData, timestampSignature, 0, timestampSignature.Length); 1267_hash = Marshal.PtrToStringUni(signerInfo.pwszHash); 1271_description = Marshal.PtrToStringUni(signerInfo.pwszDescription); 1275_descriptionUrl = Marshal.PtrToStringUni(signerInfo.pwszDescriptionUrl);

ManifestUtil\SecurityUtil.cs (1)

745int exceptionHR = Marshal.GetHRForException(ex);

Move.cs (2)

265Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());

NativeMethods.cs (5)

810errorMessage = hardLinkCreated ? null : Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()).Message; 815errorMessage = hardLinkCreated ? null : log.FormatResourceString("Copy.NonWindowsLinkErrorMessage", "link()", Marshal.GetLastWin32Error()); 1370Marshal.ThrowExceptionForHR(hr); 1445Marshal.ThrowExceptionForHR(hr);

NativeWin32Exception.cs (1)

15/// associated recent error code (<see cref="System.Runtime.InteropServices.Marshal.GetLastWin32Error" />). The <see cref="Exception.Message" />

WindowsFileSystem.cs (2)

137int hr = Marshal.GetLastWin32Error(); 190int hr = Marshal.GetLastWin32Error();

AddToWin32Manifest_Tests.cs (1)

178Marshal.Copy(ipMemorySource, uiBytes, 0, (int)resSize);

Copy_Tests.cs (4)

2613int errorCode = Marshal.GetHRForLastWin32Error(); 2614Marshal.GetExceptionForHR(errorCode); 2718int errorCode = Marshal.GetHRForLastWin32Error(); 2719Marshal.GetExceptionForHR(errorCode);

MockUnmanagedMemoryHelper.cs (4)

7using Marshal = System.Runtime.InteropServices.Marshal; 42IntPtr handle = Marshal.AllocHGlobal(cb); 70Marshal.FreeHGlobal(handle); 78Marshal.FreeHGlobal(_dependentAllocations[handle][0]);

NativeMethodsShared_Tests.cs (1)

54GetProcessIdDelegate processIdDelegate = Marshal.GetDelegateForFunctionPointer<GetProcessIdDelegate>(processHandle);

DriveMapping.cs (3)

29NativeMethodsShared.ThrowExceptionForErrorCode(Marshal.GetLastWin32Error()); 42NativeMethodsShared.ThrowExceptionForErrorCode(Marshal.GetLastWin32Error()); 60int err = Marshal.GetLastWin32Error();

NativeWin32Exception.cs (1)

15/// associated recent error code (<see cref="System.Runtime.InteropServices.Marshal.GetLastWin32Error" />). The <see cref="Exception.Message" />

WindowsFileSystem.cs (2)

137int hr = Marshal.GetLastWin32Error(); 190int hr = Marshal.GetLastWin32Error();

NativeMethodsShared_Tests.cs (1)

54GetProcessIdDelegate processIdDelegate = Marshal.GetDelegateForFunctionPointer<GetProcessIdDelegate>(processHandle);

DiaSymReader\SymUnmanagedFactory.cs (8)

123Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); 132Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); 138var creator = Marshal.GetDelegateForFunctionPointer<NativeFactory>(createAddress); 146Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); 160lazyType = Marshal.GetTypeFromCLSID(clsid);

DiaSymReader\Utilities\ComMemoryStream.cs (2)

129Marshal.Copy(_chunks[chunkIndex], chunkOffset, (IntPtr)(pv + destinationIndex), bytesToCopy); 226Marshal.Copy((IntPtr)(pv + bytesWritten), _chunks[chunkIndex], chunkOffset, bytesToCopy);

DiaSymReader\Utilities\InteropUtilities.cs (1)

30Marshal.ThrowExceptionForHR(hr, s_ignoreIErrorInfo);

DiaSymReader\Writer\SymUnmanagedWriterImpl.cs (1)

370Marshal.GetNativeVariantForObject(value, new IntPtr(&variant));

InternalUtilities\ReadOnlyUnmanagedMemoryStream.cs (1)

38Marshal.Copy(_data + _position, buffer, offset, bytesRead);

StrongName\DesktopStrongNameProvider.cs (1)

218Marshal.Copy(keyBlob, pubKey, 0, keyBlobByteCount);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (1)

505Marshal.Copy((IntPtr)valuePtr, bytes, 0, bytes.Length);

CommandLineTests.cs (1)

7830throw new Win32Exception(Marshal.GetLastWin32Error());

Emit\EmitMetadataTests.cs (1)

2406Marshal.Copy((IntPtr)relocBlock.Pointer, relocBytes, 0, relocBytes.Length);

Emit\ResourceTests.cs (3)

60throw new Win32Exception(Marshal.GetLastWin32Error()); 150throw new Win32Exception(Marshal.GetLastWin32Error()); 848Assert.True(lib != IntPtr.Zero, String.Format("LoadLibrary failed with HResult: {0:X}", +Marshal.GetLastWin32Error()));

BlindAggregatorFactory.cs (11)

40var pResult = (BlindAggregator*)Marshal.AllocCoTaskMem(sizeof(BlindAggregator)); 60Marshal.AddRef(_innerUnknown); 66Marshal.Release(_innerUnknown); 96_queryInterfacePtr = Marshal.GetFunctionPointerForDelegate(VTable.s_queryInterface); 97_addRefPtr = Marshal.GetFunctionPointerForDelegate(VTable.s_addRef); 98_releasePtr = Marshal.GetFunctionPointerForDelegate(VTable.s_release); 99_getGCHandlePtr = Marshal.GetFunctionPointerForDelegate(VTable.s_get_GCHandlePtr); 111var ptr = Marshal.AllocCoTaskMem(sizeof(VTable)); 117=> Marshal.FreeCoTaskMem(this.VTablePtr); 155return Marshal.QueryInterface(pThis->_innerUnknown, ref riid, out pvObject); 168Marshal.FreeCoTaskMem((IntPtr)pThis);

RenameTracking\MockRefactorNotifyService.cs (2)

28Marshal.ThrowExceptionForHR(unchecked((int)0x80004004)); // E_ABORT 40Marshal.ThrowExceptionForHR(unchecked((int)0x80004004)); // E_ABORT

PDB\MethodDebugInfo.Native.cs (1)

207Marshal.ThrowExceptionForHR(hr, s_ignoreIErrorInfo);

Debugger\Engine\DkmClrValue.cs (1)

771return Marshal.PtrToStructure(ptr, destinationType);

Debugging\DebugInformationReaderProvider.cs (2)

93if (symReader != null && Marshal.IsComObject(symReader)) 98Marshal.ReleaseComObject(symReader);

EditAndContinue\EditAndContinueMethodDebugInfoReader.cs (1)

202Marshal.ThrowExceptionForHR(hr);

SymbolSearch\Windows\NativePatching.cs (1)

77Marshal.Copy(output.pBuf, targetBytes, 0, targetBytes.Length);

CompilationOptionsReader.cs (1)

277Marshal.Copy(new IntPtr(contentPtr), content, 0, length);

Host\SolutionAssetCache.cs (1)

26RoslynDebug.Assert(Marshal.SizeOf(typeof(SharedStopwatch)) == 8);

src\Compilers\Shared\GlobalAssemblyCacheHelpers\ClrGlobalAssemblyCache.cs (4)

151Exception e = Marshal.GetExceptionForHR(hr); 181Marshal.ThrowExceptionForHR(hr); 240cbAssemblyInfo = (uint)Marshal.SizeOf<ASSEMBLY_INFO>(), 251var result = Marshal.PtrToStringUni((IntPtr)info.pszCurrentAssemblyPathBuf, (int)info.cchBuf - 1);

src\Compilers\Shared\GlobalAssemblyCacheHelpers\FusionAssemblyIdentity.cs (8)

142throw Marshal.GetExceptionForHR(hr); 151throw Marshal.GetExceptionForHR(hr); 154return Marshal.PtrToStringUni((IntPtr)p, (int)characterCountIncludingTerminator - 1); 171throw Marshal.GetExceptionForHR(hr); 180throw Marshal.GetExceptionForHR(hr); 197return Marshal.PtrToStringUni((IntPtr)p, (data.Length / 2) - 1); 293throw Marshal.GetExceptionForHR(hr); 437Marshal.ThrowExceptionForHR(CreateAssemblyNameObject(out result, null, 0, IntPtr.Zero));

src\Compilers\Shared\GlobalAssemblyCacheHelpers\GlobalAssemblyCacheLocation.cs (3)

53throw Marshal.GetExceptionForHR(hr); 62throw Marshal.GetExceptionForHR(hr); 65return Marshal.PtrToStringUni((IntPtr)p);

CompilationVerifier.EmitOutput.cs (1)

47Marshal.Copy((IntPtr)mdReader.MetadataPointer, bytes, 0, length);

Win32Res.cs (7)

33throw new Win32Exception(Marshal.GetLastWin32Error()); 38throw new Win32Exception(Marshal.GetLastWin32Error()); 42throw new Win32Exception(Marshal.GetLastWin32Error()); 50Marshal.Copy((IntPtr)(ptr.ToInt64() + offset), fullmanif, 0, length); 57Marshal.Copy(mfRsrc, ar, 0, 3); 164Marshal.Copy(versionRsrc, shortArray, 0, 1); 168Marshal.Copy(versionRsrc, entireResourceBytes, 0, entireResourceBytes.Length);

src\Compilers\Shared\GlobalAssemblyCacheHelpers\FusionAssemblyIdentity.cs (8)

142throw Marshal.GetExceptionForHR(hr); 151throw Marshal.GetExceptionForHR(hr); 154return Marshal.PtrToStringUni((IntPtr)p, (int)characterCountIncludingTerminator - 1); 171throw Marshal.GetExceptionForHR(hr); 180throw Marshal.GetExceptionForHR(hr); 197return Marshal.PtrToStringUni((IntPtr)p, (data.Length / 2) - 1); 293throw Marshal.GetExceptionForHR(hr); 437Marshal.ThrowExceptionForHR(CreateAssemblyNameObject(out result, null, 0, IntPtr.Zero));

Win32Res.cs (1)

167Marshal.Copy((IntPtr)p, threeWords, 0, 3);

CommandLineTests.vb (1)

6854Throw New Win32Exception(Marshal.GetLastWin32Error())

Emit\ResourceTests.vb (3)

51Throw New Win32Exception(Marshal.GetLastWin32Error()) 138Throw New Win32Exception(Marshal.GetLastWin32Error()) 337Assert.True([lib] <> IntPtr.Zero, String.Format("LoadLibrary failed with HResult: {0:X}", Marshal.GetLastWin32Error()))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Serialization\ObjectWriter.cs (1)

505Marshal.Copy((IntPtr)valuePtr, bytes, 0, bytes.Length);

TemporaryStorage\TemporaryStorageService.DirectMemoryAccessStreamReader.cs (1)

69Marshal.Copy((IntPtr)_position, buffer, index, count);

src\Compilers\Shared\GlobalAssemblyCacheHelpers\GlobalAssemblyCacheLocation.cs (3)

53throw Marshal.GetExceptionForHR(hr); 62throw Marshal.GetExceptionForHR(hr); 65return Marshal.PtrToStringUni((IntPtr)p);

src\Workspaces\MSBuild\BuildHost\Rpc\Contracts\MonoMSBuildDiscovery.cs (1)

60var result = Marshal.PtrToStringAnsi(ptr); // uses UTF8 on Unix

Rpc\Contracts\MonoMSBuildDiscovery.cs (1)

60var result = Marshal.PtrToStringAnsi(ptr); // uses UTF8 on Unix

src\Compilers\Core\Portable\InternalUtilities\ReadOnlyUnmanagedMemoryStream.cs (1)

38Marshal.Copy(_data + _position, buffer, offset, bytesRead);

XunitDisposeHook.cs (1)

48Marshal.WriteByte(functionPointer, 0xC3);

Microsoft\CSharp\RuntimeBinder\BinderHelper.cs (1)

181return obj != null && Marshal.IsComObject(obj);

src\common\NativeMethods.cs (3)

37errorMessage = hardLinkCreated ? null : Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()).Message; 42errorMessage = hardLinkCreated ? null : $"The link() library call failed with the following error code: {Marshal.GetLastWin32Error()}.";

Vsix\GetPkgDefAssemblyDependencyGuid.cs (1)

57int targetBlockSize = Marshal.SizeOf(typeof(Guid));

RemoteExecutorTests.cs (2)

119System.Runtime.InteropServices.Marshal.StructureToPtr(1, new IntPtr(1), true); 143System.Runtime.InteropServices.Marshal.StructureToPtr(1, new IntPtr(1), true);

Interop\PortableExecutable\PortableExecutableHeader.cs (3)

317UInt32 imageOptionalHeaderOffset = ImageNTHeadersOffset + 4 + (UInt32)Marshal.SizeOf<IMAGE_FILE_HEADER>(); 330FirstImageSectionHeaderOffset = ImageNTHeadersOffset + (UInt32)Marshal.SizeOf<IMAGE_NT_HEADERS32>(); 336FirstImageSectionHeaderOffset = ImageNTHeadersOffset + (UInt32)Marshal.SizeOf<IMAGE_NT_HEADERS64>();

Windows\Interop\JobObjectInfo.cs (2)

318Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());

Windows\Interop\MemoryInfo.cs (2)

25Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());

Windows\Network\WindowsTcpStateInfo.cs (14)

120Marshal.FreeHGlobal(tcpTable); 121tcpTable = Marshal.AllocHGlobal((int)size); 126Marshal.FreeHGlobal(tcpTable); 133Marshal.FreeHGlobal(tcpTable); 155var rawTcpTable = Marshal.PtrToStructure<MIB_TCPTABLE>(tcpTable); 158var offset = Marshal.OffsetOf<MIB_TCPTABLE>(nameof(MIB_TCPTABLE.Table)).ToInt32(); 162var row = Marshal.PtrToStructure<MIB_TCPROW>(rowPtr); 163rowPtr = IntPtr.Add(rowPtr, Marshal.SizeOf<MIB_TCPROW>()); 173Marshal.FreeHGlobal(tcpTable); 180var rawtcpTable = Marshal.PtrToStructure<MIB_TCP6TABLE>(tcpTable); 183var offset = Marshal.OffsetOf<MIB_TCP6TABLE>(nameof(MIB_TCP6TABLE.Table)).ToInt32(); 187var row = Marshal.PtrToStructure<MIB_TCP6ROW>(rowPtr); 188rowPtr = IntPtr.Add(rowPtr, Marshal.SizeOf<MIB_TCP6ROW>()); 198Marshal.FreeHGlobal(tcpTable);

Windows\Tcp6TableInfoTests.cs (8)

123Marshal.StructureToPtr(fakeTcp6Table, pTcp6Table, false); 124var offset = Marshal.OffsetOf<MIB_TCP6TABLE>(nameof(MIB_TCP6TABLE.Table)).ToInt32(); 129Marshal.StructureToPtr(fakeRows[i], fakePtr, false); 130fakePtr = IntPtr.Add(fakePtr, Marshal.SizeOf<MIB_TCP6ROW>()); 215Marshal.StructureToPtr(fakeTcp6Table, pTcp6Table, false); 216var offset = Marshal.OffsetOf<MIB_TCP6TABLE>(nameof(MIB_TCP6TABLE.Table)).ToInt32(); 221Marshal.StructureToPtr(fakeRows[i], fakePtr, false); 222fakePtr = IntPtr.Add(fakePtr, Marshal.SizeOf<MIB_TCP6ROW>());

Windows\TcpTableInfoTests.cs (6)

89Marshal.StructureToPtr(fakeTcpTable, pTcpTable, false); 90var offset = Marshal.OffsetOf<MIB_TCPTABLE>(nameof(MIB_TCPTABLE.Table)).ToInt32(); 95Marshal.StructureToPtr(fakeRows[i], fakePtr, false); 158Marshal.StructureToPtr(fakeTcpTable, pTcpTable, false); 159var offset = Marshal.OffsetOf<MIB_TCPTABLE>(nameof(MIB_TCPTABLE.Table)).ToInt32(); 164Marshal.StructureToPtr(fakeRows[i], fakePtr, false);

SkiaSharpTools.cs (1)

223 var code = Marshal.GetHRForException(ex);

Data\ModelHeader.cs (3)

109Contracts.Assert(Marshal.SizeOf(typeof(ModelHeader)) == Size); 311Marshal.Copy((IntPtr)pheader, bytes, 0, Size); 378Marshal.Copy(bytes, 0, (IntPtr)pheader, Size);

Data\Conversion.cs (2)

442if (Marshal.SizeOf(keySrc.RawType) > Marshal.SizeOf(typeDst.RawType))

DataLoadSave\Binary\BinaryLoader.cs (1)

1041Marshal.Copy(headerBytes, 0, (IntPtr)(&header), Header.HeaderSize);

DataLoadSave\Binary\BinarySaver.cs (2)

557Marshal.Copy(new IntPtr(&header), headerBytes, 0, Marshal.SizeOf(typeof(Header)));

DataLoadSave\Binary\Codecs.cs (2)

213Marshal.Copy(ptr, _buffer, 0, sublen); 274Marshal.Copy(_buffer, 0, ptr, sublen);

DataLoadSave\Transpose\TransposeLoader.cs (1)

569Marshal.Copy(headerBytes, 0, (IntPtr)(&header), Header.HeaderSize);

DataLoadSave\Transpose\TransposeSaver.cs (2)

179Marshal.Copy(new IntPtr(&header), headerBytes, 0, Marshal.SizeOf(typeof(Header)));

Utils\BufferPoolManager.cs (1)

81if (buffer != null && buffer.Length * Marshal.SizeOf(typeof(T)) >= MinBufferSizeInBytes)

WrappedLightGbmInterface.cs (2)

242string mes = Marshal.PtrToStringAnsi(charPtr); 291return Marshal.PtrToStringAnsi(src);

SymSgdClassificationTrainer.cs (1)

388_sizeofT = Marshal.SizeOf(typeof(T));

SafeTrainingAndModelBuffer.cs (2)

398Marshal.Copy((IntPtr)_pMFModel->P, p, 0, p.Length); 399Marshal.Copy((IntPtr)_pMFModel->Q, q, 0, q.Length);

Attributes\AttributeHelpers.cs (1)

23version = Version.Parse(Marshal.PtrToStringUTF8(gnu_get_libc_version()));

Utility\NativeLibrary.cs (1)

144return Marshal.GetDelegateForFunctionPointer<T>(functionPtr);

FftUtils.cs (1)

208throw Contracts.Except(Marshal.PtrToStringAnsi(ErrorMessage(status)));

ImageClassificationTrainer.cs (1)

771Marshal.WriteInt64(tensor, 0);

Microsoft\VisualBasic\ErrObject.vb (1)

326Return Marshal.GetLastWin32Error()

Microsoft\VisualBasic\Interaction.vb (1)

551Return Marshal.BindToMoniker([PathName])

Microsoft\VisualBasic\CompilerServices\ExceptionUtils.vb (1)

135Return New ComponentModel.Win32Exception(Marshal.GetLastWin32Error(), GetResourceString(resourceKey, placeHolders))

Microsoft\VisualBasic\Helpers\NativeMethods.vb (1)

130dwLength = CType(Marshal.SizeOf(Of MEMORYSTATUSEX)(), UInt32)

Microsoft\VisualBasic\Helpers\NativeTypes.SECURITY_ATTRIBUTES.vb (1)

17nLength = Marshal.SizeOf(Of SECURITY_ATTRIBUTES)()

Microsoft\VisualBasic\Interaction.vb (1)

330errorCode = Marshal.GetLastWin32Error()

System\Windows\Forms\SecurityAttributesTests.vb (1)

16securityAttributes.nLength.Should.Be(Marshal.SizeOf(Of SECURITY_ATTRIBUTES)())

CodeDefinitionWindow\VisualStudioCodeDefinitionWindowService.cs (1)

58Marshal.ThrowExceptionForHR(vsCodeDefView.SetContext(new Context(locations)));

DebuggerIntelliSense\AbstractDebuggerIntelliSenseContext.cs (6)

257Marshal.ThrowExceptionForHR(shellService.GetToolWindowEnum(out var windowEnum)); 258Marshal.ThrowExceptionForHR(textView.GetBuffer(out _)); 265Marshal.ThrowExceptionForHR(frame[0].GetGuidProperty((int)__VSFPROPID.VSFPROPID_GuidPersistenceSlot, out var toolWindowGuid)); 268Marshal.ThrowExceptionForHR(frame[0].QueryViewInterface(typeof(IVsTextView).GUID, out var frameTextView)); 271var immediateWindowTextView = Marshal.GetObjectForIUnknown(frameTextView) as IVsTextView; 276Marshal.Release(frameTextView);

DebuggerIntelliSense\DebuggerIntellisenseFilter.cs (1)

130if ((char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn) == '?')

EditorConfigSettings\SettingsEditorFactory.cs (5)

93textBuffer = Marshal.GetObjectForIUnknown(ptr) as IVsTextLines; 97_ = Marshal.Release(ptr); // Release RefCount from CreateInstance call 109textBuffer = Marshal.GetObjectForIUnknown(punkDocDataExisting) as IVsTextLines; 135ppunkDocView = Marshal.GetIUnknownForObject(newEditor); 136ppunkDocData = Marshal.GetIUnknownForObject(textBuffer);

EditorConfigSettings\SettingsEditorPane.cs (2)

77cbSize = (uint)Marshal.SizeOf(typeof(OLECRINFO)), 320ppUnkDocView = Marshal.GetIUnknownForObject(this);

Extensions\VisualStudioWorkspaceImplExtensions.cs (1)

40StructSize = Marshal.SizeOf(typeof(ImageAttributes)),

FindReferences\VisualStudioDefinitionsAndReferencesFactory.cs (2)

127if (Marshal.GetObjectForIUnknown(bufferPtr) is not IVsTextLines lines) 147Marshal.Release(bufferPtr);

Implementation\AbstractEditorFactory.cs (4)

85var docDataExisting = Marshal.GetObjectForIUnknown(punkDocDataExisting); 139ppunkDocView = Marshal.GetIUnknownForObject(codeWindow); 149ppunkDocData = Marshal.GetIUnknownForObject(textBuffer); 171Marshal.ThrowExceptionForHR(hresult);

Implementation\AbstractOleCommandTarget.cs (1)

65Marshal.ThrowExceptionForHR(returnValue);

Implementation\ContainedLanguageRefactorNotifyService.cs (1)

56Marshal.ThrowExceptionForHR(hresult);

Implementation\VsRefactorNotifyService.cs (2)

59Marshal.ThrowExceptionForHR(hresult); 95Marshal.ThrowExceptionForHR(hresult);

Interactive\VsResetInteractive.cs (4)

79Marshal.ThrowExceptionForHR(_monitorSelection.GetCurrentSelection( 106var hierarchy = (IVsHierarchy)Marshal.GetObjectForIUnknown(hierarchyPointer); 107Marshal.ThrowExceptionForHR( 279Marshal.Release(pointer);

Interactive\VsUpdateSolutionEvents.cs (2)

28Marshal.ThrowExceptionForHR( 56Marshal.ThrowExceptionForHR(_buildManager.UnadviseUpdateSolutionEvents(_cookie));

Interop\ComHandle.cs (3)

34else if (Marshal.IsComObject(handleOrManagedObject)) 58if (handle != null && !Marshal.IsComObject(handle)) 75Debug.Assert(_handle == null || Marshal.IsComObject(_handle), "Invariant broken!");

Interop\WeakComHandle.cs (7)

49pUnk = Marshal.GetIUnknownForObject(managedObject); 56Marshal.Release(pUnk); 68pUnk = Marshal.GetIUnknownForObject(handle.Object); 75Marshal.Release(pUnk); 102pUnk = Marshal.GetIUnknownForObject(target); 107return Marshal.GetObjectForIUnknown(pUnk) as THandle; 118Marshal.Release(pUnk);

Interop\WrapperPolicy.cs (3)

33var ptr = Marshal.GetIUnknownForObject(managedObject); 38var wrapper = Marshal.GetObjectForIUnknown(ptr); 45Marshal.Release(ptr);

KeybindingReset\KeybindingResetDetector.cs (4)

128FatalError.ReportAndCatch(Marshal.GetExceptionForHR(hr)); 145FatalError.ReportAndCatch(Marshal.GetExceptionForHR(hr)); 327FatalError.ReportAndCatch(Marshal.GetExceptionForHR(hr)); 445FatalError.ReportAndCatch(Marshal.GetExceptionForHR(hr));

LanguageService\AbstractLanguageService`2.IVsContainedLanguageFactory.cs (2)

37var webFileCtxService = Marshal.GetObjectForIUnknown(service) as IWebFileCtxService; 44Marshal.Release(service);

LanguageService\AbstractLanguageService`2.IVsImmediateStatementCompletion2.cs (3)

58Marshal.ThrowExceptionForHR(textView.AddCommandFilter(filter, out var nextFilter)); 66Marshal.ThrowExceptionForHR(textView.RemoveCommandFilter(this.filters[textView])); 84Marshal.ThrowExceptionForHR(textView.GetBuffer(out var debuggerBuffer));

Library\AbstractObjectList.cs (1)

381pData[0].dwSize = (uint)Marshal.SizeOf(typeof(VSCOMPONENTSELECTORDATA));

Options\LocalUserRegistryOptionPersister.cs (2)

153if (Marshal.SizeOf(Enum.GetUnderlyingType(optionType)) > Marshal.SizeOf(typeof(int)))

Preview\PreviewEngine.cs (6)

274var newTextPtr = Marshal.StringToHGlobalAuto(newText); 278Marshal.ThrowExceptionForHR(adapter.GetBuffer(out var lines)); 279Marshal.ThrowExceptionForHR(lines.GetLastLineIndex(out _, out var piLineIndex)); 280Marshal.ThrowExceptionForHR(lines.GetLengthOfLine(piLineIndex, out var piLineLength)); 286Marshal.ThrowExceptionForHR(lines.ReplaceLines(0, 0, piLineIndex, piLineLength, newTextPtr, newText.Length, changes)); 290Marshal.FreeHGlobal(newTextPtr);

ProjectSystem\FileChangeTracker.cs (2)

125Marshal.ThrowExceptionForHR( 179Marshal.ThrowExceptionForHR(

ProjectSystem\InvisibleEditor.cs (11)

53Marshal.ThrowExceptionForHR(invisibleEditorManager.RegisterInvisibleEditor(filePath, vsProject, 0, null, out var invisibleEditorPtr)); 57_invisibleEditor = (IVsInvisibleEditor)Marshal.GetUniqueObjectForIUnknown(invisibleEditorPtr); 65Marshal.ThrowExceptionForHR(VsTextLines.GetUndoManager(out _manager)); 66Marshal.ThrowExceptionForHR(((IVsUndoState)_manager).IsEnabled(out var isEnabled)); 78Marshal.Release(invisibleEditorPtr); 92Marshal.GetObjectForIUnknown(docDataPtrViaTextLines) is IVsTextLines vsTextLines) 100Marshal.GetObjectForIUnknown(docDataPtrViaTextBufferProvider) is IVsTextBufferProvider vsTextBufferProvider) 109Marshal.Release(docDataPtrViaTextBufferProvider); 112Marshal.Release(docDataPtrViaTextLines); 115Marshal.ThrowExceptionForHR(hr); 177Marshal.ReleaseComObject(_invisibleEditor);

Snippets\AbstractSnippetInfoService.cs (6)

187pSnippetInfo[0] = Marshal.AllocCoTaskMem(Marshal.SizeOf(snippetInfo)); 208Marshal.FreeCoTaskMem(pSnippetInfo[0]); 222var buffer = (VsExpansionWithIntPtrs)Marshal.PtrToStructure(expansionPtr, typeof(VsExpansionWithIntPtrs)); 237str = Marshal.PtrToStringBSTR(ptr); 238Marshal.FreeBSTR(ptr);

Snippets\SnippetExpansionClient.cs (3)

356xmlNode = (IXMLDOMNode)Marshal.GetUniqueObjectForIUnknown(pNode); 362if (xmlNode != null && Marshal.IsComObject(xmlNode)) 364Marshal.ReleaseComObject(xmlNode);

src\Compilers\Shared\GlobalAssemblyCacheHelpers\GlobalAssemblyCacheLocation.cs (3)

53throw Marshal.GetExceptionForHR(hr); 62throw Marshal.GetExceptionForHR(hr); 65return Marshal.PtrToStringUni((IntPtr)p);

TaskList\ProjectExternalErrorReporter.cs (1)

166Marshal.ThrowExceptionForHR(containedDocument.BufferCoordinator.MapPrimaryToSecondarySpan(

Utilities\ClipboardHelpers.cs (2)

133var win32Error = Marshal.GetLastWin32Error(); 145var win32Error = Marshal.GetLastWin32Error();

Utilities\Exceptions.cs (4)

16Marshal.ThrowExceptionForHR(VSConstants.E_FAIL, new IntPtr(-1)); 24Marshal.ThrowExceptionForHR(VSConstants.E_INVALIDARG, new IntPtr(-1)); 32Marshal.ThrowExceptionForHR(VSConstants.E_NOTIMPL, new IntPtr(-1)); 40Marshal.ThrowExceptionForHR(VSConstants.E_UNEXPECTED, new IntPtr(-1));

Utilities\VisualStudioCommandHandlerHelpers.cs (3)

52hierarchy = Marshal.GetObjectForIUnknown(selectionHierarchy) as IVsHierarchy; 66Marshal.Release(selectionHierarchy); 71Marshal.Release(selectionContainer);

Venus\ContainedDocument.cs (2)

220Marshal.ThrowExceptionForHR(BufferCoordinator.GetPrimaryBuffer(out var primaryTextLines)); 893Marshal.ThrowExceptionForHR(

Venus\ContainedLanguage.cs (2)

86Marshal.ThrowExceptionForHR(bufferCoordinator.GetSecondaryBuffer(out var secondaryTextLines)); 90Marshal.ThrowExceptionForHR(bufferCoordinator.GetPrimaryBuffer(out var primaryTextLines));

Venus\ContainedLanguage.IVsContainedLanguageCodeSupport.cs (4)

242var current = Marshal.AllocCoTaskMem(source.Count() * IntPtr.Size); 243Marshal.WriteIntPtr(dest, current); 246Marshal.WriteIntPtr(current, Marshal.StringToBSTR(s));

Workspace\GlobalUndoServiceFactory.WorkspaceGlobalUndoTransaction.cs (3)

52Marshal.ThrowExceptionForHR(_undoManager.OpenLinkedUndo((uint)LinkedTransactionFlags2.mdtGlobal, _description)); 107Marshal.ThrowExceptionForHR(result); 124Marshal.ThrowExceptionForHR(_undoManager.AbortLinkedUndo());

ProjectSystemShim\CSharpProjectShim.cs (3)

64_warningNumberArrayPointer = Marshal.AllocHGlobal(0); 85Marshal.FreeHGlobal(_warningNumberArrayPointer); 92Marshal.FreeHGlobal(@class);

ProjectSystemShim\CSharpProjectShim.ICSCompilerConfig.cs (1)

57=> Marshal.GetNativeVariantForObject(ProjectSystemProjectOptionsProcessor[optionID], variant);

ProjectSystemShim\CSharpProjectShim.ICSharpProjectSite.cs (2)

158Marshal.FreeHGlobal(@class); 161_startupClasses = [.. entryPointNames.Select(Marshal.StringToHGlobalUni)];

ProjectSystemShim\HACK_VariantStructure.cs (1)

43return Marshal.GetObjectForNativeVariant((IntPtr)(&localCopy));

ProjectSystemShim\CSharpHelpers.cs (2)

71Assert.Equal(8, (int)Marshal.OffsetOf<HACK_VariantStructure>("_booleanValue")); 74Marshal.GetNativeVariantForObject(value, (IntPtr)(&variant));

CodeModel\CodeModelTestHelpers.vb (4)

108Dim innerUnknown = Marshal.CreateAggregatedObject(wrapperUnknown, managedObject) 121Dim wrapperRCW = Marshal.GetObjectForIUnknown(wrapperUnknown) 124Marshal.Release(innerUnknown) 127Marshal.Release(wrapperUnknown)

MockVsFileChangeEx.vb (7)

149Marshal.ThrowExceptionForHR(AdviseFileChange(filename, CType(filter, UInteger), sink, cookie)) 159Marshal.ThrowExceptionForHR(AdviseFileChange(filename, CType(filter, UInteger), sink, cookie)) 172Marshal.ThrowExceptionForHR(UnadviseFileChange(cookie)) 185Marshal.ThrowExceptionForHR(UnadviseFileChange(cookie)) 196Marshal.ThrowExceptionForHR(AdviseDirChange(directory, If(watchSubdirectories, 1, 0), sink, cookie)) 204Marshal.ThrowExceptionForHR(UnadviseFileChange(cookie)) 217Marshal.ThrowExceptionForHR(UnadviseFileChange(cookie))

ProjectSystemShim\TempPECompiler.vb (1)

36Marshal.WriteInt32(pcErrors, errors)

ProjectSystemShim\VisualBasicProject.OptionsProcessor.vb (1)

151Marshal.ThrowExceptionForHR(sdkPathHResult, New IntPtr(-1))

ProjectSystemShim\VisualBasicProject.vb (2)

217Marshal.WriteInt32(pcActualItems, entryPoints.Count()) 237Marshal.WriteInt32(pcActualItems, count)

WindowsFileSystem.cs (2)

137int hr = Marshal.GetLastWin32Error(); 190int hr = Marshal.GetLastWin32Error();

CommunicationsUtilities.cs (2)

283throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());

NativeMethods.cs (12)

295_length = (uint)Marshal.SizeOf(typeof(MemoryStatus)); 400_nLength = (uint)Marshal.SizeOf(typeof(SecurityAttributes)); 523Marshal.GetLastWin32Error() == ERROR_INSUFFICIENT_BUFFER) 1035int errorCode = Marshal.GetLastWin32Error(); 1041errorCode = Marshal.GetLastWin32Error(); 1075int errorCode = Marshal.GetLastWin32Error(); 1081errorCode = Marshal.GetLastWin32Error(); 1132errorMessage = symbolicLinkCreated ? null : Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()).Message; 1137errorMessage = symbolicLinkCreated ? null : Marshal.GetLastWin32Error().ToString(); 1300Marshal.ThrowExceptionForHR(errorCode); 1582int code = Marshal.GetLastWin32Error();

src\libraries\shims\mscorlib\ref\mscorlib.cs (1)

707[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.InteropServices.Marshal))]

netstandard.cs (1)

1713[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.InteropServices.Marshal))]

MinimizeUtil.cs (2)

285throw new IOException($"Failed to create hard link from {existingFileName} to {fileName} with exception 0x{Marshal.GetLastWin32Error():X}"); 293throw new IOException($"Failed to create hard link from {existingFileName} to {fileName} with error code {Marshal.GetLastWin32Error()}");

MS\Internal\AppModel\CookieHandler.cs (1)

118if (!throwIfNoCookie && Marshal.GetLastWin32Error() == NativeMethods.ERROR_NO_MORE_ITEMS)

MS\Internal\DpiUtil\DpiUtil+WindowDpiScaleHelper.cs (1)

98Marshal.ThrowExceptionForHR(hr);

MS\Internal\FontCache\FontCacheUtil.cs (2)

75Marshal.Copy((IntPtr)_pointer, b, 0, Size); 828Util.ThrowWin32Exception(Marshal.GetLastWin32Error(), fileName);

MS\Internal\FontFace\FontDriver.cs (1)

250Marshal.Copy((IntPtr)fontData, fontCopy, 0, fileSize);

MS\Internal\Ink\GestureRecognizer\NativeRecognizer.cs (9)

520int allocationSize = (int)(Marshal.SizeOf(typeof(MS.Win32.Recognizer.PACKET_PROPERTY)) * packetDescription.cPacketProperties); 521packetDescription.pPacketProperties = Marshal.AllocCoTaskMem(allocationSize); 527Marshal.StructureToPtr(packetProperties[i], new IntPtr(pElement), false); 538packets = Marshal.AllocCoTaskMem(countOfBytes); 539Marshal.Copy(rawPackets, 0, packets, packetCount); 559Marshal.DestroyStructure(new IntPtr(pElement), typeof(MS.Win32.Recognizer.PACKET_PROPERTY)); 563Marshal.FreeCoTaskMem(pd.pPacketProperties); 569Marshal.FreeCoTaskMem(pd.pguidButtons); 575Marshal.FreeCoTaskMem(packets);

MS\Internal\IO\Packaging\ByteRangeDownloader.cs (1)

478throw new Win32Exception(Marshal.GetLastWin32Error());

MS\Internal\Text\TextInterface\DWriteUtil.cs (2)

39System.Runtime.InteropServices.Marshal.ThrowExceptionForHR(hr, new System.IntPtr(-1)); 55System.Exception e = System.Runtime.InteropServices.Marshal.GetExceptionForHR(hr);

MS\Internal\Text\TextInterface\Factory.cs (10)

61IntPtr pIDWriteFontFileLoaderMirror = Marshal.GetComInterfaceForObject( 77Marshal.Release(pIDWriteFontFileLoaderMirror); 81IntPtr pIDWriteFontCollectionLoaderMirror = Marshal.GetComInterfaceForObject( 88Marshal.Release(pIDWriteFontCollectionLoaderMirror); 300IntPtr pIDWriteFontCollectionLoaderMirror = Marshal.GetComInterfaceForObject( 315Marshal.Release(pIDWriteFontCollectionLoaderMirror); 353IntPtr pIDWriteFontCollectionLoaderMirror = Marshal.GetComInterfaceForObject( 358Marshal.Release(pIDWriteFontCollectionLoaderMirror); 365IntPtr pIDWriteFontFileLoaderMirror = Marshal.GetComInterfaceForObject( 370Marshal.Release(pIDWriteFontFileLoaderMirror);

MS\Internal\Text\TextInterface\FontCollectionLoader.cs (2)

68IntPtr pIDWriteFontFileEnumeratorMirror = Marshal.GetComInterfaceForObject( 76hr = Marshal.GetHRForException(exception);

MS\Internal\TextFormatting\LineServicesCallbacks.cs (1)

2311Marshal.StructureToPtr(inlineInit, (System.IntPtr)objectInfo, false);

MS\Internal\WindowsRuntime\Windows\UI\ViewManagement\InputPane.cs (1)

247Marshal.ReleaseComObject(_inputPane);

MS\Internal\WindowsRuntime\Windows\UI\ViewManagement\InputPaneRcw.cs (3)

25Marshal.ThrowExceptionForHR(NativeMethods.WindowsCreateString(typeName, typeName.Length, out hstring)); 29Marshal.ThrowExceptionForHR(NativeMethods.RoGetActivationFactory(hstring, ref iid, out object factory)); 34Marshal.ThrowExceptionForHR(NativeMethods.WindowsDeleteString(hstring));

MS\Internal\WindowsRuntime\Windows\UI\ViewManagement\UISettings.cs (1)

167Marshal.ReleaseComObject(_uisettings);

MS\Internal\WindowsRuntime\Windows\UI\ViewManagement\UISettingsRcw.cs (3)

21Marshal.ThrowExceptionForHR(hr); 25Marshal.ThrowExceptionForHR(hr); 31Marshal.ThrowExceptionForHR(hr);

src\Microsoft.DotNet.Wpf\src\Common\Graphics\wgx_render.cs (1)

775Exception exceptionForHR = Marshal.GetExceptionForHR(hr, (IntPtr)(-1));

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\SafeSecurityHelper.cs (1)

52int win32Err = Marshal.GetLastWin32Error();

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\SecurityHelper.cs (4)

133return Marshal.GetExceptionForHR(hr, new IntPtr(-1)); 140Marshal.ThrowExceptionForHR(hr, new IntPtr(-1)); 150int hr = Marshal.GetHRForException(exception); 154Marshal.GetHRForException(new Exception());

src\Microsoft.DotNet.Wpf\src\Shared\MS\Win32\WinInet.cs (3)

28UInt32 size = (UInt32)Marshal.SizeOf(icci); 38int hr = Marshal.GetHRForLastWin32Error(); 42Marshal.ThrowExceptionForHR(hr);

System\Windows\DpiChangedEventArgs.cs (1)

48NativeMethods.RECT suggestedRect = Marshal.PtrToStructure<NativeMethods.RECT>(lParam);

System\Windows\Input\Cursor.cs (1)

174int errorCode = Marshal.GetLastWin32Error();

System\Windows\Input\DefaultTextStore.cs (1)

283Marshal.ReleaseComObject(compartment);

System\Windows\Input\DefaultTextStoreTextComposition.cs (4)

65Marshal.ReleaseComObject(composition); 68Marshal.ReleaseComObject(context); 88Marshal.ReleaseComObject(doc); 107Marshal.ReleaseComObject(enumCompositionView);

System\Windows\Input\InputMethod.cs (5)

1510Marshal.ReleaseComObject(fnConfigure); 1513Marshal.ReleaseComObject(funcPrv); 1563Marshal.ReleaseComObject(fnConfigure); 1566Marshal.ReleaseComObject(funcPrv); 1674Marshal.ReleaseComObject(enumIpp);

System\Windows\Input\InputProcessorProfiles.cs (3)

85Marshal.ReleaseComObject(_ipp); 156short langid = Marshal.PtrToStructure<short>((IntPtr)((Int64)langids + sizeof(short) * i)); 161Marshal.FreeCoTaskMem(langids);

System\Windows\Input\Stylus\Wisp\PenThreadWorker.cs (2)

791Marshal.Copy(pPackets, data, 0, cItems); 1120Marshal.ReleaseComObject(penContext._pimcContext);

System\Windows\Input\Stylus\Wisp\WispTabletDevice.cs (1)

342Marshal.ReleaseComObject(tablet);

System\Windows\Input\Stylus\Wisp\WispTabletDeviceCollection.cs (3)

123int result = (int)MS.Win32.UnsafeNativeMethods.GetRawInputDeviceList(null, ref deviceCount, (uint)Marshal.SizeOf(typeof(NativeMethods.RAWINPUTDEVICELIST))); 128int count = (int)MS.Win32.UnsafeNativeMethods.GetRawInputDeviceList(ridl, ref deviceCount, (uint)Marshal.SizeOf(typeof(NativeMethods.RAWINPUTDEVICELIST))); 138cbSize = (uint)Marshal.SizeOf(typeof(NativeMethods.RID_DEVICE_INFO))

System\Windows\Input\TextServicesCompartment.cs (6)

98Marshal.ReleaseComObject(compartment); 99Marshal.ReleaseComObject(source); 117Marshal.ReleaseComObject(compartment); 118Marshal.ReleaseComObject(source); 198Marshal.ReleaseComObject(compartment); 210Marshal.ReleaseComObject(compartment);

System\Windows\Input\TextServicesContext.cs (6)

81Marshal.ReleaseComObject(_defaultTextStore.DocumentManager); 120Marshal.ReleaseComObject(_dimEmpty); 129Marshal.ReleaseComObject(_threadManager); 218Marshal.ReleaseComObject(context); 359Marshal.ReleaseComObject(comp); 391Marshal.ReleaseComObject(comp);

System\Windows\InterOp\HwndMouseInputProvider.cs (1)

231int n = UnsafeNativeMethods.GetMouseMovePointsEx((uint)(Marshal.SizeOf(mp_in)), ref mp_in, mp_out, 64, mode);

System\Windows\InterOp\HwndSource.cs (2)

1347NativeMethods.WINDOWPOS windowPos = Marshal.PtrToStructure<NativeMethods.WINDOWPOS>(lParam); 1396Marshal.StructureToPtr(windowPos, lParam, true);

System\Windows\InterOp\HwndTarget.cs (3)

877Marshal.PtrToStructure<NativeMethods.RECT>(lParam); 1462return new IntPtr(Marshal.GetHRForException(e)); 1865NativeMethods.WINDOWPOS windowPos = Marshal.PtrToStructure<NativeMethods.WINDOWPOS>(lParam);

System\Windows\Media\ByteStreamGeometryContext.cs (2)

493Marshal.Copy(_chunkList[currentChunk], bufferOffset, (IntPtr)pbData, cbDataForThisChunk); 497Marshal.Copy((IntPtr)pbData, _chunkList[currentChunk], bufferOffset, cbDataForThisChunk);

System\Windows\Media\ColorContext.cs (2)

646HRESULT.Check(Marshal.GetHRForLastWin32Error()); 660HRESULT.Check(Marshal.GetHRForLastWin32Error());

System\Windows\Media\ColorContextHelper.cs (1)

93HRESULT.Check(Marshal.GetHRForLastWin32Error());

System\Windows\Media\ColorTransformHelper.cs (1)

100HRESULT.Check(Marshal.GetHRForLastWin32Error());

System\Windows\Media\EventProxy.cs (1)

93return Marshal.GetHRForException(e);

System\Windows\Media\GlyphTypeface.cs (1)

1280Marshal.Copy(new IntPtr(pMilPathGeometry), data, 0, checked((int)size));

System\Windows\Media\ImageSourceConverter.cs (2)

228if (Marshal.ReadInt16(addr) != 0x1c15) 239OBJECTHEADER pHeader = Marshal.PtrToStructure<OBJECTHEADER>(addr);

System\Windows\Media\Imaging\BitmapEncoder.cs (2)

28pstrName = Marshal.StringToCoTaskMemUni(name); 33Marshal.FreeCoTaskMem(pstrName);

System\Windows\Media\Imaging\BitmapMetadata.cs (3)

233pIEnumMetadata = Marshal.GetComInterfaceForObject( 683blockWriter = Marshal.GetComInterfaceForObject( 732blockWriter = Marshal.GetComInterfaceForObject(

System\Windows\Media\Imaging\BitmapMetadataEnumerator.cs (2)

82_current = Marshal.PtrToStringUni(ppStr); 89Marshal.FreeCoTaskMem(ppStr);

System\Windows\Media\Imaging\BitmapSource.cs (3)

571_wicSource = new BitmapSourceSafeMILHandle(Marshal.GetComInterfaceForObject( 1791rc = Marshal.PtrToStructure<Int32Rect>(prc); 1833Marshal.Copy(managedArray, y * rectRowSize, new IntPtr(rowPtr), rectRowSize);

System\Windows\Media\Imaging\PropVariant.cs (40)

System\Windows\Media\Imaging\WriteableBitmap.cs (2)

1072elementSize = Marshal.SizeOf(exemplar); 1100elementSize = Marshal.SizeOf(exemplar);

System\Windows\Media\MediaContextNotificationWindow.cs (1)

187ChangeWindowMessageFilterNative function = Marshal.GetDelegateForFunctionPointer(

System\Windows\Media\RenderData.cs (2)

108Marshal.Copy((IntPtr)(&header), this._buffer, _curOffset, sizeof(RecordHeader)); 109Marshal.Copy((IntPtr)pbRecord, this._buffer, _curOffset + sizeof(RecordHeader), cbRecordSize);

MS\Internal\AppModel\AppSecurityManager.cs (1)

119sei.cbSize = Marshal.SizeOf(sei);

MS\Internal\AppModel\IconHelper.cs (1)

234Marshal.Copy(colorArray, 0, bits, colorArray.Length);

MS\Internal\Controls\ActiveXSite.cs (1)

259lpFrameInfo.cb = (uint)Marshal.SizeOf(typeof(NativeMethods.OLEINPLACEFRAMEINFO));

MS\Internal\Controls\ConnectionPointCookie.cs (4)

47else if (sink == null || !eventInterface.IsInstanceOfType(sink) && !Marshal.IsComObject(sink)) 57Marshal.FinalReleaseComObject(connectionPoint); 73Marshal.FinalReleaseComObject(connectionPoint); 114System.Runtime.InteropServices.Marshal.FinalReleaseComObject(connectionPoint);

MS\Internal\Controls\EnumUnknown.cs (4)

40Marshal.WriteInt32(pceltFetched, 0, 0); 58Marshal.WriteIntPtr(rgelt, Marshal.GetIUnknownForObject(this.arr[this.loc])); 66Marshal.WriteInt32(pceltFetched, 0, fetched);

MS\Internal\IO\Packaging\indexingfiltermarshaler.cs (9)

104Marshal.Copy(s.ToCharArray(), 0, p, s.Length); 107Marshal.WriteInt16(p, s.Length * _int16Size, 0); 125native.union.name = Marshal.StringToCoTaskMemUni(propSpec.PropName); 187pszVal = Marshal.StringToCoTaskMemAnsi((string)obj); 212pNative = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(PROPVARIANT))); 218Marshal.StructureToPtr(v, pNative, false); 224Marshal.FreeCoTaskMem(pszVal); 229Marshal.FreeCoTaskMem(pNative);

MS\Internal\IO\Packaging\ManagedFilter.cs (1)

121PropName = Marshal.PtrToStringUni(propSpec.union.name);

MS\Internal\IO\Packaging\ManagedIStream.cs (3)

46Marshal.WriteInt32(bytesReadPtr, bytesRead); 85Marshal.WriteInt64(newPositionPtr, position); 150Marshal.WriteInt32(bytesWrittenPtr, bufferSize);

MS\Internal\IO\Packaging\XpsFilter.cs (4)

125Marshal.WriteInt16(pBuffer, 0); 180short shCharacter = Marshal.ReadInt16(pBuffer); 199shCharacter = Marshal.ReadInt16(pBuffer, _int16Size); 257Marshal.WriteInt16(pBuffer, (int)bufCharacterCount * _int16Size, 0);

MS\Internal\Printing\NativeMethods.cs (2)

28public int lStructSize = Marshal.SizeOf(typeof(PRINTDLGEX32)); 54public int lStructSize = Marshal.SizeOf(typeof(PRINTDLGEX64));

MS\Internal\Printing\PrintDlgExMarshaler.cs (37)

MS\Internal\WindowsRuntime\Generated\Windows.Data.Text.cs (14)

458var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 3); 459Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 630var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 17); 631Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 1142var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 3); 1143Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 1294var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 4); 1295Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 1482var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 1); 1483Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 1574Invoke = Marshal.GetFunctionPointerForDelegate(AbiInvokeDelegate) 1576var nativeVftbl = ComWrappersSupport.AllocateVtableMemory(typeof(WordSegmentsTokenizingHandler), Marshal.SizeOf<global::WinRT.Interop.IDelegateVftbl>()); 1577Marshal.StructureToPtr(AbiToProjectionVftable, nativeVftbl, false); 1607var abiInvoke = Marshal.GetDelegateForFunctionPointer<Abi_Invoke>(_nativeDelegate.Vftbl.Invoke);

MS\Internal\WindowsRuntime\Generated\Windows.Globalization.cs (12)

233var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 4); 234Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 417var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 1); 418Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 491var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 1); 492Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 572var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 1); 573Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 655var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 2); 656Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 771var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 1); 772Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false);

MS\Internal\WindowsRuntime\Generated\WinRT.cs (15)

MS\Internal\WindowsRuntime\Generated\WinRT\ComWrappersSupport.net5.cs (5)

65QueryInterface = Marshal.GetDelegateForFunctionPointer<IUnknownVftbl._QueryInterface>(qi), 66AddRef = Marshal.GetDelegateForFunctionPointer<IUnknownVftbl._AddRef>(addRef), 67Release = Marshal.GetDelegateForFunctionPointer<IUnknownVftbl._Release>(release), 91ComInterfaceEntry* nativeEntries = (ComInterfaceEntry*)Marshal.AllocCoTaskMem(sizeof(ComInterfaceEntry) * count); 151Marshal.FreeCoTaskMem((IntPtr)_data);

MS\Internal\WindowsRuntime\Generated\WinRT\Context.cs (1)

17Marshal.ThrowExceptionForHR(CoGetObjectContext(ref riid, out IntPtr contextCallbackPtr));

MS\Internal\WindowsRuntime\Generated\WinRT\ExceptionHelpers.cs (4)

96Marshal.ThrowExceptionForHR(getRestrictedErrorInfo(out IntPtr restrictedErrorInfoPtr)); 148ex = Marshal.GetExceptionForHR(hr, iErrorInfo?.ThisPtr ?? (IntPtr)(-1)); 208Marshal.ThrowExceptionForHR(getRestrictedErrorInfo(out IntPtr ppRestrictedErrorInfo)); 311Marshal.ThrowExceptionForHR(getRestrictedErrorInfo(out IntPtr restrictedErrorInfoPtr));

MS\Internal\WindowsRuntime\Generated\WinRT\IInspectable.cs (4)

45AbiToProjectionVftablePtr = Marshal.AllocHGlobal(Marshal.SizeOf<Vftbl>()); 46Marshal.StructureToPtr(AbiToProjectionVftable, AbiToProjectionVftablePtr, false); 112Marshal.ThrowExceptionForHR(hr);

MS\Internal\WindowsRuntime\Generated\WinRT\Interop\ExceptionErrorInfo.cs (38)

MS\Internal\WindowsRuntime\Generated\WinRT\Interop\IContextCallback.cs (1)

77Marshal.ThrowExceptionForHR(_obj.Vftbl.ContextCallback_4(ThisPtr, pfnCallback, pParam, ref riid, iMethod, IntPtr.Zero));

MS\Internal\WindowsRuntime\Generated\WinRT\Interop\IUnknownVftbl.cs (3)

25AbiToProjectionVftblPtr = Marshal.AllocHGlobal(Marshal.SizeOf<IUnknownVftbl>()); 26Marshal.StructureToPtr(AbiToProjectionVftbl, AbiToProjectionVftblPtr, false);

MS\Internal\WindowsRuntime\Generated\WinRT\Marshalers.cs (27)

54Marshal.ThrowExceptionForHR(Platform.WindowsCreateStringReference( 106Marshal.ThrowExceptionForHR( 124Marshal.FreeCoTaskMem(_array); 143m._array = Marshal.AllocCoTaskMem(length * IntPtr.Size); 210data = Marshal.AllocCoTaskMem(length * IntPtr.Size); 268Marshal.FreeCoTaskMem(abi.data); 308var byte_length = length * Marshal.SizeOf<T>(); 309var data = Marshal.AllocCoTaskMem(byte_length); 319int byte_length = array.Length * Marshal.SizeOf<T>(); 335Marshal.FreeCoTaskMem(abi.data); 439Marshal.FreeCoTaskMem(_array); 458var abi_element_size = Marshal.SizeOf(HelperType); 460m._array = Marshal.AllocCoTaskMem(byte_length); 493var abi_element_size = Marshal.SizeOf(HelperType); 496var abi_element = Marshal.PtrToStructure((IntPtr)data, HelperType); 511var abi_element_size = Marshal.SizeOf(HelperType); 514var abi_element = Marshal.PtrToStructure((IntPtr)data, HelperType); 538var abi_element_size = Marshal.SizeOf(HelperType); 540data = Marshal.AllocCoTaskMem(byte_length); 568var abi_element_size = Marshal.SizeOf(HelperType); 587var abi_element_size = Marshal.SizeOf(HelperType); 590var abi_element = Marshal.PtrToStructure((IntPtr)data, HelperType); 602Marshal.FreeCoTaskMem(abi.data); 621Marshal.FreeCoTaskMem(_array); 641m._array = Marshal.AllocCoTaskMem(byte_length); 699data = Marshal.AllocCoTaskMem(byte_length); 756Marshal.FreeCoTaskMem(abi.data);

MS\Internal\WindowsRuntime\Generated\WinRT\ObjectReference.cs (6)

55Marshal.ThrowExceptionForHR(VftblIUnknown.QueryInterface(ThisPtr, ref iid, out IntPtr thatPtr)); 130releaseDelegate = Marshal.PtrToStructure<IUnknownVftbl>(Marshal.PtrToStructure<VftblPtr>(ThisPtr).Vftbl).Release; 206var vftblPtr = Marshal.PtrToStructure<VftblPtr>(thisPtr); 207var vftblIUnknown = Marshal.PtrToStructure<IUnknownVftbl>(vftblPtr.Vftbl); 215vftblT = Marshal.PtrToStructure<T>(vftblPtr.Vftbl);

MS\Internal\WindowsRuntime\Generated\WinRT\Projections\IEnumerable.cs (21)

102var vftblPtr = Marshal.PtrToStructure<VftblPtr>(thisPtr); 104IInspectableVftbl = Marshal.PtrToStructure<IInspectable.Vftbl>(vftblPtr.Vftbl); 105First_0 = Marshal.GetDelegateForFunctionPointer<IEnumerable_Delegates.First_0>(vftbl[6]); 117var nativeVftbl = (IntPtr*)Marshal.AllocCoTaskMem(Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 1); 118Marshal.StructureToPtr(AbiToProjectionVftable.IInspectableVftbl, (IntPtr)nativeVftbl, false); 119nativeVftbl[6] = Marshal.GetFunctionPointerForDelegate(AbiToProjectionVftable.First_0); 301if (Marshal.GetHRForException(e) == ExceptionHelpers.E_CHANGED_STATE) 428var vftblPtr = Marshal.PtrToStructure<VftblPtr>(thisPtr); 430IInspectableVftbl = Marshal.PtrToStructure<IInspectable.Vftbl>(vftblPtr.Vftbl); 431get_Current_0 = Marshal.GetDelegateForFunctionPointer(vftbl[6], get_Current_0_Type); 432get_HasCurrent_1 = Marshal.GetDelegateForFunctionPointer<_get_PropertyAsBoolean>(vftbl[7]); 433MoveNext_2 = Marshal.GetDelegateForFunctionPointer<IEnumerator_Delegates.MoveNext_2>(vftbl[8]); 434GetMany_3 = Marshal.GetDelegateForFunctionPointer<IEnumerator_Delegates.GetMany_3>(vftbl[9]); 449var nativeVftbl = (IntPtr*)Marshal.AllocCoTaskMem(Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 4); 450Marshal.StructureToPtr(AbiToProjectionVftable.IInspectableVftbl, (IntPtr)nativeVftbl, false); 451nativeVftbl[6] = Marshal.GetFunctionPointerForDelegate(AbiToProjectionVftable.get_Current_0); 452nativeVftbl[7] = Marshal.GetFunctionPointerForDelegate(AbiToProjectionVftable.get_HasCurrent_1); 453nativeVftbl[8] = Marshal.GetFunctionPointerForDelegate(AbiToProjectionVftable.MoveNext_2); 454nativeVftbl[9] = Marshal.GetFunctionPointerForDelegate(AbiToProjectionVftable.GetMany_3);

MS\Internal\WindowsRuntime\Generated\WinRT\Projections\IReadOnlyList.cs (13)

218var vftblPtr = Marshal.PtrToStructure<VftblPtr>(thisPtr); 220IInspectableVftbl = Marshal.PtrToStructure<IInspectable.Vftbl>(vftblPtr.Vftbl); 221GetAt_0 = Marshal.GetDelegateForFunctionPointer(vftbl[6], GetAt_0_Type); 222get_Size_1 = Marshal.GetDelegateForFunctionPointer<_get_PropertyAsUInt32>(vftbl[7]); 223IndexOf_2 = Marshal.GetDelegateForFunctionPointer(vftbl[8], IndexOf_2_Type); 224GetMany_3 = Marshal.GetDelegateForFunctionPointer<IReadOnlyList_Delegates.GetMany_3>(vftbl[9]); 239var nativeVftbl = (IntPtr*)Marshal.AllocCoTaskMem(Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 4); 240Marshal.StructureToPtr(AbiToProjectionVftable.IInspectableVftbl, (IntPtr)nativeVftbl, false); 241nativeVftbl[6] = Marshal.GetFunctionPointerForDelegate(AbiToProjectionVftable.GetAt_0); 242nativeVftbl[7] = Marshal.GetFunctionPointerForDelegate(AbiToProjectionVftable.get_Size_1); 243nativeVftbl[8] = Marshal.GetFunctionPointerForDelegate(AbiToProjectionVftable.IndexOf_2); 244nativeVftbl[9] = Marshal.GetFunctionPointerForDelegate(AbiToProjectionVftable.GetMany_3);

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\SecurityHelper.cs (1)

133return Marshal.GetExceptionForHR(hr, new IntPtr(-1));

System\Windows\Controls\PasswordBox.cs (2)

154IntPtr ptr = System.Runtime.InteropServices.Marshal.SecureStringToBSTR(securePassword); 165System.Runtime.InteropServices.Marshal.ZeroFreeBSTR(ptr);

System\Windows\Controls\Primitives\Popup.cs (2)

2678cbSize = Marshal.SizeOf(typeof(NativeMethods.MONITORINFOEX)) 2776int resultOfGetObject = UnsafeNativeMethods.GetObject(iconInfo.hbmMask.MakeHandleRef(null), Marshal.SizeOf(typeof(NativeMethods.BITMAP)), bm);

System\Windows\Controls\WebBrowser.cs (1)

430if (!Marshal.IsTypeVisibleFromCom(t))

System\windows\Documents\CaretElement.cs (4)

992int win32Error = Marshal.GetLastWin32Error(); 1024int win32Error = Marshal.GetLastWin32Error(); 1078int win32Error = Marshal.GetLastWin32Error(); 1090win32Error = Marshal.GetLastWin32Error();

System\Windows\Documents\FrameworkTextComposition.cs (4)

163Marshal.ReleaseComObject(composition); 166Marshal.ReleaseComObject(context); 177Marshal.ReleaseComObject(context); 325Marshal.ReleaseComObject(enumCompositionView);

System\Windows\Documents\ImmComposition.cs (7)

1330int requestSize = Marshal.SizeOf(typeof(NativeMethods.RECONVERTSTRING)) + (target.Length * sizeof(short)) + ((_maxSrounding + 1) * sizeof(short) * 2); 1339NativeMethods.RECONVERTSTRING reconv = Marshal.PtrToStructure<NativeMethods.RECONVERTSTRING>(lParam); 1344reconv.dwStrOffset = Marshal.SizeOf(typeof(NativeMethods.RECONVERTSTRING)); // in byte count 1361Marshal.StructureToPtr(reconv, lParam, true); 1374p += Marshal.SizeOf(typeof(NativeMethods.RECONVERTSTRING)); 1375Marshal.Copy(surrounding.ToCharArray(), 0, new IntPtr((void*)p), surrounding.Length); 1501NativeMethods.RECONVERTSTRING reconv = Marshal.PtrToStructure<NativeMethods.RECONVERTSTRING>(lParam);

System\Windows\Documents\InputScopeAttribute.cs (9)

56ppinputscopes = Marshal.AllocCoTaskMem(sizeof(Int32) * count); 65Marshal.WriteInt32(ppinputscopes, offset, (Int32)((InputScopeName)_inputScope.Names[i]).NameValue); 71ppinputscopes = Marshal.AllocCoTaskMem(sizeof(Int32) * 1); 72Marshal.WriteInt32(ppinputscopes, (Int32)InputScopeNameValue.Default); 84ppbstrPhrases = Marshal.AllocCoTaskMem(IntPtr.Size * count); 97pbstr = Marshal.StringToBSTR(((InputScopePhrase)_inputScope.PhraseList[i]).Name); 104Marshal.FreeBSTR(Marshal.ReadIntPtr(ppbstrPhrases, offset)); 110Marshal.WriteIntPtr(ppbstrPhrases , offset, pbstr);

System\Windows\Documents\MsSpellCheckLib\SpellChecker\OptionDescription.cs (1)

76Marshal.ReleaseComObject(optionDescription);

System\Windows\Documents\MsSpellCheckLib\SpellChecker\SpellChecker.cs (1)

615Marshal.ReleaseComObject(_speller.Value);

System\Windows\Documents\MsSpellCheckLib\SpellChecker\SpellingError.cs (1)

104Marshal.ReleaseComObject(error);

System\Windows\Documents\MsSpellCheckLib\SpellCheckerFactory\SpellCheckerFactory.cs (1)

122Marshal.ReleaseComObject(Singleton.ComFactory);

System\Windows\Documents\MsSpellCheckLib\Utils\Extensions.cs (4)

59Marshal.ReleaseComObject(enumString); 106Marshal.ReleaseComObject(spellingErrors); 164Marshal.ReleaseComObject(iSpellingError); 176Marshal.ReleaseComObject(spellingErrors);

System\Windows\Documents\NLGSpellerInterop.cs (19)

System\windows\Documents\TextEditor.cs (1)

1546Marshal.ReleaseComObject(threadManager);

System\windows\Documents\TextEditorContextMenu.cs (2)

587Marshal.ReleaseComObject(candString); 653Marshal.ReleaseComObject(CandidateList);

System\Windows\Documents\TextFindEngine.cs (1)

579int win32Error = System.Runtime.InteropServices.Marshal.GetLastWin32Error();

System\Windows\Documents\TextServicesDisplayAttributePropertyRanges.cs (6)

160Marshal.ReleaseComObject(attributeRanges[0]); 179Marshal.ReleaseComObject(attributeRangeEnumerator); 182Marshal.ReleaseComObject(displayAttributeProperty); 232Marshal.ReleaseComObject(catmgr); 256Marshal.ReleaseComObject(dai); 264Marshal.ReleaseComObject(dam);

System\Windows\Documents\TextServicesHost.cs (6)

142Marshal.ReleaseComObject(comp); 171Marshal.ReleaseComObject(comp); 240Marshal.ReleaseComObject(context); 244Marshal.ReleaseComObject(textstore.DocumentManager); 339Marshal.ReleaseComObject(context); 377Marshal.ReleaseComObject(_threadManager);

System\Windows\Documents\TextServicesPropertyRanges.cs (5)

88Marshal.ReleaseComObject(outRangesProp[0]); 90Marshal.ReleaseComObject(rangesProp); 93Marshal.ReleaseComObject(outRanges[0]); 95Marshal.ReleaseComObject(ranges); 97Marshal.ReleaseComObject(prop);

System\Windows\Documents\TextStore.cs (17)

System\Windows\Interop\ActiveXHost.cs (1)

588Marshal.FinalReleaseComObject(_axInstance);

System\Windows\Shell\WindowChromeWorker.cs (3)

413var rcClientArea = Marshal.PtrToStructure<RECT>(lParam); 431Marshal.StructureToPtr(rcClientArea, lParam, false); 576var wp = Marshal.PtrToStructure<WINDOWPOS>(lParam);

System\Windows\Standard\ErrorCodes.cs (1)

105return new Win32Error(Marshal.GetLastWin32Error());

System\Windows\Standard\MessageWindow.cs (2)

45cbSize = Marshal.SizeOf(typeof(WNDCLASSEX)), 148var createStruct = Marshal.PtrToStructure<CREATESTRUCT>(lParam);

System\Windows\Standard\NativeMethods.cs (9)

1875cbSize = Marshal.SizeOf(typeof(NONCLIENTMETRICS)) 1888cbSize = Marshal.SizeOf(typeof(NONCLIENTMETRICS)) - sizeof(int) 1934public int cbSize = Marshal.SizeOf(typeof(MONITORINFO)); 2153public int length = Marshal.SizeOf(typeof(WINDOWPLACEMENT)); 2328var filterstruct = new CHANGEFILTERSTRUCT { cbSize = (uint)Marshal.SizeOf(typeof(CHANGEFILTERSTRUCT)) }; 2361IntPtr currArg = Marshal.ReadIntPtr(argv, i * IntPtr.Size); 2362result[i] = Marshal.PtrToStringUni(currArg); 3020var hc = new HIGHCONTRAST { cbSize = Marshal.SizeOf(typeof(HIGHCONTRAST)) }; 3182var dti = new DWM_TIMING_INFO { cbSize = Marshal.SizeOf(typeof(DWM_TIMING_INFO)) };

System\Windows\Standard\Utilities.cs (2)

213Assert.IsTrue(Marshal.IsComObject(t)); 214Marshal.ReleaseComObject(t);

System\Windows\SystemParameters.cs (1)

170cbSize = Marshal.SizeOf(typeof(NativeMethods.HIGHCONTRAST_I))

System\Windows\Window.cs (5)

3958length = Marshal.SizeOf(typeof(NativeMethods.WINDOWPLACEMENT)) 5222placement.length = Marshal.SizeOf(placement); 5912length = Marshal.SizeOf(typeof(NativeMethods.WINDOWPLACEMENT)) 6000cbSize = Marshal.SizeOf(typeof(NativeMethods.MONITORINFOEX)) 7407cbSize = Marshal.SizeOf(typeof(NativeMethods.MONITORINFOEX))

MS\Internal\Documents\PeoplePickerWrapper.cs (13)

133(uint)Marshal.SizeOf(typeof(UnsafeNativeMethods.QueryInitParams)), 144IntPtr queryInitParamsPtr = Marshal.AllocCoTaskMem(Marshal.SizeOf(queryInitParams)); 154Marshal.StructureToPtr(queryInitParams, queryInitParamsPtr, false /*fDeleteOld*/); 168(uint)Marshal.SizeOf(typeof(UnsafeNativeMethods.OpenQueryWindowParams)), 194Marshal.FreeCoTaskMem(queryInitParamsPtr); 325_ptrToDsObjectNames = Marshal.AllocHGlobal(data.Length); 329Marshal.Copy(data, 0, _ptrToDsObjectNames, data.Length); 333_dsObjectNames = Marshal.PtrToStructure<UnsafeNativeMethods.DsObjectNames>(_ptrToDsObjectNames); 422return Marshal.PtrToStringAuto(nameOffset); 455UnsafeNativeMethods.DsObject dsObject = Marshal.PtrToStructure<UnsafeNativeMethods.DsObject>(offset); 479Marshal.FreeHGlobal(_ptrToDsObjectNames); 524Marshal.SizeOf(typeof(UnsafeNativeMethods.DsObject));

MS\Internal\Printing\Configuration\DevMode.cs (3)

460short dmSize = Marshal.ReadInt16(devModeWPointer, DevMode.DEVMODEW_dmSizeByteOffset); 461short dmExtraSize = Marshal.ReadInt16(devModeWPointer, DevMode.DEVMODEW_dmDriverExtraByteOffset); 465Marshal.Copy(devModeWPointer, devModeWBytes, 0, devModeWByteSize);

MS\Internal\Printing\Configuration\WinSpoolPrinterCapabilities.cs (8)

394return GetArrayCapability<T>(capability, readItem, Marshal.SizeOf(typeof(T))); 449result[i] = (uint)Marshal.ReadInt32(baseAddr, offset); 475result[i] = Marshal.ReadInt16(baseAddr, offset); 501int x = Marshal.ReadInt32(baseAddr, offset); 502int y = Marshal.ReadInt32(baseAddr, offset + (itemByteSize / 2)); 529int w = Marshal.ReadInt32(baseAddr, offset); 530int h = Marshal.ReadInt32(baseAddr, offset + (itemByteSize / 2)); 558string str = Marshal.PtrToStringUni(strAddr, itemByteSize / 2);

PrintConfig\FallbackPTProvider.cs (9)

57throw new PrintQueueException(Marshal.GetLastWin32Error(), "PrintConfig.Provider.BindFail", deviceName); 751IntPtr pPrinterName = Marshal.ReadIntPtr(ptr, 1 * IntPtr.Size); 754PRINTER_INFO_2.pPrinterName = Marshal.PtrToStringUni(pPrinterName); 758IntPtr pPortName = Marshal.ReadIntPtr(ptr, 3 * IntPtr.Size); 761PRINTER_INFO_2.pPortName = Marshal.PtrToStringUni(pPortName); 765IntPtr pDriverName = Marshal.ReadIntPtr(ptr, 4 * IntPtr.Size); 768PRINTER_INFO_2.pDriverName = Marshal.PtrToStringUni(pDriverName); 772IntPtr pDevMode = Marshal.ReadIntPtr(ptr, 7 * IntPtr.Size); 817IntPtr pDevMode = Marshal.ReadIntPtr(pPrinterBuffer.Handle.DangerousGetHandle());

PrintConfig\PTProvider.cs (7)

390IntPtr umDevMode = Marshal.AllocCoTaskMem(devMode.Length); 394Marshal.Copy(devMode, 0, umDevMode, devMode.Length); 424Marshal.FreeCoTaskMem(umDevMode); 476Marshal.Copy(umDevMode, devMode, 0, (int)umDevModeLen); 601Marshal.ReleaseComObject(result); 794Marshal.ThrowExceptionForHR((int)hResult); 804Marshal.ReleaseComObject(stream);

src\Compilers\Shared\BuildServerConnection.cs (2)

473startInfo.cb = Marshal.SizeOf(startInfo); 507logger.LogError("Failed to create process. GetLastError={0}", Marshal.GetLastWin32Error());

EditAndContinue\EditAndContinueTest.cs (1)

211var isInException = Marshal.GetExceptionPointers() != IntPtr.Zero;

Reader\PdbTestUtilities.cs (1)

39Marshal.ThrowExceptionForHR(hr);

Reader\PdbValidation.cs (2)

547Marshal.ThrowExceptionForHR(symReader.GetSourceServerData(out byte* data, out int size)); 554Marshal.Copy((IntPtr)data, result, 0, result.Length);

System\ComponentModel\ReferenceConverter.cs (1)

101if (!Marshal.IsComObject(value) && value is IComponent comp)

System\ComponentModel\TypeDescriptor.cs (1)

1764Marshal.Release(unknown);

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\Interop\Unix\System.Native\Interop.GetPwUid.cs (1)

70username = Marshal.PtrToStringUTF8((IntPtr)passwd.Name);

src\libraries\System.Private.CoreLib\src\System\IO\PersistedFiles.Unix.cs (1)

102path = Marshal.PtrToStringUTF8((IntPtr)passwd.HomeDirectory);

Common\System\Data\Common\SafeNativeMethods.cs (3)

12var handle = Marshal.AllocHGlobal(initialSize); 19Marshal.FreeHGlobal(ptr); 25Marshal.Copy(zeroes, 0, ptr, length);

Common\System\Data\ProviderBase\DbBuffer.cs (22)

71value = Marshal.PtrToStringUni(ptr); 99value = Marshal.PtrToStringUni(ptr, length); 125value = Marshal.ReadByte(ptr, offset); 158Marshal.Copy(ptr, destination, startIndex, length); 191Marshal.Copy(ptr, destination, startIndex, length); 223value = Marshal.ReadInt16(ptr, offset); 250Marshal.Copy(ptr, destination, startIndex, length); 275value = Marshal.ReadInt32(ptr, offset); 302Marshal.Copy(ptr, destination, startIndex, length); 327value = Marshal.ReadInt64(ptr, offset); 353value = Marshal.ReadIntPtr(ptr, offset); 387ValidateCheck(offset, Marshal.SizeOf(structure.GetType())); 397Marshal.StructureToPtr(structure, ptr, false/*fDeleteOld*/); 421Marshal.WriteByte(ptr, offset, value); 447Marshal.Copy(source, startIndex, ptr, length); 473Marshal.Copy(source, startIndex, ptr, length); 502Marshal.WriteInt16(ptr, offset, value); 528Marshal.Copy(source, startIndex, ptr, length); 552Marshal.WriteInt32(ptr, offset, value); 578Marshal.Copy(source, startIndex, ptr, length); 602Marshal.WriteInt64(ptr, offset, value); 626Marshal.WriteIntPtr(ptr, offset, value);

System\Data\Odbc\OdbcStatementHandle.cs (2)

292IntPtr pwszTableName = Marshal.StringToCoTaskMemUni(tableName); 307Marshal.FreeCoTaskMem(pwszTableName);

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\Interop\Unix\System.Native\Interop.ForkAndExecProcess.cs (1)

34return result == 0 ? 0 : Marshal.GetLastPInvokeError();

src\libraries\Common\src\Interop\Unix\System.Native\Interop.GetHostName.cs (1)

41return Marshal.PtrToStringUTF8((IntPtr)name)!;

src\libraries\Common\src\Interop\Unix\System.Native\Interop.GetPwUid.cs (1)

70username = Marshal.PtrToStringUTF8((IntPtr)passwd.Name);

src\libraries\Common\src\Interop\Unix\System.Native\Interop.GetSetPriority.cs (1)

35return Marshal.GetLastPInvokeError();

src\libraries\Common\src\Interop\Unix\System.Native\Interop.MountPoints.FormatInfo.cs (1)

63Marshal.PtrToStringUTF8((IntPtr)formatBuffer)!;

src\libraries\Common\src\Interop\Unix\System.Native\Interop.ReadLink.cs (2)

51error = Marshal.GetLastPInvokeError(); 69Marshal.SetLastPInvokeError(error);

System\Diagnostics\ProcessWaitState.Unix.cs (2)

585int errorCode = Marshal.GetLastWin32Error(); 631int errorCode = Marshal.GetLastWin32Error();

mono\System.Drawing\BitmapTests.cs (25)

System\Drawing\BitmapTests.cs (22)

System\Drawing\GdiPlusHandlesTests.cs (1)

52int error = Marshal.GetLastWin32Error();

System\Drawing\Text\PrivateFontCollectionTests.cs (6)

140IntPtr fontBuffer = Marshal.AllocCoTaskMem(data.Length); 143Marshal.Copy(data, 0, fontBuffer, data.Length); 151Marshal.FreeCoTaskMem(fontBuffer); 176IntPtr fontBuffer = Marshal.AllocCoTaskMem(data.Length); 179Marshal.Copy(data, 0, fontBuffer, data.Length); 184Marshal.FreeCoTaskMem(fontBuffer);

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\Interop\Unix\System.Native\Interop.GetPwUid.cs (1)

70username = Marshal.PtrToStringUTF8((IntPtr)passwd.Name);

src\libraries\Common\src\System\IO\Compression\ZLibNative.cs (1)

320public string GetErrorMessage() => _zStream.msg != ZNullPtr ? Marshal.PtrToStringUTF8(_zStream.msg)! : string.Empty;

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\Interop\Unix\System.Native\Interop.MountPoints.cs (1)

29callbackContext->_results.Add(Marshal.PtrToStringUTF8((IntPtr)name)!);

src\libraries\Common\src\Interop\Unix\System.Native\Interop.MountPoints.FormatInfo.cs (1)

63Marshal.PtrToStringUTF8((IntPtr)formatBuffer)!;

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\Interop\Unix\System.Native\Interop.GetHostName.cs (1)

41return Marshal.PtrToStringUTF8((IntPtr)name)!;

src\libraries\Common\src\Interop\Unix\System.Native\Interop.GetPwUid.cs (1)

70username = Marshal.PtrToStringUTF8((IntPtr)passwd.Name);

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

System\IO\Ports\InternalResources.cs (1)

5using Marshal = System.Runtime.InteropServices.Marshal;

System\Net\HttpListenerException.cs (1)

14public HttpListenerException() : base(Marshal.GetLastPInvokeError())

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\Interop\Unix\System.Native\Interop.GetHostName.cs (1)

41return Marshal.PtrToStringUTF8((IntPtr)name)!;

src\libraries\Common\src\System\Net\SocketAddressPal.Unix.cs (1)

152uint addr = (uint)System.Runtime.InteropServices.Marshal.ReadInt32((IntPtr)address);

System\Net\NameResolutionPal.Unix.cs (3)

60? Marshal.PtrToStringUTF8((IntPtr)hostEntry.CanonicalName) 116localAliases[i] = Marshal.PtrToStringUTF8((IntPtr)hostEntry.Aliases[i])!; 189return socketError == SocketError.Success ? Marshal.PtrToStringUTF8((IntPtr)buffer) : null;

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\Interop\Unix\System.Native\Interop.GetDomainName.cs (1)

34string domainName = Marshal.PtrToStringUTF8((IntPtr)name)!;

src\libraries\Common\src\Interop\Unix\System.Native\Interop.GetHostName.cs (1)

41return Marshal.PtrToStringUTF8((IntPtr)name)!;

src\libraries\Common\src\System\Net\NetworkInformation\NetworkInformationException.cs (1)

25public NetworkInformationException() : base(Marshal.GetLastPInvokeError())

System\Net\NetworkInformation\LinuxNetworkInterface.cs (2)

97var lni = new LinuxNetworkInterface(Marshal.PtrToStringUTF8((IntPtr)nii->Name)!, nii->InterfaceIndex, systemProperties); 135Marshal.FreeHGlobal(globalMemory);

System\Net\NetworkInformation\NetworkAddressChange.Unix.cs (1)

166Marshal.InitHandle(sh, newSocket);

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\System\Net\SocketAddressPal.Unix.cs (1)

152uint addr = (uint)System.Runtime.InteropServices.Marshal.ReadInt32((IntPtr)address);

System\Net\NetworkInformation\Ping.RawSocket.cs (2)

397Debug.Assert(Marshal.SizeOf<IcmpHeader>() == 8, "The size of an ICMP Header must be 8 bytes."); 470Marshal.Copy(new IntPtr(&icmpHeader), result, offset, icmpHeaderSize);

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\Interop\Unix\System.Native\Interop.GetDomainName.cs (1)

34string domainName = Marshal.PtrToStringUTF8((IntPtr)name)!;

src\libraries\Common\src\Interop\Unix\System.Native\Interop.GetHostName.cs (1)

41return Marshal.PtrToStringUTF8((IntPtr)name)!;

src\libraries\Common\src\System\Net\SocketAddressPal.Unix.cs (1)

152uint addr = (uint)System.Runtime.InteropServices.Marshal.ReadInt32((IntPtr)address);

System\Net\NetworkCredential.cs (3)

165ptr = Marshal.SecureStringToGlobalAllocUnicode(sstr); 166result = Marshal.PtrToStringUni(ptr)!; 172Marshal.ZeroFreeGlobalAllocUnicode(ptr);

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.ASN1.cs (2)

70return Marshal.PtrToStringUTF8((IntPtr)bufStack, bytesNeeded); 96return Marshal.PtrToStringUTF8((IntPtr)buf, bytesNeeded);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.Crypto.cs (2)

74return Marshal.PtrToStringUTF8(ptr); 80return Marshal.PtrToStringUTF8(GetX509RootStoreFile_private(&unused));

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.ERR.cs (1)

40ret = Marshal.PtrToStringUTF8((IntPtr)buf)!;

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.X509.cs (1)

255return Marshal.PtrToStringUTF8(CryptoNative_X509VerifyCertErrorString(n))!;

src\libraries\Common\src\System\Net\SocketAddressPal.Unix.cs (1)

152uint addr = (uint)System.Runtime.InteropServices.Marshal.ReadInt32((IntPtr)address);

System\Net\Quic\Internal\MsQuicApi.cs (1)

173string? gitHash = Marshal.PtrToStringUTF8((IntPtr)libGitHash);

System\Net\Quic\Interop\msquic_generated.cs (1)

3136internal static readonly uint QUIC_EXECUTION_CONFIG_MIN_SIZE = unchecked((uint)((int)(Marshal.OffsetOf<QUIC_EXECUTION_CONFIG>("ProcessorList"))));

System\Net\Quic\QuicConnection.cs (2)

428IntPtr targetHostPtr = Marshal.StringToCoTaskMemUTF8(sni); 444Marshal.FreeCoTaskMem(targetHostPtr);

System\Net\Quic\QuicListener.cs (1)

344SslClientHelloInfo clientHello = new SslClientHelloInfo(data.Info->ServerNameLength > 0 ? Marshal.PtrToStringUTF8((IntPtr)data.Info->ServerName, data.Info->ServerNameLength) : "", SslProtocols.Tls13);

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\Interop\Unix\System.Net.Security.Native\Interop.GssApiException.cs (1)

88return (Status.GSS_S_COMPLETE != displayCallStatus) ? null : Marshal.PtrToStringUTF8(displayBuffer._data);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.ASN1.cs (2)

70return Marshal.PtrToStringUTF8((IntPtr)bufStack, bytesNeeded); 96return Marshal.PtrToStringUTF8((IntPtr)buf, bytesNeeded);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.Crypto.cs (2)

74return Marshal.PtrToStringUTF8(ptr); 80return Marshal.PtrToStringUTF8(GetX509RootStoreFile_private(&unused));

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.ERR.cs (1)

40ret = Marshal.PtrToStringUTF8((IntPtr)buf)!;

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.OpenSsl.cs (1)

937string msg = SR.Format(message, Marshal.PtrToStringUTF8(Crypto.ErrReasonErrorString(errorVal)));

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.Ssl.cs (1)

309string? ret = Marshal.PtrToStringUTF8(GetOpenSslCipherSuiteName(ssl, (int)cipherSuite, out int isTls12OrLowerInt));

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.SslCtx.cs (2)

177string? targetName = Marshal.PtrToStringUTF8(namePtr); 222string? targetName = Marshal.PtrToStringUTF8(namePtr);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.X509.cs (1)

255return Marshal.PtrToStringUTF8(CryptoNative_X509VerifyCertErrorString(n))!;

System\Net\Security\Pal.Managed\SafeChannelBindingHandle.cs (4)

27Marshal.Copy(certHashBytes, 0, CertHashPtr, length); 39handle = Marshal.AllocHGlobal(SecChannelBindingSize + _cbtPrefixByteArraySize + CertHashMaxSize); 56Marshal.StructureToPtr(channelBindings, handle, true); 63Marshal.FreeHGlobal(handle);

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\System\Net\SocketAddressPal.Unix.cs (1)

152uint addr = (uint)System.Runtime.InteropServices.Marshal.ReadInt32((IntPtr)address);

src\libraries\Common\src\System\Net\Sockets\SocketExceptionFactory.cs (1)

12return Marshal.GetPInvokeErrorMessage(nativeSocketError) + " " + endPoint.ToString();

System\Net\Sockets\SocketPal.Unix.cs (2)

94Marshal.InitHandle(socket, fd); 1151Marshal.InitHandle(socket, acceptedFd);

src\libraries\Common\src\System\IO\Compression\ZLibNative.cs (1)

320public string GetErrorMessage() => _zStream.msg != ZNullPtr ? Marshal.PtrToStringUTF8(_zStream.msg)! : string.Empty;

System\Net\WebSockets\WebSocketException.cs (1)

18: this(Marshal.GetLastPInvokeError())

src\Internal\Runtime\InteropServices\ComponentActivator.CoreCLR.cs (2)

19if (Marshal.PtrToStringUni(methodNameNative) == "LoadInMemoryAssemblyInContext" 20&& Marshal.PtrToStringUni(typeNameNative) == $"Internal.Runtime.InteropServices.{nameof(InMemoryAssemblyLoader)}, {CoreLib.Name}")

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\Interop\Unix\System.Native\Interop.GetCwd.cs (1)

57return Marshal.PtrToStringUTF8((IntPtr)ptr);

src\libraries\Common\src\Interop\Unix\System.Native\Interop.GetHostName.cs (1)

41return Marshal.PtrToStringUTF8((IntPtr)name)!;

src\libraries\Common\src\Interop\Unix\System.Native\Interop.GetPwUid.cs (1)

70username = Marshal.PtrToStringUTF8((IntPtr)passwd.Name);

src\libraries\Common\src\Interop\Unix\System.Native\Interop.MountPoints.cs (1)

29callbackContext->_results.Add(Marshal.PtrToStringUTF8((IntPtr)name)!);

src\libraries\Common\src\Interop\Unix\System.Native\Interop.ReadLink.cs (2)

51error = Marshal.GetLastPInvokeError(); 69Marshal.SetLastPInvokeError(error);

src\libraries\Common\src\Interop\Windows\Kernel32\Interop.FormatMessage.cs (2)

56if (Marshal.GetLastWin32Error() == ERROR_INSUFFICIENT_BUFFER) 69Marshal.FreeHGlobal(nativeMsgPtr);

src\libraries\Common\src\System\IO\Win32Marshal.cs (1)

19=> GetExceptionForWin32Error(Marshal.GetLastPInvokeError(), path);

src\libraries\System.Private.CoreLib\src\Internal\Runtime\InteropServices\ComponentActivator.cs (2)

41string? result = Marshal.PtrToStringAuto(arg); 353functionPtr = Marshal.GetFunctionPointerForDelegate(d);

src\libraries\System.Private.CoreLib\src\System\ComAwareWeakReference.cs (2)

57Marshal.Release(pComWeakRef); 71Marshal.Release(_pComWeakRef);

src\libraries\System.Private.CoreLib\src\System\ComponentModel\Win32Exception.cs (4)

26public Win32Exception() : this(Marshal.GetLastPInvokeError()) 33public Win32Exception(int error) : this(error, Marshal.GetPInvokeErrorMessage(error)) 48public Win32Exception(string? message) : this(Marshal.GetLastPInvokeError(), message) 58NativeErrorCode = Marshal.GetLastPInvokeError();

src\libraries\System.Private.CoreLib\src\System\DefaultBinder.cs (2)

233if (Marshal.IsBuiltInComSupported && argTypes[index].IsCOMObject) 269if (Marshal.IsBuiltInComSupported && argTypes[j].IsCOMObject)

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipe.cs (6)

96native.m_pProviderName = (char*)Marshal.StringToCoTaskMemUni(managed.ProviderName); 99native.m_pFilterData = (char*)Marshal.StringToCoTaskMemUni(managed.FilterData); 106Marshal.FreeCoTaskMem((IntPtr)m_pProviderName); 110Marshal.FreeCoTaskMem((IntPtr)m_pFilterData); 121Span<EventPipeProviderConfigurationNative> providersNative = new Span<EventPipeProviderConfigurationNative>((void*)Marshal.AllocCoTaskMem(sizeof(EventPipeProviderConfigurationNative) * providers.Length), providers.Length); 146Marshal.FreeCoTaskMem((IntPtr)providersNativePointer);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventProvider.cs (1)

1358Marshal.Copy((IntPtr)(void*)filterData->Ptr, data, 0, data.Length);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (1)

1929Marshal.Copy(data->DataPointer, blob, 0, blob.Length);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\DataCollector.cs (2)

137Marshal.Copy((IntPtr)p, buffer, oldPos, size); 176Marshal.Copy((IntPtr)p, buffer, oldPos, size);

src\libraries\System.Private.CoreLib\src\System\Environment.Variables.Windows.cs (4)

23if (length == 0 && Marshal.GetLastPInvokeError() == Interop.Errors.ERROR_ENVVAR_NOT_FOUND) 47int errorCode = Marshal.GetLastPInvokeError(); 61throw new OutOfMemoryException(Marshal.GetPInvokeErrorMessage(errorCode)); 64throw new ArgumentException(Marshal.GetPInvokeErrorMessage(errorCode));

src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.Nls.cs (3)

71Debug.Assert(ret >= 0 || Marshal.GetLastPInvokeError() == Interop.Errors.ERROR_SUCCESS); 303Debug.Assert(result >= 0 || Marshal.GetLastPInvokeError() == Interop.Errors.ERROR_SUCCESS); 509if (Marshal.GetLastPInvokeError() == Interop.Errors.ERROR_INSUFFICIENT_BUFFER)

src\libraries\System.Private.CoreLib\src\System\Globalization\IdnMapping.Nls.cs (1)

120int lastError = Marshal.GetLastPInvokeError();

src\libraries\System.Private.CoreLib\src\System\Globalization\Normalization.Nls.cs (4)

67int lastError = Marshal.GetLastPInvokeError(); 139int lastError = Marshal.GetLastPInvokeError(); 182int lastError = Marshal.GetLastPInvokeError(); 205int lastError = Marshal.GetLastPInvokeError();

src\libraries\System.Private.CoreLib\src\System\IO\PersistedFiles.Unix.cs (1)

102path = Marshal.PtrToStringUTF8((IntPtr)passwd.HomeDirectory);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\ArrayWithOffset.cs (1)

23if (array is not Array arrayObj || (arrayObj.Rank != 1) || !Marshal.IsPinnable(arrayObj))

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\CriticalHandle.cs (2)

149int lastError = Marshal.GetLastPInvokeError(); 153Marshal.SetLastPInvokeError(lastError);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\DispatchWrapper.cs (2)

19IntPtr pdisp = Marshal.GetIDispatchForObject(obj); 22Marshal.Release(pdisp);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\ErrorWrapper.cs (1)

26ErrorCode = Marshal.GetHRForException(e);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\GCHandle.cs (2)

42if (type == GCHandleType.Pinned && !Marshal.IsPinnable(value)) 98if (IsPinned(handle) && !Marshal.IsPinnable(value))

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\AnsiStringMarshaller.cs (8)

26int exactByteCount = Marshal.GetAnsiStringByteCount(managed); // Includes null terminator 27byte* mem = (byte*)Marshal.AllocCoTaskMem(exactByteCount); 30Marshal.GetAnsiStringBytes(managed, buffer); // Includes null terminator 40=> Marshal.PtrToStringAnsi((IntPtr)unmanaged); 47=> Marshal.FreeCoTaskMem((IntPtr)unmanaged); 79if ((long)Marshal.SystemMaxDBCSCharSize * managed.Length >= buffer.Length) 82int exactByteCount = Marshal.GetAnsiStringByteCount(managed); // Includes null terminator 93Marshal.GetAnsiStringBytes(managed, buffer); // Includes null terminator

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\ArrayMarshaller.cs (2)

43return (TUnmanagedElement*)Marshal.AllocCoTaskMem(spaceToAllocate); 99=> Marshal.FreeCoTaskMem((IntPtr)unmanaged);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\BStrStringMarshaller.cs (5)

24=> (ushort*)Marshal.StringToBSTR(managed); 36return Marshal.PtrToStringBSTR((IntPtr)unmanaged); 44=> Marshal.FreeBSTR((IntPtr)unmanaged); 83ptrToFirstChar = (ushort*)Marshal.AllocBSTRByteLen((uint)lengthInBytes); 96Debug.Assert(lengthInBytes == Marshal.SysStringByteLen((IntPtr)ptrToFirstChar));

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\ComVariant.cs (19)

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\PointerArrayMarshaller.cs (2)

44return (TUnmanagedElement*)Marshal.AllocCoTaskMem(spaceToAllocate); 100=> Marshal.FreeCoTaskMem((IntPtr)unmanaged);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\ReadOnlySpanMarshaller.cs (2)

54return (TUnmanagedElement*)Marshal.AllocCoTaskMem(spaceToAllocate); 223Marshal.FreeCoTaskMem((IntPtr)_unmanagedArray);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\SafeHandleMarshaller.cs (2)

108Marshal.InitHandle(_newHandle, value); 175Marshal.InitHandle(_newHandle, value);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\SpanMarshaller.cs (2)

48return (TUnmanagedElement*)Marshal.AllocCoTaskMem(spaceToAllocate); 104=> Marshal.FreeCoTaskMem((IntPtr)unmanaged);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\Utf16StringMarshaller.cs (3)

21=> (ushort*)Marshal.StringToCoTaskMemUni(managed); 29=> Marshal.PtrToStringUni((IntPtr)unmanaged); 36=> Marshal.FreeCoTaskMem((IntPtr)unmanaged);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\Utf8StringMarshaller.cs (3)

28byte* mem = (byte*)Marshal.AllocCoTaskMem(exactByteCount); 42=> Marshal.PtrToStringUTF8((IntPtr)unmanaged); 49=> Marshal.FreeCoTaskMem((IntPtr)unmanaged);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\NativeLibrary.cs (1)

263throw new Win32Exception(Marshal.GetLastPInvokeError());

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\SafeHandle.cs (4)

77int lastError = Marshal.GetLastPInvokeError(); 79Marshal.SetLastPInvokeError(lastError); 266int lastError = Marshal.GetLastPInvokeError(); 268Marshal.SetLastPInvokeError(lastError);

src\libraries\System.Private.CoreLib\src\System\Runtime\Loader\AssemblyDependencyResolver.cs (5)

48var errorWriter = new Interop.HostPolicy.corehost_error_writer_fn(message => errorMessage.AppendLine(Marshal.PtrToStringAuto(message))); 50IntPtr errorWriterPtr = Marshal.GetFunctionPointerForDelegate(errorWriter); 61assemblyPathsList = Marshal.PtrToStringAuto(assemblyPaths); 62nativeSearchPathsList = Marshal.PtrToStringAuto(nativeSearchPaths); 63resourceSearchPathsList = Marshal.PtrToStringAuto(resourceSearchPaths);

src\libraries\System.Private.CoreLib\src\System\Security\SecureString.cs (10)

322ptr = Marshal.AllocBSTR(length); 335Marshal.FreeBSTR(ptr); 365byteLength = Marshal.GetAnsiStringByteCount(span); 370ptr = Marshal.AllocHGlobal(byteLength); 374ptr = Marshal.AllocCoTaskMem(byteLength); 385Marshal.GetAnsiStringBytes(span, new Span<byte>((void*)ptr, byteLength)); 401Marshal.FreeHGlobal(ptr); 405Marshal.FreeCoTaskMem(ptr); 429buffer.SetHandle(Marshal.AllocHGlobal(byteLength)); 465Marshal.FreeHGlobal(handle);

src\libraries\System.Private.CoreLib\src\System\Threading\EventWaitHandle.Windows.cs (2)

35int errorCode = Marshal.GetLastPInvokeError(); 84errorCode = Marshal.GetLastPInvokeError();

src\libraries\System.Private.CoreLib\src\System\Threading\Semaphore.Windows.cs (2)

39int errorCode = Marshal.GetLastPInvokeError(); 92errorCode = Marshal.GetLastPInvokeError();

src\libraries\System.Private.CoreLib\src\System\ThrowHelper.cs (1)

651Exception? ex = Marshal.GetExceptionForHR(hr);

src\libraries\System.Private.CoreLib\src\System\Type.cs (2)

565public static Type? GetTypeFromCLSID(Guid clsid, string? server, bool throwOnError) => Marshal.GetTypeFromCLSID(clsid, server, throwOnError); 574public static Type? GetTypeFromProgID(string progID, string? server, bool throwOnError) => Marshal.GetTypeFromProgID(progID, server, throwOnError);

src\System\GC.CoreCLR.cs (2)

883string nameAsString = Marshal.PtrToStringUTF8((IntPtr)name)!; 892string? dataAsString = Marshal.PtrToStringUTF8((nint)data);

src\System\Reflection\RuntimeAssembly.cs (1)

734Marshal.ThrowExceptionForHR(tokenMaybe, new IntPtr(-1));

src\System\Runtime\InteropServices\ComWrappers.cs (1)

37/// This can be done through an API like <see cref="Marshal.Release(IntPtr)"/>.

src\System\RuntimeHandles.cs (3)

2122Marshal.ThrowExceptionForHR(offsetMaybe, new IntPtr(-1)); 2140Marshal.ThrowExceptionForHR(offsetMaybe, new IntPtr(-1)); 2158Marshal.ThrowExceptionForHR(callConvMaybe, new IntPtr(-1));

src\System\StubHelpers.cs (32)

23byte[] buffer = new byte[checked((str.Length + 1) * Marshal.SystemMaxDBCSCharSize)]; 26cbLength = Marshal.StringToAnsiString(str, bufferPtr, buffer.Length, fBestFit, fThrowOnUnmappableChar); 33int cbAllocLength = (1 + 1) * Marshal.SystemMaxDBCSCharSize; 37int cbLength = Marshal.StringToAnsiString(managedChar.ToString(), bufferPtr, cbAllocLength, fBestFit, fThrowOnUnmappableChar); 63if (pbNativeBuffer != null || Marshal.SystemMaxDBCSCharSize == 1) 69nb = checked((strManaged.Length + 1) * Marshal.SystemMaxDBCSCharSize + 1); 77pbNativeBuffer = (byte*)Marshal.AllocCoTaskMem(nb); 83nb = Marshal.StringToAnsiString(strManaged, pbNativeBuffer, nb, 88Marshal.FreeCoTaskMem((IntPtr)pbNativeBuffer); 97pbNativeBuffer = (byte*)Marshal.AllocCoTaskMem(2); 110pbNativeBuffer = (byte*)Marshal.AllocCoTaskMem(nb + 2); 270ptrToFirstChar = (byte*)Marshal.AllocBSTRByteLen(lengthInBytes); 295uint length = Marshal.SysStringByteLen(bstr); 333Marshal.FreeBSTR(pNative); 351int nbytes = checked(sizeof(uint) + ((cch + 1) * Marshal.SystemMaxDBCSCharSize)); 353pNative = (byte*)Marshal.AllocCoTaskMem(nbytes); 392Marshal.FreeCoTaskMem(pNative - sizeof(uint)); 415IntPtr bstr = Marshal.AllocBSTRByteLen(length); 441Marshal.FreeBSTR(pNative); 653Marshal.FreeCoTaskMem(nativeHome); 1002pNativeHome = Marshal.AllocCoTaskMem(allocSize); 1045int allocSize = checked((pManagedHomeCapacity * Marshal.SystemMaxDBCSCharSize) + 4); 1046pNativeHome = Marshal.AllocCoTaskMem(allocSize); 1055int length = Marshal.StringToAnsiString(pManagedHome.ToString(), 1070pNativeHome = Marshal.AllocCoTaskMem(allocSize); 1100int allocSize = Marshal.SizeOfHelper((RuntimeType)pManagedHome.GetType(), false); 1101IntPtr pNativeHome = Marshal.AllocCoTaskMem(allocSize); 1223Marshal.DestroyStructure(pNativeHome, layoutType); 1225Marshal.FreeCoTaskMem(pNativeHome); 1517bool success = Marshal.TryGetStructMarshalStub((IntPtr)pMT, &structMarshalStub, &size); 1536bool success = Marshal.TryGetStructMarshalStub((IntPtr)pMT, &structMarshalStub, &size); 1555bool success = Marshal.TryGetStructMarshalStub((IntPtr)pMT, &structMarshalStub, &size);

src\System\Threading\Mutex.CoreCLR.Unix.cs (3)

28int errorCode = Marshal.GetLastPInvokeError(); 140errorCode = Marshal.GetLastPInvokeError(); 150errorCode = mutexHandle.IsInvalid ? Marshal.GetLastPInvokeError() : Interop.Errors.ERROR_SUCCESS;

System\Private\Windows\Ole\Composition.NativeToManagedAdapter.cs (1)

151Marshal.Copy((nint)buffer, bytes, 0, size);

System\Private\Windows\Ole\DragDropFormat.cs (1)

86Marshal.AddRef(mediumSource.hGlobal);

System\Private\Windows\Ole\DragDropHelper.cs (4)

208throw new Win32Exception(Marshal.GetLastSystemError(), SR.ExternalException); 215throw new Win32Exception(Marshal.GetLastSystemError(), SR.ExternalException); 366throw new Win32Exception(Marshal.GetLastSystemError(), SR.ExternalException); 373throw new Win32Exception(Marshal.GetLastSystemError(), SR.ExternalException);

Windows\Win32\Foundation\BSTR.cs (2)

13public BSTR(string? value) : this((char*)Marshal.StringToBSTR(value)) 21Marshal.FreeBSTR((nint)Value);

Windows\Win32\Foundation\PWSTR.cs (1)

18Marshal.FreeCoTaskMem((IntPtr)Value);

Windows\Win32\PInvokeCore.GetWindowText.cs (1)

30int error = Marshal.GetLastWin32Error();

Windows\Win32\PInvokeCore.SetWindowLong.cs (1)

38IntPtr pointer = Marshal.GetFunctionPointerForDelegate(dwNewLong);

Windows\Win32\System\Com\ComHelpers.cs (4)

105ccw = (IUnknown*)Marshal.GetIUnknownForObject(@object); 257using ComScope<IUnknown> ccw = new((IUnknown*)(void*)Marshal.GetIUnknownForObject(@object)); 286/// <see cref="ComWrappers"/> capable wrapper for <see cref="Marshal.GetObjectForIUnknown(nint)"/>. 304return Marshal.GetObjectForIUnknown((nint)unknown);

Windows\Win32\System\Com\ComManagedStream.cs (1)

214pstatstg->pwcsName = (char*)Marshal.StringToCoTaskMemUni(_dataStream is FileStream fs ? fs.Name : _dataStream.ToString());

Windows\Win32\System\Com\Lifetime.cs (2)

34Marshal.FreeCoTaskMem((nint)lifetime); 56var wrapper = (Lifetime<TVTable, TObject>*)Marshal.AllocCoTaskMem(sizeof(Lifetime<TVTable, TObject>));

Windows\Win32\System\Variant\VARIANT.cs (8)

159return Marshal.PtrToStringUni(*(IntPtr*)data); 161return Marshal.PtrToStringAnsi(*(IntPtr*)data); 380result[i] = Marshal.PtrToStringUni(data[i]); 589SetValue(array, Marshal.PtrToStringUni(data), indices, lowerBounds); 830result[i] = Marshal.PtrToStringUni(data[i]); 842result[i] = Marshal.PtrToStringAnsi(data[i]); 868=> MemoryMarshal.CreateSpan(ref Unsafe.AsRef<T>(Marshal.UnsafeAddrOfPinnedArrayElement(array, 0).ToPointer()), array.Length); 1014Marshal.GetNativeVariantForObject(value, (nint)(void*)&variant);

Windows\Win32\System\Variant\VARIANTVector.cs (1)

25Marshal.GetNativeVariantForObject(values[i], (IntPtr)(&pVariants[i]));

System\Drawing\IIconExtensions.cs (1)

37return Marshal.GetObjectForIUnknown(picture);

Windows\Win32\System\Ole\IPicture.cs (2)

16return Marshal.GetObjectForIUnknown(picture); 31return Marshal.GetObjectForIUnknown(picture);

System\Reflection\Internal\MemoryBlocks\NativeHeapMemoryBlock.cs (2)

32_pointer = Marshal.AllocHGlobal(size); 49Marshal.FreeHGlobal(ptr);

System\Reflection\Internal\Utilities\EncodingHelper.netcoreapp.cs (1)

48Marshal.Copy((IntPtr)bytes, buffer, prefix.Length, byteCount);

System\Reflection\Metadata\BlobReader.cs (1)

437Marshal.Copy((IntPtr)GetCurrentPointerAndAdvance(byteCount), buffer, bufferOffset, byteCount);

System\Reflection\Metadata\Internal\StringHeap.cs (1)

188Marshal.Copy((IntPtr)block.Pointer, bytes, prefix.Length, block.Length);

artifacts\obj\System.Runtime.InteropServices\Debug\net10.0\System.Runtime.InteropServices.Forwards.cs (1)

105[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.InteropServices.Marshal))]

System\Runtime\InteropServices\ComAwareEventInfo.cs (2)

32if (Marshal.IsComObject(target)) 50if (Marshal.IsComObject(target))

System\Runtime\InteropServices\Marshalling\ComImportInteropInterfaceDetailsStrategy.cs (1)

194/// <remarks>The returned object must be an object such that a call to <see cref="Marshal.IsComObject(object)"/> would return true.</remarks>

System\Runtime\InteropServices\Marshalling\ComInterfaceMarshaller.cs (4)

68Marshal.Release((nint)unmanaged); 79if (Marshal.QueryInterface(unknown, in Nullable.GetValueRefOrDefaultRef(in TargetInterfaceIID), out nint interfacePointer) != 0) 81Marshal.Release(unknown); 84Marshal.Release(unknown);

System\Runtime\InteropServices\Marshalling\ComObject.cs (5)

46_runtimeCallableWrapper = Marshal.GetObjectForIUnknown((nint)thisPointer); 47Debug.Assert(Marshal.IsComObject(_runtimeCallableWrapper)); 99Marshal.ThrowExceptionForHR(qiResult); 111Marshal.ThrowExceptionForHR(qiResult); 157Marshal.ThrowExceptionForHR(qiHResult);

System\Runtime\InteropServices\Marshalling\ComVariantMarshaller.cs (5)

195return Marshal.PtrToStringBSTR(*(IntPtr*)unmanaged.GetRawDataRef<nint>()); 306Marshal.FreeBSTR(bstrStorage); 307bstrStorage = Marshal.StringToBSTR(str); 313Marshal.FreeBSTR(bstrStorage); 314bstrStorage = Marshal.StringToBSTR(str.WrappedObject);

System\Runtime\InteropServices\Marshalling\ExceptionAsDefaultMarshaller.cs (1)

23_ = Marshal.GetHRForException(e);

System\Runtime\InteropServices\Marshalling\ExceptionAsHResultMarshaller.cs (1)

38return T.CreateTruncating(Marshal.GetHRForException(e));

System\Runtime\InteropServices\Marshalling\ExceptionAsNaNMarshaller.cs (1)

25_ = Marshal.GetHRForException(e);

System\Runtime\InteropServices\Marshalling\ExceptionAsVoidMarshaller.cs (1)

25_ = Marshal.GetHRForException(e);

System\Runtime\InteropServices\Marshalling\FreeThreadedStrategy.cs (3)

15Marshal.AddRef((nint)unknown); 21int hr = Marshal.QueryInterface((nint)thisPtr, handle, out nint ppv); 34=> Marshal.Release((nint)thisPtr);

System\Runtime\InteropServices\Marshalling\IIUnknownStrategy.cs (2)

35/// <seealso cref="Marshal.QueryInterface(nint, in Guid, out nint)"/> 43/// <seealso cref="Marshal.Release(nint)"/>

System\Runtime\InteropServices\Marshalling\UniqueComInterfaceMarshaller.cs (1)

70Marshal.Release((nint)unmanaged);

System\Security\SecureStringMarshal.cs (4)

10public static IntPtr SecureStringToCoTaskMemAnsi(SecureString s) => Marshal.SecureStringToCoTaskMemAnsi(s); 11public static IntPtr SecureStringToGlobalAllocAnsi(SecureString s) => Marshal.SecureStringToGlobalAllocAnsi(s); 12public static IntPtr SecureStringToCoTaskMemUnicode(SecureString s) => Marshal.SecureStringToCoTaskMemUnicode(s); 13public static IntPtr SecureStringToGlobalAllocUnicode(SecureString s) => Marshal.SecureStringToGlobalAllocUnicode(s);

Microsoft\Win32\SafeHandles\SafePasswordHandle.cs (4)

29handle = Marshal.StringToHGlobalUni(password); 47handle = Marshal.AllocHGlobal(spanLen * sizeof(char)); 68handle = Marshal.SecureStringToGlobalAllocUnicode(password); 77Marshal.ZeroFreeGlobalAllocUnicode(handle);

src\libraries\Common\src\Interop\Unix\Interop.Errors.cs (3)

158return ConvertErrorPlatformToPal(Marshal.GetLastPInvokeError()); 163return new ErrorInfo(Marshal.GetLastPInvokeError()); 182return Marshal.PtrToStringUTF8((IntPtr)message)!;

src\libraries\Common\src\Interop\Unix\System.Native\Interop.GetPwUid.cs (1)

70username = Marshal.PtrToStringUTF8((IntPtr)passwd.Name);

src\libraries\Common\src\Interop\Unix\System.Native\Interop.ReadLink.cs (2)

51error = Marshal.GetLastPInvokeError(); 69Marshal.SetLastPInvokeError(error);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.ASN1.cs (2)

70return Marshal.PtrToStringUTF8((IntPtr)bufStack, bytesNeeded); 96return Marshal.PtrToStringUTF8((IntPtr)buf, bytesNeeded);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.Crypto.cs (2)

74return Marshal.PtrToStringUTF8(ptr); 80return Marshal.PtrToStringUTF8(GetX509RootStoreFile_private(&unused));

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.ERR.cs (1)

40ret = Marshal.PtrToStringUTF8((IntPtr)buf)!;

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.X509.cs (1)

255return Marshal.PtrToStringUTF8(CryptoNative_X509VerifyCertErrorString(n))!;

src\libraries\System.Private.CoreLib\src\System\IO\PersistedFiles.Unix.cs (1)

102path = Marshal.PtrToStringUTF8((IntPtr)passwd.HomeDirectory);

System\Security\Cryptography\OidLookup.OpenSsl.cs (1)

29return Marshal.PtrToStringUTF8(friendlyNamePtr);

src\libraries\Common\src\Interop\Windows\Crypt32\Interop.DATA_BLOB.cs (1)

31Marshal.Copy(pbData, array, 0, (int)cbData);

src\libraries\Common\src\Interop\Windows\Kernel32\Interop.FormatMessage.cs (2)

56if (Marshal.GetLastWin32Error() == ERROR_INSUFFICIENT_BUFFER) 69Marshal.FreeHGlobal(nativeMsgPtr);

System\Security\Cryptography\ProtectedData.cs (2)

363int lastWin32Error = Marshal.GetLastPInvokeError(); 405Marshal.FreeHGlobal(outputBlob.pbData);

Microsoft\Win32\SafeHandles\SafeAllocHHandle.cs (1)

28Marshal.FreeHGlobal(handle);

System\Text\BaseCodePageEncoding.cs (1)

369byte* pNativeMemory = (byte*)Marshal.AllocHGlobal(iSize);

Microsoft\Windows\Controls\Ribbon\NativeMethods.cs (1)

285internal int cbSize = Marshal.SizeOf(typeof(MONITORINFOEX));

Microsoft\Windows\Controls\Ribbon\RibbonDropDownHelper.cs (1)

172cbSize = Marshal.SizeOf(typeof(NativeMethods.MONITORINFOEX))

System\Windows\Forms\Accessibility\AccessibleObject.cs (1)

1167*ppAccessible = (UIA.IAccessible*)Marshal.GetComInterfaceForObject<AccessibleObject, IAccessible>(this);

System\Windows\Forms\Accessibility\LabelEditNativeWindow.cs (1)

46(void*)Marshal.GetFunctionPointerForDelegate(_winEventProcCallback);

System\Windows\Forms\ActiveX\AxHost.cs (4)

2952Marshal.FreeCoTaskMem((IntPtr)uuids.pElems); 3052Marshal.FreeCoTaskMem((IntPtr)uuids.pElems); 3438Marshal.ReleaseComObject(_instance); 3762using ComScope<IDispatch> dispatch = new((IDispatch*)Marshal.GetIDispatchForObject(oleFont));

System\Windows\Forms\ActiveX\AxHost.OleInterfaces.cs (1)

131Marshal.GetNativeVariantForObject(ambient, (nint)result);

System\Windows\Forms\ActiveX\AxHost.State.cs (2)

146Marshal.Copy(_buffer, 0, (nint)pointer, _length); 284Marshal.Copy((nint)pointer, _buffer, 0, _length);

System\Windows\Forms\ActiveX\Control.ActiveXFontMarshaler.cs (1)

24public void CleanUpNativeData(IntPtr pObj) => Marshal.Release(pObj);

System\Windows\Forms\ActiveX\Control.ActiveXImpl.cs (2)

857throw new Win32Exception(Marshal.GetLastWin32Error(), SR.Win32SetParentFailed); 1320Marshal.ThrowExceptionForHR((int)hr);

System\Windows\Forms\ActiveX\Control_ActiveXControlInterfaces.cs (1)

259*pszUserType = (char*)Marshal.StringToCoTaskMemUni(

System\Windows\Forms\ComponentModel\COM2Interop\COM2ComponentEditor.cs (2)

41Marshal.FreeCoTaskMem((IntPtr)uuids.pElems); 121Marshal.FreeCoTaskMem((nint)uuids.pElems);

System\Windows\Forms\ComponentModel\COM2Interop\COM2IManagedPerPropertyBrowsingHandler.cs (2)

212Marshal.FreeCoTaskMem((nint)(void*)values); 240Marshal.FreeCoTaskMem((IntPtr)values);

System\Windows\Forms\ComponentModel\COM2Interop\COM2PropertyPageUITypeConverter.cs (1)

96Marshal.Release(addresses[i]);

System\Windows\Forms\Control.cs (10)

1298int lastWin32Error = Marshal.GetLastWin32Error(); 3491|| (!returnValue && Marshal.GetLastWin32Error() == (int)WIN32_ERROR.ERROR_INVALID_HANDLE) 6503Marshal.Copy(bytes, 0, m.LParamInternal, bytes.Length); 6504Marshal.Copy(nullBytes, 0, m.LParamInternal + (nint)bytes.Length, nullBytes.Length); 6995throw new Win32Exception(Marshal.GetLastWin32Error(), SR.Win32SetParentFailed); 9267throw new Win32Exception(Marshal.GetLastWin32Error(), SR.Win32SetParentFailed); 9471throw Marshal.GetExceptionForHR((int)hr)!; 9480throw Marshal.GetExceptionForHR((int)hr)!; 10204throw new Win32Exception(Marshal.GetLastWin32Error(), SR.Win32SetParentFailed); 10220throw new Win32Exception(Marshal.GetLastWin32Error(), SR.Win32SetParentFailed);

System\Windows\Forms\Controls\ListView\ListView.cs (6)

4150Marshal.FreeHGlobal(hGlobalColumns); 4153hGlobalColumns = Marshal.AllocHGlobal((int)(lvItem.cColumns * sizeof(int))); 4165Marshal.Copy(columns, 0, (nint)lvItem.puColumns, (int)lvItem.cColumns); 4228Marshal.FreeHGlobal(hGlobalColumns); 5536IntPtr callbackPointer = Marshal.GetFunctionPointerForDelegate(callback); 6828Marshal.Copy(charBuf, 0, destPtr, Math.Min(charBuf.Length, infoTip->cchTextMax));

System\Windows\Forms\Controls\MonthCalendar\MonthCalendar.CalendarButtonAccessibleObject.cs (1)

135PInvoke.SendInput(1, &mouseInput, Marshal.SizeOf(mouseInput));

System\Windows\Forms\Controls\PropertyGrid\PropertyGrid.cs (2)

4079if (obj is not null && !Marshal.IsComObject(obj)) 4313_propertyName = Marshal.PtrToStringAuto((nint)cds->lpData);

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\PropertyGridView.MouseHook.cs (1)

94IntPtr hook = Marshal.GetFunctionPointerForDelegate(_callBack);

System\Windows\Forms\Controls\RichTextBox\RichTextBox.cs (7)

261int lastWin32Error = Marshal.GetLastWin32Error(); 1638Marshal.Copy(buf, bytes, 0, cb); 1726Marshal.Copy(bytes, 0, buf, transferred); 2096Marshal.FreeCoTaskMem(txrg.lpstrText); 2910es.pfnCallback = Marshal.GetFunctionPointerForDelegate(callback); 3014es.pfnCallback = Marshal.GetFunctionPointerForDelegate(callback); 3211Marshal.FreeCoTaskMem(unmanagedBuffer);

System\Windows\Forms\Controls\ToolStrips\ToolStripDropTargetManager.cs (1)

179throw Marshal.GetExceptionForHR((int)hr)!;

System\Windows\Forms\Controls\ToolStrips\ToolStripManager.ModalMenuFilter.HostedWindowsFormsMessageHook.cs (1)

65IntPtr hook = Marshal.GetFunctionPointerForDelegate(_callBack);

System\Windows\Forms\Controls\ToolStrips\ToolStripMenuItem.cs (2)

628nint allocatedStringBuffer = Marshal.AllocCoTaskMem((int)info.cch * sizeof(char)); 647Marshal.FreeCoTaskMem(allocatedStringBuffer);

System\Windows\Forms\Controls\TreeView\TreeNode.cs (4)

1841tvis.item.pszText = (char*)Marshal.StringToHGlobalUni(_text); 1891Marshal.FreeCoTaskMem((nint)tvis.item.pszText.Value); 2145item.pszText = (char*)Marshal.StringToHGlobalUni(_text); 2183Marshal.FreeCoTaskMem((nint)item.pszText.Value);

System\Windows\Forms\Controls\WebBrowser\WebBrowser.cs (1)

479if (!Marshal.IsTypeVisibleFromCom(value.GetType()))

System\Windows\Forms\Controls\WebBrowser\WebBrowserBase.cs (1)

877Marshal.FinalReleaseComObject(_activeXInstance);

System\Windows\Forms\Controls\WebBrowser\WebBrowserSiteBase.cs (1)

267lpFrameInfo->cb = (uint)Marshal.SizeOf<OLEINPLACEFRAMEINFO>();

System\Windows\Forms\Design\EventsTab.cs (1)

28public override bool CanExtend(object? extendee) => extendee is null || !Marshal.IsComObject(extendee);

System\Windows\Forms\Dialogs\CommonDialogs\CommonDialog.cs (2)

33_functionPointer = (delegate* unmanaged[Stdcall]<HWND, uint, WPARAM, LPARAM, nuint>)(void*)Marshal.GetFunctionPointerForDelegate(_hookProc); 221nint hookedWndProc = Marshal.GetFunctionPointerForDelegate(ownerWindowProcedure);

System\Windows\Forms\Dialogs\CommonDialogs\FolderBrowserDialog.cs (1)

314throw Marshal.GetExceptionForHR((int)hr)!;

System\Windows\Forms\Dialogs\MessageBox.cs (1)

469int lastWin32Error = Marshal.GetLastWin32Error();

System\Windows\Forms\Dialogs\TaskDialog\TaskDialog.cs (4)

264private static void FreeConfig(IntPtr ptrToFree) => Marshal.FreeHGlobal(ptrToFree); 1170string? linkHref = Marshal.PtrToStringUni(lParam); 1431ptrToFree = Marshal.AllocHGlobal((nint)(sizeToAllocate + (IntPtr.Size - 1))); 1548Marshal.FreeHGlobal(ptrToFree);

System\Windows\Forms\Input\Cursor.cs (2)

41throw new Win32Exception(string.Format(SR.FailedToLoadCursor, Marshal.GetLastWin32Error())); 430throw new Win32Exception(string.Format(SR.FailedToLoadCursor, Marshal.GetLastWin32Error()));

System\Windows\Forms\NativeWindow.cs (1)

453lastWin32Error = Marshal.GetLastWin32Error();

System\Windows\Forms\NativeWindow.WindowClass.cs (2)

147throw new Win32Exception(Marshal.GetLastWin32Error(), SR.InvalidWndClsName); 157nint callback = Marshal.GetFunctionPointerForDelegate(_windProc);

System\Windows\Forms\StringSource.cs (1)

96rgelt[fetched] = (char*)Marshal.StringToCoTaskMemUni(_strings[_current]);

System\Windows\Forms\SystemInformation.cs (1)

805return Marshal.GetLastWin32Error() == (int)WIN32_ERROR.ERROR_ACCESS_DENIED;

System\Windows\Forms\WindowSubclassHandler.cs (1)

72_windowProcDelegatePtr = (void*)Marshal.GetFunctionPointerForDelegate(_windowProcDelegate);

System\Drawing\Design\ColorEditor.CustomColorDialog.cs (3)

28_hInstance = Marshal.AllocHGlobal(size); 29Marshal.Copy(buffer, 0, _hInstance, size); 49Marshal.FreeHGlobal(_hInstance);

System\Windows\Forms\Design\Behavior\BehaviorService.AdornerWindow.MouseHook.cs (1)

78IntPtr hook = Marshal.GetFunctionPointerForDelegate(_callBack);

System\Windows\Forms\Design\Behavior\BehaviorService.cs (2)

779Marshal.Copy(bytes, 0, m.LParamInternal, bytes.Length); 780Marshal.Copy(nullBytes, 0, m.LParamInternal + (nint)bytes.Length, nullBytes.Length);

PropertyGridTests.cs (2)

43Marshal.ReleaseComObject(target); 74Marshal.ReleaseComObject(target);

RichTextBoxTests.cs (2)

83Assert.Equal("Fine Text", Marshal.PtrToStringUni((IntPtr)value.lpstrText)); 159Assert.Equal("Fine Text", Marshal.PtrToStringAnsi(value.lpstrText));

Microsoft\Win32\SafeHandles\CoTaskMemSafeHandle.cs (1)

18Marshal.FreeCoTaskMem(handle);

System\Windows\Forms\Automation\UiaTextRange.cs (1)

708Runtime.InteropServices.Marshal.GetNativeVariantForObject(value, (nint)(void*)&variant);

System\Windows\Forms\Internals\ScaleHelper.DpiAwarenessScope.cs (4)

49throw new Win32Exception(Marshal.GetLastWin32Error(), SR.Win32GetThreadsDpiContextFailed); 64throw new Win32Exception(Marshal.GetLastWin32Error(), string.Format(SR.Win32SetThreadsDpiHostingBehaviorFailed, behavior)); 79throw new Win32Exception(Marshal.GetLastWin32Error(), string.Format(SR.Win32SetThreadsDpiHostingBehaviorFailed, _originalDpiHostingBehavior)); 85throw new Win32Exception(Marshal.GetLastWin32Error(), string.Format(SR.Win32SetThreadsDpiContextFailed, _originalDpiAwarenessContext));

System\Windows\Forms\Internals\UnicodeCharBuffer.cs (3)

20IntPtr result = Marshal.AllocCoTaskMem(_buffer.Length * 2); 21Marshal.Copy(_buffer, 0, result, _buffer.Length); 45Marshal.Copy(ptr, _buffer, 0, _buffer.Length);

System\Windows\Forms\Message.cs (1)

89Type cls) => Marshal.PtrToStructure(LParamInternal, cls);

Windows\Win32\PInvoke.CreateWindowEx.cs (5)

56int size = Marshal.SizeOf(lpParam); 57nint native = Marshal.AllocCoTaskMem(size); 61Marshal.StructureToPtr(lpParam, native, fDeleteOld: false); 68Marshal.DestroyStructure(native, lpParam.GetType()); 69Marshal.FreeCoTaskMem(native);

Windows\Win32\PInvoke.LoadLibrary.cs (1)

57if (Marshal.GetLastWin32Error() != (int)WIN32_ERROR.ERROR_INVALID_PARAMETER)

Windows\Win32\System\Ole\CADWORD.cs (1)

20Marshal.FreeCoTaskMem((nint)pElems);

Windows\Win32\UI\Accessibility\UIAHelper.cs (1)

20/// Although <see cref="global::System.Runtime.InteropServices.Marshal.GetNativeVariantForObject"/>

Windows\Win32\UI\Shell\FolderBrowserHelper.cs (2)

54Marshal.FreeCoTaskMem((nint)rootFolderId); 65Marshal.FreeCoTaskMem((nint)resultId);

Interop\ComCtl32\MCGRIDINFOTests.cs (26)

Interop\Kernel32\FILETIMETests.cs (1)

14Assert.Equal(8, Marshal.SizeOf<FILETIME>());

Interop\Kernel32\SYSTEMTIMETests.cs (1)

13Assert.Equal(16, Marshal.SizeOf<SYSTEMTIME>());

Interop\Mocks\MockCursor.cs (1)

22throw new Win32Exception(Marshal.GetLastWin32Error());

Interop\Ole32\CADWORDTests.cs (1)

38pElems = (uint*)Marshal.AllocCoTaskMem(sizeof(uint) * values.Length)

Interop\Ole32\CALPOLESTRTests.cs (2)

38pElems = (PWSTR*)Marshal.AllocCoTaskMem(IntPtr.Size * values.Length) 46IntPtr nativeCopy = Marshal.StringToCoTaskMemUni(values[i]);

Interop\Oleaut32\DECIMALTests.cs (1)

14Assert.Equal(16, Marshal.SizeOf<DECIMAL>());

Interop\Oleaut32\SAFEARRAYTests.cs (3)

25Assert.Equal(24, Marshal.SizeOf<SAFEARRAY>()); 37Assert.Equal(32, Marshal.SizeOf<SAFEARRAY>()); 123public IRecordInfo* GetComInterface() => (IRecordInfo*)Marshal.GetComInterfaceForObject<CustomRecordInfo, IRecordInfo.Interface>(this);

Interop\Oleaut32\VARIANTTests.cs (112)

Interop\Shell32\ShellItemTests.cs (1)

26Marshal.FreeCoTaskMem((nint)ppidl);

Metafiles\EmfScope.cs (1)

82IntPtr callback = Marshal.GetFunctionPointerForDelegate(CallBack);

Win32\WindowClass.cs (3)

79Marshal.GetHINSTANCE(Assembly.GetCallingAssembly().Modules.First()); 93lpfnWndProc = (delegate* unmanaged[Stdcall]<HWND, uint, WPARAM, LPARAM, LRESULT>)Marshal.GetFunctionPointerForDelegate(_windowProcedure), 200throw new Win32Exception(Marshal.GetLastWin32Error());

Windows\Win32\System\Com\ComClassFactory.cs (1)

61unknown = punk is null ? null : Marshal.GetObjectForIUnknown((nint)punk);

System\Windows\Forms\AxHost.PropertyBagStreamTests.cs (1)

71Marshal.GetNativeVariantForObject(value, (nint)(void*)&variant);

System\Windows\Forms\ClipboardTests.cs (2)

561SetClipboardData((uint)CLIPBOARD_FORMAT.CF_UNICODETEXT, (HANDLE)Marshal.StringToHGlobalUni(testString)); 942Marshal.Copy((nint)buffer, bytes, 0, size);

System\Windows\Forms\DataObjectTests.cs (1)

1928Marshal.ThrowExceptionForHR(QueryGetData(ref format));

System\Windows\Forms\DragDropFormatTests.cs (1)

60unionmember = Marshal.GetIUnknownForObject(iStream)

System\Windows\Forms\ListBoxTests.cs (1)

3348Marshal.Copy(GetSelResult, 0, m.LParam, GetSelResult.Length);

System\Windows\Forms\MessageTests.cs (4)

187IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf<TestStruct>()); 195Marshal.StructureToPtr(original, ptr, fDeleteOld: false); 207Marshal.FreeHGlobal(ptr);

System\Windows\Forms\RichTextBoxTests.cs (11)

10225IntPtr ptr = Marshal.AllocCoTaskMem(100); 10228Marshal.WriteInt32(ptr, IntPtr.Size * 2, (int)PInvoke.EN_PROTECTED); 10229Marshal.WriteInt32(ptr, IntPtr.Size * 2 + IntPtr.Size, (int)PInvokeCore.EM_SETCHARFORMAT); 10230Marshal.WriteIntPtr(ptr, IntPtr.Size * 2 + IntPtr.Size + 4 + IntPtr.Size, (IntPtr)(&format)); 10245Marshal.FreeCoTaskMem(ptr); 10461IntPtr ptr = Marshal.AllocCoTaskMem(100); 10464Marshal.WriteInt32(ptr, IntPtr.Size * 2, (int)PInvoke.EN_PROTECTED); 10465Marshal.WriteInt32(ptr, IntPtr.Size * 2 + IntPtr.Size, (int)PInvokeCore.EM_SETCHARFORMAT); 10466Marshal.WriteIntPtr(ptr, IntPtr.Size * 2 + IntPtr.Size + 4 + IntPtr.Size, (IntPtr)(&format)); 10484Marshal.FreeCoTaskMem(ptr); 11068int lastWin32Error = Marshal.GetLastWin32Error();

System\Windows\Forms\ToolTipBufferTests.cs (10)

TextBoxBaseTests.cs (2)

6143yield return new object[] { Marshal.GetIUnknownForObject(new object()) }; 6174IntPtr pUnk = Marshal.GetIUnknownForObject(new object());

ImageListTests.cs (1)

80int lastWin32Error = Marshal.GetLastWin32Error();

Infra\ControlTestBase.cs (4)

202throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()); 213throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());

Input\KeyboardSimulator.cs (6)

27PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>()); 38PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>()); 50PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>()); 62PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>()); 80PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>()); 111PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>());

Input\MouseSimulator.cs (7)

88PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>()); 99PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>()); 111PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>()); 125PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>()); 145PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>()); 156PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>()); 167PInvoke.SendInput(inputs, Marshal.SizeOf<INPUT>());

HttpSys\HttpSysConfigurator.cs (4)

54var pInputConfigInfo = Marshal.AllocCoTaskMem( 55Marshal.SizeOf(typeof(HTTP_SERVICE_CONFIG_SSL_SET))); 56Marshal.StructureToPtr(configSslSet, pInputConfigInfo, false); 61Marshal.SizeOf(configSslSet),

MS\Internal\Automation\HwndProxyElementProvider.cs (5)

310length = Marshal.SizeOf(typeof(UnsafeNativeMethods.WINDOWPLACEMENT)) 696length = Marshal.SizeOf(typeof(UnsafeNativeMethods.WINDOWPLACEMENT)) 810length = Marshal.SizeOf(typeof(UnsafeNativeMethods.WINDOWPLACEMENT)) 1908int lastWin32Error = Marshal.GetLastWin32Error(); 1933int lastWin32Error = Marshal.GetLastWin32Error();

MS\Internal\Automation\input.cs (2)

64Misc.SendInput(1, ref ki, Marshal.SizeOf(ki)); 83Misc.SendInput(1, ref ki, Marshal.SizeOf(ki));

MS\Internal\Automation\Misc.cs (29)

MS\Internal\Automation\ProxyManager.cs (2)

224int lastWin32Error = Marshal.GetLastWin32Error(); 238int lastWin32Error = Marshal.GetLastWin32Error();

MS\Internal\Automation\UiaCoreApi.cs (16)

139IntPtr dataStart = Marshal.AllocCoTaskMem((properties.Length + patterns.Length) * sizeof(int)); 165Marshal.FreeCoTaskMem(_pProperties); 638UiaEventArgs args = Marshal.PtrToStructure<UiaEventArgs>(argsAddr); 656UiaPropertyChangedEventArgs pcargs = Marshal.PtrToStructure<UiaPropertyChangedEventArgs>(argsAddr); 670UiaStructureChangedEventArgs scargs = Marshal.PtrToStructure<UiaStructureChangedEventArgs>(argsAddr); 677UiaAsyncContentLoadedEventArgs aclargs = Marshal.PtrToStructure<UiaAsyncContentLoadedEventArgs>(argsAddr); 683UiaWindowClosedEventArgs wcargs = Marshal.PtrToStructure<UiaWindowClosedEventArgs>(argsAddr); 690UiaNotificationEventArgs nargs = Marshal.PtrToStructure<UiaNotificationEventArgs>(argsAddr); 692Marshal.PtrToStringUni(nargs._displayString), Marshal.PtrToStringUni(nargs._activityId)); 697UiaActiveTextPositionChangedEventArgs atpcargs = Marshal.PtrToStructure<UiaActiveTextPositionChangedEventArgs>(argsAddr); 1126&& !Marshal.IsComObject(arr[1]) 1139IntPtr errorInfoAsIntPtr = Marshal.GetIUnknownForObject(errorInfo); 1142Marshal.Release(errorInfoAsIntPtr); 1145Marshal.ThrowExceptionForHR(hr); 1204Marshal.ThrowExceptionForHR(hr);

System\Windows\Automation\Condition.cs (5)

28Marshal.FreeCoTaskMem(handle); 38int size = Marshal.SizeOf(uiaCondition); 43IntPtr mem = Marshal.AllocCoTaskMem(size); 46Marshal.StructureToPtr(uiaCondition, sh.handle, false); 60IntPtr mem = Marshal.AllocCoTaskMem(conditions.Length * IntPtr.Size);

MS\Internal\AutomationProxies\CommonXSendMessage.cs (67)

MS\Internal\AutomationProxies\Input.cs (5)

119if( UnsafeNativeMethods.SendInput( 1, ref mi, Marshal.SizeOf(mi) ) == 0 ) 120throw new Win32Exception(Marshal.GetLastWin32Error()); 144if( UnsafeNativeMethods.SendInput( 1, ref ki, Marshal.SizeOf(ki) ) == 0 ) 145throw new Win32Exception(Marshal.GetLastWin32Error()); 168Misc.SendInput(1, ref ki, Marshal.SizeOf(ki));

MS\Internal\AutomationProxies\Misc.cs (59)

MS\Internal\AutomationProxies\SafeCoTaskMem.cs (4)

18SetHandle(Marshal.AllocCoTaskMem(length * sizeof (char))); 23return Marshal.PtrToStringAuto(handle); 29return Marshal.PtrToStringUni(handle, length); 34Marshal.FreeCoTaskMem(handle);

MS\Internal\AutomationProxies\WindowsAltTab.cs (2)

236altTabInfo.cbSize = (uint)Marshal.SizeOf(typeof(UnsafeNativeMethods.ALTTABINFO)); 246int lastWin32Error = Marshal.GetLastWin32Error();

MS\Internal\AutomationProxies\WindowsEditBox.cs (2)

553int cb = Marshal.SizeOf(typeof(NativeMethods.LOGFONT)); 706cbSize = System.Runtime.InteropServices.Marshal.SizeOf(typeof(NativeMethods.ScrollInfo)),

MS\Internal\AutomationProxies\WindowsHyperlink.cs (3)

211bGetItemResult = XSendMessage.XSend(_hwnd, NativeMethods.LM_HITTEST, IntPtr.Zero, new IntPtr(&HitTestInfo), Marshal.SizeOf(HitTestInfo.GetType())); 395return XSendMessage.XSend(_hwnd, NativeMethods.LM_SETITEM, IntPtr.Zero, new IntPtr(&linkItem), Marshal.SizeOf(linkItem.GetType())); 492bGetItemResult = XSendMessage.XSend(_hwnd, NativeMethods.LM_HITTEST, IntPtr.Zero, new IntPtr(&HitTestInfo), Marshal.SizeOf(HitTestInfo.GetType()));

MS\Internal\AutomationProxies\WindowsListView.cs (7)

1269if (XSendMessage.XSend(hwnd, NativeMethods.LVM_GETITEMRECT, new IntPtr(item), new IntPtr(location), Marshal.SizeOf(itemRectangle.GetType()))) 1420result = XSendMessage.XSendGetIndex(hwnd, NativeMethods.LVM_SUBITEMHITTEST, IntPtr.Zero, new IntPtr(&hitTestNative), Marshal.SizeOf(hitTestNative.GetType())); 1429result = XSendMessage.XSendGetIndex(hwnd, NativeMethods.LVM_SUBITEMHITTEST, IntPtr.Zero, new IntPtr(&hitTestNative), Marshal.SizeOf(hitTestNative.GetType())); 1493if (XSendMessage.XSend(hwnd, NativeMethods.LVM_GETSUBITEMRECT, new IntPtr(item), new IntPtr(location), Marshal.SizeOf(itemRectangle.GetType()))) 1664scrollBarInfo.cbSize = Marshal.SizeOf(scrollBarInfo.GetType()); 1675si.cbSize = Marshal.SizeOf (si.GetType ()); 1792if (XSendMessage.XSend(hwnd, NativeMethods.LVM_GETITEMPOSITION, new IntPtr(item), new IntPtr(location), Marshal.SizeOf(pt.GetType())))

MS\Internal\AutomationProxies\WindowsListViewGroup.cs (12)

MS\Internal\AutomationProxies\WindowsListViewGroupHelper.cs (5)

386while (XSendMessage.XSend (hwnd, NativeMethods.LVM_GETNEXTITEMINDEX, new IntPtr(&ii), flags, Marshal.SizeOf(ii.GetType()))) 390groupInfo.Init(Marshal.SizeOf(typeof(NativeMethods.LVGROUP_V6))); 393bool lresult = XSendMessage.XSend(hwnd, NativeMethods.LVM_GETGROUPINFOBYINDEX, new IntPtr(ii.iGroup), new IntPtr(&groupInfo), Marshal.SizeOf(typeof(NativeMethods.LVGROUP_V6))); 703new IntPtr(_groupID), new IntPtr(&rect), Marshal.SizeOf(rect.GetType())); 814sbi.cbSize = Marshal.SizeOf(sbi.GetType());

MS\Internal\AutomationProxies\WindowsListViewGroupSubsetLink.cs (3)

77XSendMessage.XSend(_hwnd, NativeMethods.LVM_GETGROUPRECT, new IntPtr(0), new IntPtr(&rect), Marshal.SizeOf(rect.GetType())); 88groupInfo.Init(Marshal.SizeOf(typeof(NativeMethods.LVGROUP_V6))); 105group.Init(Marshal.SizeOf(typeof(NativeMethods.LVGROUP_V6)));

MS\Internal\AutomationProxies\WindowsListViewItem.cs (2)

133if (XSendMessage.XSend(_hwnd, NativeMethods.LVM_GETITEMINDEXRECT, new IntPtr(&ii), new IntPtr(&itemRectangle), Marshal.SizeOf(ii.GetType()), Marshal.SizeOf(itemRectangle.GetType())))

MS\Internal\AutomationProxies\WindowsListViewScroll.cs (1)

56si.cbSize = Marshal.SizeOf (si.GetType ());

MS\Internal\AutomationProxies\WindowsMenu.cs (6)

504mbi.cbSize = Marshal.SizeOf(mbi.GetType()); 1886menuItemInfo.cbSize = Marshal.SizeOf(menuItemInfo.GetType()); 1901menuItemInfo.cbSize = Marshal.SizeOf (menuItemInfo.GetType ()); 1945menuItemInfo.cbSize = Marshal.SizeOf(menuItemInfo.GetType()); 2552menuItemInfo.cbSize = Marshal.SizeOf(menuItemInfo.GetType()); 2593int readSize = Marshal.SizeOf(msaaMenuInfo.GetType());

MS\Internal\AutomationProxies\WindowsRebar.cs (3)

206return XSendMessage.XSendGetIndex(_hwnd, NativeMethods.RB_HITTEST, IntPtr.Zero, new IntPtr(&rbHitTestInfo), Marshal.SizeOf(rbHitTestInfo.GetType())); 399if (!XSendMessage.XSend(hwnd, NativeMethods.RB_GETRECT, new IntPtr(item), new IntPtr(&rectW32), Marshal.SizeOf(rectW32.GetType()), XSendMessage.ErrorValue.Zero)) 435if (XSendMessage.XSend(_hwnd, NativeMethods.RB_GETBANDINFOA, new IntPtr(_item), new IntPtr(&rebarBandInfo), Marshal.SizeOf(rebarBandInfo.GetType()), XSendMessage.ErrorValue.Zero))

MS\Internal\AutomationProxies\WindowsRichEditRange.cs (1)

1233Marshal.ThrowExceptionForHR(hr);

MS\Internal\AutomationProxies\WindowsScroll.cs (6)

127sbi.cbSize = Marshal.SizeOf(sbi.GetType()); 143si.cbSize = Marshal.SizeOf (si.GetType ()); 195si.cbSize = Marshal.SizeOf (si.GetType ()); 250si.cbSize = Marshal.SizeOf (si.GetType ()); 291si.cbSize = Marshal.SizeOf(si.GetType ()); 367si.cbSize = Marshal.SizeOf (si.GetType ());

MS\Internal\AutomationProxies\WindowsScrollBar.cs (8)

135sbi.cbSize = Marshal.SizeOf (sbi.GetType ()); 431si.cbSize = Marshal.SizeOf (si.GetType ()); 445sbi.cbSize = Marshal.SizeOf (sbi.GetType ()); 519sbi.cbSize = Marshal.SizeOf (sbi.GetType ()); 572si.cbSize = Marshal.SizeOf (si.GetType ()); 625si.cbSize = Marshal.SizeOf (si.GetType ()); 711sbi.cbSize = Marshal.SizeOf (sbi.GetType ()); 726sbi.cbSize = Marshal.SizeOf(sbi.GetType());

MS\Internal\AutomationProxies\WindowsScrollBarBits.cs (3)

205si.cbSize = Marshal.SizeOf (si.GetType ()); 223sbi.cbSize = Marshal.SizeOf (sbi.GetType ()); 542si.cbSize = Marshal.SizeOf (si.GetType ());

MS\Internal\AutomationProxies\WindowsSlider.cs (2)

460XSendMessage.XSend(hwnd, NativeMethods.TBM_GETCHANNELRECT, IntPtr.Zero, new IntPtr(&rcChannel), Marshal.SizeOf(rcChannel.GetType()), XSendMessage.ErrorValue.NoCheck); 472XSendMessage.XSend(hwnd, NativeMethods.TBM_GETTHUMBRECT, IntPtr.Zero, new IntPtr(&rcThumb), Marshal.SizeOf(rcThumb.GetType()), XSendMessage.ErrorValue.NoCheck);

MS\Internal\AutomationProxies\WindowsSysHeader.cs (2)

161index = XSendMessage.XSendGetIndex(_hwnd, NativeMethods.HDM_HITTEST, IntPtr.Zero, new IntPtr(&HitTestInfo), Marshal.SizeOf(HitTestInfo.GetType())); 568result = XSendMessage.XSend(_hwnd, NativeMethods.HDM_GETITEMRECT, new IntPtr(index), new IntPtr(&rectW32), Marshal.SizeOf(rectW32.GetType()), XSendMessage.ErrorValue.Zero);

MS\Internal\AutomationProxies\WindowsTab.cs (3)

276index = XSendMessage.XSendGetIndex(_hwnd, NativeMethods.TCM_HITTEST, IntPtr.Zero, new IntPtr(&hti), Marshal.SizeOf(hti.GetType())); 653result = XSendMessage.XSend(hwnd, NativeMethods.TCM_GETITEMRECT, new IntPtr(count - 1), new IntPtr(&rectW32), Marshal.SizeOf(rectW32.GetType()), XSendMessage.ErrorValue.Zero); 1272if (!XSendMessage.XSend(_hwnd, NativeMethods.TCM_GETITEMRECT, new IntPtr(_item), new IntPtr(&rectW32), Marshal.SizeOf(rectW32.GetType()), XSendMessage.ErrorValue.Zero))

MS\Internal\AutomationProxies\WindowsTreeView.cs (3)

555if (!XSendMessage.XSend(hwnd, NativeMethods.TVM_GETITEMRECT, partialDisplay, rectangle, Marshal.SizeOf(rc.GetType()))) 935if (Marshal.SizeOf(_hItem.GetType()) > sizeof(int)) 1592int readSize = Marshal.SizeOf(ent.GetType());

MS\Win32\NativeMethods.cs (1)

1486internal static int comboboxInfoSize = Marshal.SizeOf(typeof(NativeMethods.COMBOBOXINFO));

MS\Win32\UnsafeNativeMethods.cs (2)

378error = Marshal.GetLastWin32Error(); 385error = Marshal.GetLastWin32Error();

MS\Internal\Automation\UiaCoreProviderApi.cs (1)

105Marshal.ThrowExceptionForHR(hr, (IntPtr)(-1));

MS\Internal\Automation\UiaCoreTypesApi.cs (1)

102Marshal.ThrowExceptionForHR(hr, (IntPtr)(-1));

src\Microsoft.DotNet.Wpf\src\Shared\MS\Win32\NativeMethodsCLR.cs (35)

1525return Marshal.SizeOf(typeof(MONITORINFOEX)); 1538return Marshal.SizeOf(typeof(TRACKMOUSEEVENT)); 1593return Marshal.SizeOf(typeof(NONCLIENTMETRICS)); 1608return Marshal.SizeOf(typeof(ICONMETRICS)); 1738return Marshal.SizeOf(typeof(MENUITEMINFO_T)); 1785return Marshal.SizeOf(typeof(OPENFILENAME_I)); 1964return Marshal.SizeOf(typeof(tagCONTROLINFO)); 1991Marshal.Release(this.data1); 2025IntPtr mem = Marshal.AllocCoTaskMem(16); 2026Marshal.WriteInt16(mem, vt); 2027Marshal.WriteInt16(mem, 2, reserved1); 2028Marshal.WriteInt16(mem, 4, reserved2); 2029Marshal.WriteInt16(mem, 6, reserved3); 2030Marshal.WriteInt32(mem, 8, (int) data1); 2031Marshal.WriteInt32(mem, 12, (int) data2); 2049val = (IntPtr) Marshal.ReadByte(val); 2055val = (IntPtr) Marshal.ReadByte(val); 2062val = (IntPtr) Marshal.ReadInt16(val); 2068val = (IntPtr) Marshal.ReadInt16(val); 2075val = (IntPtr) Marshal.ReadInt32(val); 2082val = (IntPtr) Marshal.ReadInt32(val); 2089longVal = Marshal.ReadInt64(val); 2123return Marshal.PtrToStringUni(val); 2126return Marshal.PtrToStringAnsi(val); 2131return Marshal.GetObjectForIUnknown(val); 2145VARIANT varStruct = Marshal.PtrToStructure<VARIANT>(val); 2149Guid guid = Marshal.PtrToStructure<Guid>(val); 2183return Marshal.ReadIntPtr(value); 2305if (Marshal.SystemDefaultCharSize == 1) 2336IntPtr result = Marshal.AllocCoTaskMem(buffer.Length); 2337Marshal.Copy(buffer, 0, result, buffer.Length); 2360Marshal.Copy(ptr, buffer, 0, buffer.Length); 2394IntPtr result = Marshal.AllocCoTaskMem(buffer.Length * 2); 2395Marshal.Copy(buffer, 0, result, buffer.Length); 2417Marshal.Copy(ptr, buffer, 0, buffer.Length);

src\Microsoft.DotNet.Wpf\src\Shared\MS\Win32\NativeMethodsOther.cs (5)

86return Marshal.SizeOf(typeof(OSVERSIONINFOEX)); 157return Marshal.SizeOf(typeof(DOCHOSTUIINFO)); 513return Marshal.SizeOf(typeof(BITMAPINFO)); 544return Marshal.SizeOf(typeof(SECURITY_ATTRIBUTES)); 1083return Marshal.SizeOf(typeof(ANIMATIONINFO));

src\Microsoft.DotNet.Wpf\src\Shared\MS\Win32\UnsafeNativeMethodsCLR.cs (16)

src\Compilers\Shared\BuildClient.cs (1)

364var commandLine = Marshal.PtrToStringUni(ptr)!;

src\Compilers\Shared\BuildServerConnection.cs (2)

473startInfo.cb = Marshal.SizeOf(startInfo); 507logger.LogError("Failed to create process. GetLastError={0}", Marshal.GetLastWin32Error());

src\Compilers\Server\VBCSCompiler\MemoryHelper.cs (1)

21this.Length = (int)Marshal.SizeOf(this);

src\Compilers\Shared\BuildClient.cs (1)

364var commandLine = Marshal.PtrToStringUni(ptr)!;

src\Compilers\Shared\BuildServerConnection.cs (2)

473startInfo.cb = Marshal.SizeOf(startInfo); 507logger.LogError("Failed to create process. GetLastError={0}", Marshal.GetLastWin32Error());

System\Windows\Integration\WindowsFormsHost.cs (1)

974throw new Win32Exception(Marshal.GetLastWin32Error());

ScalingBeforeChanges.cs (1)

common\AssemblyResolution\Microsoft.DotNet.PlatformAbstractions\Native\NativeMethods.Darwin.cs (1)

35return Marshal.PtrToStringAnsi((IntPtr)buf, (int)*len);

common\AssemblyResolution\Microsoft.DotNet.PlatformAbstractions\Native\NativeMethods.Windows.cs (1)

31osvi.dwOSVersionInfoSize = (uint)Marshal.SizeOf(osvi);