Marshal

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

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

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

466startInfo.cb = Marshal.SizeOf(startInfo); 500logger.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)

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

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

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

Rendering\EndpointHtmlRenderer.Streaming.cs (1)

128var 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 (3)

86throw new HttpSysException(Marshal.GetLastWin32Error()); 114&length, (uint)Marshal.SizeOf<long>()); 130&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)

242return 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)

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

TimeoutManager.cs (1)

19Marshal.SizeOf<HTTP_TIMEOUT_LIMIT_INFO>();

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)

269return Marshal.PtrToStringAnsi((IntPtr)NativeRequest->pRawUrl.Value, NativeRequest->RawUrlLength); 811Marshal.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)

269return Marshal.PtrToStringAnsi((IntPtr)NativeRequest->pRawUrl.Value, NativeRequest->RawUrlLength); 811Marshal.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)

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

EnvironmentUtilities.cs (1)

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

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)

131int hr = Marshal.GetLastWin32Error(); 184int hr = Marshal.GetLastWin32Error();

WindowsFileSystem.cs (2)

131int hr = Marshal.GetLastWin32Error(); 184int hr = Marshal.GetLastWin32Error();

BackEnd\TargetUpToDateChecker_Tests.cs (6)

1037Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); 1051Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); 1059Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());

NativeMethods.cs (12)

294_length = (uint)Marshal.SizeOf<MemoryStatus>(); 399_nLength = (uint)Marshal.SizeOf<SecurityAttributes>(); 524Marshal.GetLastWin32Error() == ERROR_INSUFFICIENT_BUFFER) 1036int errorCode = Marshal.GetLastWin32Error(); 1042errorCode = Marshal.GetLastWin32Error(); 1076int errorCode = Marshal.GetLastWin32Error(); 1082errorCode = Marshal.GetLastWin32Error(); 1133errorMessage = symbolicLinkCreated ? null : Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()).Message; 1138errorMessage = symbolicLinkCreated ? null : Marshal.GetLastWin32Error().ToString(); 1301Marshal.ThrowExceptionForHR(errorCode); 1574int 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)

466startInfo.cb = Marshal.SizeOf(startInfo); 500logger.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)

929int code = Marshal.GetHRForException(e);

EnvironmentUtilities.cs (1)

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

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)

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

ManifestUtil\mansign2.cs (9)

429string issuerKeyHash = Marshal.PtrToStringUni(pIssuerKeyHash); 545string publicKeyToken = Marshal.PtrToStringUni(pPublicKeyToken); 865throw new CryptographicException(Marshal.GetLastWin32Error()); 869var timestampContext = (Win32.CRYPT_TIMESTAMP_CONTEXT)Marshal.PtrToStructure(ppTsContext, typeof(Win32.CRYPT_TIMESTAMP_CONTEXT)); 871Marshal.Copy(timestampContext.pbEncoded, encodedBytes, 0, (int)timestampContext.cbEncoded); 943Marshal.Copy(timestampBlob.pbData, timestampSignature, 0, timestampSignature.Length); 1313_hash = Marshal.PtrToStringUni(signerInfo.pwszHash); 1317_description = Marshal.PtrToStringUni(signerInfo.pwszDescription); 1321_descriptionUrl = Marshal.PtrToStringUni(signerInfo.pwszDescriptionUrl);

ManifestUtil\SecurityUtil.cs (1)

744int exceptionHR = Marshal.GetHRForException(ex);

Move.cs (2)

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

NativeMethods.cs (5)

808errorMessage = hardLinkCreated ? null : Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()).Message; 813errorMessage = hardLinkCreated ? null : log.FormatResourceString("Copy.NonWindowsLinkErrorMessage", "link()", Marshal.GetLastWin32Error()); 1363Marshal.ThrowExceptionForHR(hr); 1432Marshal.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)

131int hr = Marshal.GetLastWin32Error(); 184int hr = Marshal.GetLastWin32Error();

AddToWin32Manifest_Tests.cs (1)

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

Copy_Tests.cs (4)

2618int errorCode = Marshal.GetHRForLastWin32Error(); 2619Marshal.GetExceptionForHR(errorCode); 2723int errorCode = Marshal.GetHRForLastWin32Error(); 2724Marshal.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)

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

DriveMapping.cs (3)

31NativeMethodsShared.ThrowExceptionForErrorCode(Marshal.GetLastWin32Error()); 44NativeMethodsShared.ThrowExceptionForErrorCode(Marshal.GetLastWin32Error()); 62int err = Marshal.GetLastWin32Error();

EnvironmentUtilities.cs (1)

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

NativeWin32Exception.cs (1)

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

WindowsFileSystem.cs (2)

131int hr = Marshal.GetLastWin32Error(); 184int hr = Marshal.GetLastWin32Error();

NativeMethodsShared_Tests.cs (1)

55GetProcessIdDelegate 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)

79Marshal.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);

Compilation\IRuntimeEnvironment.cs (1)

75Marshal.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)

180return 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>();

Interop\StructuredStorage.cs (5)

72Marshal.ReleaseComObject(rootStorageEnum); 77Marshal.ReleaseComObject(rootStorage); 96Marshal.ReleaseComObject(rootStorage); 127Marshal.ReleaseComObject(fileStg); 130Marshal.ReleaseComObject(stg);

Verification\AuthentiCode.cs (17)

23cbStruct = (uint)Marshal.SizeOf(typeof(WinTrustFileInfo)), 31cbStruct = (uint)Marshal.SizeOf(typeof(WinTrustData)), 39pFile = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(WinTrustFileInfo))), 46Marshal.StructureToPtr(fileInfo, data.pFile, false); 48IntPtr pGuid = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Guid))); 49IntPtr pData = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(WinTrustData))); 50Marshal.StructureToPtr(data, pData, true); 51Marshal.StructureToPtr(WinTrust.WINTRUST_ACTION_GENERIC_VERIFY_V2, pGuid, true); 55Marshal.FreeHGlobal(pGuid); 56Marshal.FreeHGlobal(pData); 113Marshal.StringToHGlobalUni(path), 124throw new Win32Exception(Marshal.GetLastWin32Error()); 132throw new Win32Exception(Marshal.GetLastWin32Error()); 138throw new Win32Exception(Marshal.GetLastWin32Error());

Verification\AuthentiCodeVerifier.cs (1)

52string errorMessage = new Win32Exception(Marshal.GetLastWin32Error()).Message;

Verification\StrongName.cs (1)

36Marshal.Copy(tokenPtr, token, 0, tokenSize);

Verification\VsixVerifier.cs (2)

86var timestampContext = (CRYPT_TIMESTAMP_CONTEXT)Marshal.PtrToStructure(TSContextPtr, typeof(CRYPT_TIMESTAMP_CONTEXT)); 87var timestampInfo = (CRYPT_TIMESTAMP_INFO)Marshal.PtrToStructure(timestampContext.pTimeStamp, typeof(CRYPT_TIMESTAMP_INFO));

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)

214 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)

241string mes = Marshal.PtrToStringAnsi(charPtr); 290return 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);

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)

272Marshal.ThrowExceptionForHR(shellService.GetToolWindowEnum(out var windowEnum)); 273Marshal.ThrowExceptionForHR(textView.GetBuffer(out _)); 280Marshal.ThrowExceptionForHR(frame[0].GetGuidProperty((int)__VSFPROPID.VSFPROPID_GuidPersistenceSlot, out var toolWindowGuid)); 283Marshal.ThrowExceptionForHR(frame[0].QueryViewInterface(typeof(IVsTextView).GUID, out var frameTextView)); 286var immediateWindowTextView = Marshal.GetObjectForIUnknown(frameTextView) as IVsTextView; 291Marshal.Release(frameTextView);

DebuggerIntelliSense\DebuggerIntellisenseFilter.cs (1)

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

EditorConfigSettings\SettingsEditorFactory.cs (5)

113textBuffer = Marshal.GetObjectForIUnknown(ptr) as IVsTextLines; 117_ = Marshal.Release(ptr); // Release RefCount from CreateInstance call 129textBuffer = Marshal.GetObjectForIUnknown(punkDocDataExisting) as IVsTextLines; 150ppunkDocView = Marshal.GetIUnknownForObject(newEditor); 151ppunkDocData = 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)

90var docDataExisting = Marshal.GetObjectForIUnknown(punkDocDataExisting); 144ppunkDocView = Marshal.GetIUnknownForObject(codeWindow); 154ppunkDocData = Marshal.GetIUnknownForObject(textBuffer); 176Marshal.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)

30Marshal.ThrowExceptionForHR( 58Marshal.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)

127FatalError.ReportAndCatch(Marshal.GetExceptionForHR(hr)); 144FatalError.ReportAndCatch(Marshal.GetExceptionForHR(hr)); 326FatalError.ReportAndCatch(Marshal.GetExceptionForHR(hr)); 444FatalError.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)

124Marshal.ThrowExceptionForHR( 178Marshal.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)

168Marshal.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)

87Marshal.ThrowExceptionForHR(bufferCoordinator.GetSecondaryBuffer(out var secondaryTextLines)); 91Marshal.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)

55Marshal.ThrowExceptionForHR(_undoManager.OpenLinkedUndo((uint)LinkedTransactionFlags2.mdtGlobal, _description)); 110Marshal.ThrowExceptionForHR(result); 127Marshal.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)

CommunicationsUtilities.cs (2)

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

WindowsFileSystem.cs (2)

131int hr = Marshal.GetLastWin32Error(); 184int hr = Marshal.GetLastWin32Error();

CommunicationsUtilities.cs (2)

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

NativeMethods.cs (12)

292_length = (uint)Marshal.SizeOf(typeof(MemoryStatus)); 397_nLength = (uint)Marshal.SizeOf(typeof(SecurityAttributes)); 524Marshal.GetLastWin32Error() == ERROR_INSUFFICIENT_BUFFER) 1036int errorCode = Marshal.GetLastWin32Error(); 1042errorCode = Marshal.GetLastWin32Error(); 1076int errorCode = Marshal.GetLastWin32Error(); 1082errorCode = Marshal.GetLastWin32Error(); 1133errorMessage = symbolicLinkCreated ? null : Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()).Message; 1138errorMessage = symbolicLinkCreated ? null : Marshal.GetLastWin32Error().ToString(); 1301Marshal.ThrowExceptionForHR(errorCode); 1574int 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)

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

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

99Marshal.ThrowExceptionForHR(hr);

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

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

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

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

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

521int allocationSize = (int)(Marshal.SizeOf(typeof(MS.Win32.Recognizer.PACKET_PROPERTY)) * packetDescription.cPacketProperties); 522packetDescription.pPacketProperties = Marshal.AllocCoTaskMem(allocationSize); 528Marshal.StructureToPtr(packetProperties[i], new IntPtr(pElement), false); 539packets = Marshal.AllocCoTaskMem(countOfBytes); 540Marshal.Copy(rawPackets, 0, packets, packetCount); 560Marshal.DestroyStructure(new IntPtr(pElement), typeof(MS.Win32.Recognizer.PACKET_PROPERTY)); 564Marshal.FreeCoTaskMem(pd.pPacketProperties); 570Marshal.FreeCoTaskMem(pd.pguidButtons); 576Marshal.FreeCoTaskMem(packets);

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

479throw 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\TextFormatting\LineServicesCallbacks.cs (1)

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

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

248Marshal.ReleaseComObject(_inputPane);

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

26Marshal.ThrowExceptionForHR(NativeMethods.WindowsCreateString(typeName, typeName.Length, out hstring)); 30Marshal.ThrowExceptionForHR(NativeMethods.RoGetActivationFactory(hstring, ref iid, out object factory)); 35Marshal.ThrowExceptionForHR(NativeMethods.WindowsDeleteString(hstring));

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

164Marshal.ReleaseComObject(_uisettings);

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

18Marshal.ThrowExceptionForHR(hr); 22Marshal.ThrowExceptionForHR(hr); 28Marshal.ThrowExceptionForHR(hr);

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

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

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

53int win32Err = Marshal.GetLastWin32Error();

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

134return Marshal.GetExceptionForHR(hr, new IntPtr(-1)); 141Marshal.ThrowExceptionForHR(hr, new IntPtr(-1)); 151int hr = Marshal.GetHRForException(exception); 155Marshal.GetHRForException(new Exception());

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

29UInt32 size = (UInt32)Marshal.SizeOf(icci); 39int hr = Marshal.GetHRForLastWin32Error(); 43Marshal.ThrowExceptionForHR(hr);

System\Windows\clipboard.cs (4)

61Marshal.ThrowExceptionForHR(hr); 492Marshal.ThrowExceptionForHR(hr); 602Marshal.ThrowExceptionForHR(hr); 608if (oleDataObject is IDataObject && !Marshal.IsComObject(oleDataObject))

System\Windows\dataobject.cs (29)

563Marshal.ThrowExceptionForHR(NativeMethods.E_NOTIMPL); 663medium.unionmember = Marshal.GetComInterfaceForObject(istream, typeof(IStream)); 664Marshal.ReleaseComObject(istream); 670Marshal.Release(medium.unionmember); 686Marshal.ThrowExceptionForHR(hr); 702Marshal.ThrowExceptionForHR(DV_E_TYMED); 708Marshal.ThrowExceptionForHR(hr); 761Marshal.ThrowExceptionForHR(NativeMethods.E_NOTIMPL); 969int win32Error = Marshal.GetLastWin32Error(); 986Marshal.ThrowExceptionForHR(hr); 998int win32Error = Marshal.GetLastWin32Error(); 1011int win32Error = Marshal.GetLastWin32Error(); 1026int win32Error = Marshal.GetLastWin32Error(); 1041int win32Error = Marshal.GetLastWin32Error(); 1055int win32Error = Marshal.GetLastWin32Error(); 1148int win32Error = Marshal.GetLastWin32Error(); 1381int win32Error = Marshal.GetLastWin32Error(); // Dance around FxCop 1548IStream istream = (IStream)( Marshal.GetObjectForIUnknown(medium.unionmember) ); 1578Marshal.ReleaseComObject(istream); 1722Marshal.Copy(bytes, 0, ptr, NativeMethods.IntPtrToInt32(size)); 1803if (Marshal.SystemDefaultCharSize == 1) 1839Marshal.Copy(structData, 0, currentPtr, structData.Length); 1957Marshal.Copy(new byte[] { 0 }, 0, (IntPtr)((long)ptr + pinvokeSize), 1); 2007Marshal.Copy(new byte[] { 0 }, 0, (IntPtr)((long)pointerUtf8 + utf8ByteCount), 1); 2480Marshal.FreeCoTaskMem(formatetc[formatetcIndex].ptd); 2662pStream = (UnsafeNativeMethods.IStream)Marshal.GetObjectForIUnknown(medium.unionmember); 2951Marshal.Copy(ptr, bytes, 0, size); 3157byte endByte = Marshal.ReadByte((IntPtr)((long)pointerUtf8 + utf8ByteCount)); 3171Marshal.Copy(pointerUtf8, bytes, 0, utf8ByteCount);

System\Windows\DpiChangedEventArgs.cs (1)

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

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

177int errorCode = Marshal.GetLastWin32Error();

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

284Marshal.ReleaseComObject(compartment);

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

66Marshal.ReleaseComObject(composition); 69Marshal.ReleaseComObject(context); 89Marshal.ReleaseComObject(doc); 108Marshal.ReleaseComObject(enumCompositionView);

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

1511Marshal.ReleaseComObject(fnConfigure); 1514Marshal.ReleaseComObject(funcPrv); 1564Marshal.ReleaseComObject(fnConfigure); 1567Marshal.ReleaseComObject(funcPrv); 1675Marshal.ReleaseComObject(enumIpp);

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

86Marshal.ReleaseComObject(_ipp); 157short langid = Marshal.PtrToStructure<short>((IntPtr)((Int64)langids + sizeof(short) * i)); 162Marshal.FreeCoTaskMem(langids);

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

792Marshal.Copy(pPackets, data, 0, cItems); 1121Marshal.ReleaseComObject(penContext._pimcContext);

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

343Marshal.ReleaseComObject(tablet);

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

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

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

396int win32Err = Marshal.GetLastWin32Error();

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

99Marshal.ReleaseComObject(compartment); 100Marshal.ReleaseComObject(source); 118Marshal.ReleaseComObject(compartment); 119Marshal.ReleaseComObject(source); 199Marshal.ReleaseComObject(compartment); 211Marshal.ReleaseComObject(compartment);

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

82Marshal.ReleaseComObject(_defaultTextStore.DocumentManager); 121Marshal.ReleaseComObject(_dimEmpty); 130Marshal.ReleaseComObject(_threadManager); 219Marshal.ReleaseComObject(context); 360Marshal.ReleaseComObject(comp); 392Marshal.ReleaseComObject(comp);

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

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

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

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

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

878Marshal.PtrToStructure<NativeMethods.RECT>(lParam); 1464return new IntPtr(Marshal.GetHRForException(e)); 1867NativeMethods.WINDOWPOS windowPos = Marshal.PtrToStructure<NativeMethods.WINDOWPOS>(lParam);

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

494Marshal.Copy(_chunkList[currentChunk], bufferOffset, (IntPtr)pbData, cbDataForThisChunk); 498Marshal.Copy((IntPtr)pbData, _chunkList[currentChunk], bufferOffset, cbDataForThisChunk);

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

647HRESULT.Check(Marshal.GetHRForLastWin32Error()); 661HRESULT.Check(Marshal.GetHRForLastWin32Error());

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

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

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

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

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

94return Marshal.GetHRForException(e);

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

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

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

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

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

29pstrName = Marshal.StringToCoTaskMemUni(name); 34Marshal.FreeCoTaskMem(pstrName);

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

234pIEnumMetadata = Marshal.GetComInterfaceForObject( 684blockWriter = Marshal.GetComInterfaceForObject( 733blockWriter = Marshal.GetComInterfaceForObject(

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

83_current = Marshal.PtrToStringUni(ppStr); 90Marshal.FreeCoTaskMem(ppStr);

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

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

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

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

1079elementSize = Marshal.SizeOf(exemplar); 1107elementSize = Marshal.SizeOf(exemplar);

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

188ChangeWindowMessageFilterNative function = Marshal.GetDelegateForFunctionPointer(

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

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

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

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

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

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

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

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

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

48else if (sink == null || !eventInterface.IsInstanceOfType(sink) && !Marshal.IsComObject(sink)) 58Marshal.FinalReleaseComObject(connectionPoint); 74Marshal.FinalReleaseComObject(connectionPoint); 115System.Runtime.InteropServices.Marshal.FinalReleaseComObject(connectionPoint);

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

41Marshal.WriteInt32(pceltFetched, 0, 0); 59Marshal.WriteIntPtr(rgelt, Marshal.GetIUnknownForObject(this.arr[this.loc])); 67Marshal.WriteInt32(pceltFetched, 0, fetched);

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

105Marshal.Copy(s.ToCharArray(), 0, p, s.Length); 108Marshal.WriteInt16(p, s.Length * _int16Size, 0); 126native.union.name = Marshal.StringToCoTaskMemUni(propSpec.PropName); 188pszVal = Marshal.StringToCoTaskMemAnsi((string)obj); 213pNative = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(PROPVARIANT))); 219Marshal.StructureToPtr(v, pNative, false); 225Marshal.FreeCoTaskMem(pszVal); 230Marshal.FreeCoTaskMem(pNative);

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

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

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

47Marshal.WriteInt32(bytesReadPtr, bytesRead); 86Marshal.WriteInt64(newPositionPtr, position); 151Marshal.WriteInt32(bytesWrittenPtr, bufferSize);

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

126Marshal.WriteInt16(pBuffer, 0); 181short shCharacter = Marshal.ReadInt16(pBuffer); 200shCharacter = Marshal.ReadInt16(pBuffer, _int16Size); 258Marshal.WriteInt16(pBuffer, (int)bufCharacterCount * _int16Size, 0);

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

29public int lStructSize = Marshal.SizeOf(typeof(PRINTDLGEX32)); 55public int lStructSize = Marshal.SizeOf(typeof(PRINTDLGEX64));

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

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

459var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 3); 460Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 631var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 17); 632Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 1143var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 3); 1144Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 1295var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 4); 1296Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 1483var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 1); 1484Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 1575Invoke = Marshal.GetFunctionPointerForDelegate(AbiInvokeDelegate) 1577var nativeVftbl = ComWrappersSupport.AllocateVtableMemory(typeof(WordSegmentsTokenizingHandler), Marshal.SizeOf<global::WinRT.Interop.IDelegateVftbl>()); 1578Marshal.StructureToPtr(AbiToProjectionVftable, nativeVftbl, false); 1608var abiInvoke = Marshal.GetDelegateForFunctionPointer<Abi_Invoke>(_nativeDelegate.Vftbl.Invoke);

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

234var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 4); 235Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 418var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 1); 419Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 492var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 1); 493Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 573var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 1); 574Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 656var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 2); 657Marshal.StructureToPtr(AbiToProjectionVftable, (IntPtr)nativeVftbl, false); 772var nativeVftbl = (IntPtr*)ComWrappersSupport.AllocateVtableMemory(typeof(Vftbl), Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 1); 773Marshal.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)

76Marshal.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; 205var vftblPtr = Marshal.PtrToStructure<VftblPtr>(thisPtr); 206var vftblIUnknown = Marshal.PtrToStructure<IUnknownVftbl>(vftblPtr.Vftbl); 214vftblT = 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); 300if (Marshal.GetHRForException(e) == ExceptionHelpers.E_CHANGED_STATE) 427var vftblPtr = Marshal.PtrToStructure<VftblPtr>(thisPtr); 429IInspectableVftbl = Marshal.PtrToStructure<IInspectable.Vftbl>(vftblPtr.Vftbl); 430get_Current_0 = Marshal.GetDelegateForFunctionPointer(vftbl[6], get_Current_0_Type); 431get_HasCurrent_1 = Marshal.GetDelegateForFunctionPointer<_get_PropertyAsBoolean>(vftbl[7]); 432MoveNext_2 = Marshal.GetDelegateForFunctionPointer<IEnumerator_Delegates.MoveNext_2>(vftbl[8]); 433GetMany_3 = Marshal.GetDelegateForFunctionPointer<IEnumerator_Delegates.GetMany_3>(vftbl[9]); 448var nativeVftbl = (IntPtr*)Marshal.AllocCoTaskMem(Marshal.SizeOf<global::WinRT.IInspectable.Vftbl>() + sizeof(IntPtr) * 4); 449Marshal.StructureToPtr(AbiToProjectionVftable.IInspectableVftbl, (IntPtr)nativeVftbl, false); 450nativeVftbl[6] = Marshal.GetFunctionPointerForDelegate(AbiToProjectionVftable.get_Current_0); 451nativeVftbl[7] = Marshal.GetFunctionPointerForDelegate(AbiToProjectionVftable.get_HasCurrent_1); 452nativeVftbl[8] = Marshal.GetFunctionPointerForDelegate(AbiToProjectionVftable.MoveNext_2); 453nativeVftbl[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)

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

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

155IntPtr ptr = System.Runtime.InteropServices.Marshal.SecureStringToBSTR(securePassword); 166System.Runtime.InteropServices.Marshal.ZeroFreeBSTR(ptr);

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

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

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

431if (!Marshal.IsTypeVisibleFromCom(t))

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

993int win32Error = Marshal.GetLastWin32Error(); 1025int win32Error = Marshal.GetLastWin32Error(); 1079int win32Error = Marshal.GetLastWin32Error(); 1091win32Error = Marshal.GetLastWin32Error();

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

164Marshal.ReleaseComObject(composition); 167Marshal.ReleaseComObject(context); 178Marshal.ReleaseComObject(context); 326Marshal.ReleaseComObject(enumCompositionView);

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

1331int requestSize = Marshal.SizeOf(typeof(NativeMethods.RECONVERTSTRING)) + (target.Length * sizeof(short)) + ((_maxSrounding + 1) * sizeof(short) * 2); 1340NativeMethods.RECONVERTSTRING reconv = Marshal.PtrToStructure<NativeMethods.RECONVERTSTRING>(lParam); 1345reconv.dwStrOffset = Marshal.SizeOf(typeof(NativeMethods.RECONVERTSTRING)); // in byte count 1362Marshal.StructureToPtr(reconv, lParam, true); 1375p += Marshal.SizeOf(typeof(NativeMethods.RECONVERTSTRING)); 1376Marshal.Copy(surrounding.ToCharArray(), 0, new IntPtr((void*)p), surrounding.Length); 1502NativeMethods.RECONVERTSTRING reconv = Marshal.PtrToStructure<NativeMethods.RECONVERTSTRING>(lParam);

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

57ppinputscopes = Marshal.AllocCoTaskMem(sizeof(Int32) * count); 66Marshal.WriteInt32(ppinputscopes, offset, (Int32)((InputScopeName)_inputScope.Names[i]).NameValue); 72ppinputscopes = Marshal.AllocCoTaskMem(sizeof(Int32) * 1); 73Marshal.WriteInt32(ppinputscopes, (Int32)InputScopeNameValue.Default); 85ppbstrPhrases = Marshal.AllocCoTaskMem(IntPtr.Size * count); 98pbstr = Marshal.StringToBSTR(((InputScopePhrase)_inputScope.PhraseList[i]).Name); 105Marshal.FreeBSTR(Marshal.ReadIntPtr(ppbstrPhrases, offset)); 111Marshal.WriteIntPtr(ppbstrPhrases , offset, pbstr);

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

77Marshal.ReleaseComObject(optionDescription);

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

616Marshal.ReleaseComObject(_speller.Value);

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

105Marshal.ReleaseComObject(error);

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

123Marshal.ReleaseComObject(Singleton.ComFactory);

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

60Marshal.ReleaseComObject(enumString); 107Marshal.ReleaseComObject(spellingErrors); 165Marshal.ReleaseComObject(iSpellingError); 177Marshal.ReleaseComObject(spellingErrors);

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

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

1547Marshal.ReleaseComObject(threadManager);

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

588Marshal.ReleaseComObject(candString); 654Marshal.ReleaseComObject(CandidateList);

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

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

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

161Marshal.ReleaseComObject(attributeRanges[0]); 180Marshal.ReleaseComObject(attributeRangeEnumerator); 183Marshal.ReleaseComObject(displayAttributeProperty); 233Marshal.ReleaseComObject(catmgr); 257Marshal.ReleaseComObject(dai); 265Marshal.ReleaseComObject(dam);

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

143Marshal.ReleaseComObject(comp); 172Marshal.ReleaseComObject(comp); 241Marshal.ReleaseComObject(context); 245Marshal.ReleaseComObject(textstore.DocumentManager); 340Marshal.ReleaseComObject(context); 378Marshal.ReleaseComObject(_threadManager);

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

89Marshal.ReleaseComObject(outRangesProp[0]); 91Marshal.ReleaseComObject(rangesProp); 94Marshal.ReleaseComObject(outRanges[0]); 96Marshal.ReleaseComObject(ranges); 98Marshal.ReleaseComObject(prop);

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

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

592Marshal.FinalReleaseComObject(_axInstance);

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

414var rcClientArea = Marshal.PtrToStructure<RECT>(lParam); 432Marshal.StructureToPtr(rcClientArea, lParam, false); 577var wp = Marshal.PtrToStructure<WINDOWPOS>(lParam);

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

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

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

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

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

1884cbSize = Marshal.SizeOf(typeof(NONCLIENTMETRICS)) 1897cbSize = Marshal.SizeOf(typeof(NONCLIENTMETRICS)) - sizeof(int) 1943public int cbSize = Marshal.SizeOf(typeof(MONITORINFO)); 2162public int length = Marshal.SizeOf(typeof(WINDOWPLACEMENT)); 2337var filterstruct = new CHANGEFILTERSTRUCT { cbSize = (uint)Marshal.SizeOf(typeof(CHANGEFILTERSTRUCT)) }; 2370IntPtr currArg = Marshal.ReadIntPtr(argv, i * IntPtr.Size); 2371result[i] = Marshal.PtrToStringUni(currArg); 3029var hc = new HIGHCONTRAST { cbSize = Marshal.SizeOf(typeof(HIGHCONTRAST)) }; 3191var dti = new DWM_TIMING_INFO { cbSize = Marshal.SizeOf(typeof(DWM_TIMING_INFO)) };

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

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

System\Windows\SystemParameters.cs (1)

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

System\Windows\Window.cs (5)

3959length = Marshal.SizeOf(typeof(NativeMethods.WINDOWPLACEMENT)) 5223placement.length = Marshal.SizeOf(placement); 5913length = Marshal.SizeOf(typeof(NativeMethods.WINDOWPLACEMENT)) 6001cbSize = Marshal.SizeOf(typeof(NativeMethods.MONITORINFOEX)) 7408cbSize = Marshal.SizeOf(typeof(NativeMethods.MONITORINFOEX))

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

134(uint)Marshal.SizeOf(typeof(UnsafeNativeMethods.QueryInitParams)), 145IntPtr queryInitParamsPtr = Marshal.AllocCoTaskMem(Marshal.SizeOf(queryInitParams)); 155Marshal.StructureToPtr(queryInitParams, queryInitParamsPtr, false /*fDeleteOld*/); 169(uint)Marshal.SizeOf(typeof(UnsafeNativeMethods.OpenQueryWindowParams)), 195Marshal.FreeCoTaskMem(queryInitParamsPtr); 326_ptrToDsObjectNames = Marshal.AllocHGlobal(data.Length); 330Marshal.Copy(data, 0, _ptrToDsObjectNames, data.Length); 334_dsObjectNames = Marshal.PtrToStructure<UnsafeNativeMethods.DsObjectNames>(_ptrToDsObjectNames); 423return Marshal.PtrToStringAuto(nameOffset); 456UnsafeNativeMethods.DsObject dsObject = Marshal.PtrToStructure<UnsafeNativeMethods.DsObject>(offset); 480Marshal.FreeHGlobal(_ptrToDsObjectNames); 525Marshal.SizeOf(typeof(UnsafeNativeMethods.DsObject));

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

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

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

395return GetArrayCapability<T>(capability, readItem, Marshal.SizeOf(typeof(T))); 450result[i] = (uint)Marshal.ReadInt32(baseAddr, offset); 476result[i] = Marshal.ReadInt16(baseAddr, offset); 502int x = Marshal.ReadInt32(baseAddr, offset); 503int y = Marshal.ReadInt32(baseAddr, offset + (itemByteSize / 2)); 530int w = Marshal.ReadInt32(baseAddr, offset); 531int h = Marshal.ReadInt32(baseAddr, offset + (itemByteSize / 2)); 559string str = Marshal.PtrToStringUni(strAddr, itemByteSize / 2);

PrintConfig\FallbackPTProvider.cs (9)

58throw new PrintQueueException(Marshal.GetLastWin32Error(), "PrintConfig.Provider.BindFail", deviceName); 752IntPtr pPrinterName = Marshal.ReadIntPtr(ptr, 1 * IntPtr.Size); 755PRINTER_INFO_2.pPrinterName = Marshal.PtrToStringUni(pPrinterName); 759IntPtr pPortName = Marshal.ReadIntPtr(ptr, 3 * IntPtr.Size); 762PRINTER_INFO_2.pPortName = Marshal.PtrToStringUni(pPortName); 766IntPtr pDriverName = Marshal.ReadIntPtr(ptr, 4 * IntPtr.Size); 769PRINTER_INFO_2.pDriverName = Marshal.PtrToStringUni(pDriverName); 773IntPtr pDevMode = Marshal.ReadIntPtr(ptr, 7 * IntPtr.Size); 818IntPtr pDevMode = Marshal.ReadIntPtr(pPrinterBuffer.Handle.DangerousGetHandle());

PrintConfig\PTProvider.cs (7)

391IntPtr umDevMode = Marshal.AllocCoTaskMem(devMode.Length); 395Marshal.Copy(devMode, 0, umDevMode, devMode.Length); 425Marshal.FreeCoTaskMem(umDevMode); 477Marshal.Copy(umDevMode, devMode, 0, (int)umDevModeLen); 602Marshal.ReleaseComObject(result); 795Marshal.ThrowExceptionForHR((int)hResult); 805Marshal.ReleaseComObject(stream);

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

466startInfo.cb = Marshal.SizeOf(startInfo); 500logger.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)

305public 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)

70return Marshal.PtrToStringUTF8(ptr); 76return 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)

172string? 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)

70return Marshal.PtrToStringUTF8(ptr); 76return 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)

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

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

302string? 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)

305public 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)

95native.m_pProviderName = (char*)Marshal.StringToCoTaskMemUni(managed.ProviderName); 98native.m_pFilterData = (char*)Marshal.StringToCoTaskMemUni(managed.FilterData); 105Marshal.FreeCoTaskMem((IntPtr)m_pProviderName); 109Marshal.FreeCoTaskMem((IntPtr)m_pFilterData); 120Span<EventPipeProviderConfigurationNative> providersNative = new Span<EventPipeProviderConfigurationNative>((void*)Marshal.AllocCoTaskMem(sizeof(EventPipeProviderConfigurationNative) * providers.Length), providers.Length); 145Marshal.FreeCoTaskMem((IntPtr)providersNativePointer);

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

1361Marshal.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)

39if (type == GCHandleType.Pinned && !Marshal.IsPinnable(value)) 95if (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 (1)

31int errorCode = Marshal.GetLastPInvokeError();

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

32int errorCode = 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)

2113Marshal.ThrowExceptionForHR(offsetMaybe, new IntPtr(-1)); 2131Marshal.ThrowExceptionForHR(offsetMaybe, new IntPtr(-1)); 2149Marshal.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 (2)

97errorCode = Marshal.GetLastPInvokeError(); 107errorCode = mutexHandle.IsInvalid ? Marshal.GetLastPInvokeError() : Interop.Errors.ERROR_SUCCESS;

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

149Marshal.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)

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

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)

70return Marshal.PtrToStringUTF8(ptr); 76return 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)

365int lastWin32Error = Marshal.GetLastPInvokeError(); 407Marshal.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)

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

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

173cbSize = 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)

858throw new Win32Exception(Marshal.GetLastWin32Error(), SR.Win32SetParentFailed); 1321Marshal.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); 6998throw new Win32Exception(Marshal.GetLastWin32Error(), SR.Win32SetParentFailed); 9273throw new Win32Exception(Marshal.GetLastWin32Error(), SR.Win32SetParentFailed); 9477throw Marshal.GetExceptionForHR((int)hr)!; 9486throw Marshal.GetExceptionForHR((int)hr)!; 10213throw new Win32Exception(Marshal.GetLastWin32Error(), SR.Win32SetParentFailed); 10229throw 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)

4085if (obj is not null && !Marshal.IsComObject(obj)) 4319_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)

1844tvis.item.pszText = (char*)Marshal.StringToHGlobalUni(_text); 1894Marshal.FreeCoTaskMem((nint)tvis.item.pszText.Value); 2150item.pszText = (char*)Marshal.StringToHGlobalUni(_text); 2188Marshal.FreeCoTaskMem((nint)item.pszText.Value);

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

482if (!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)

32_functionPointer = (delegate* unmanaged[Stdcall]<HWND, uint, WPARAM, LPARAM, nuint>)(void*)Marshal.GetFunctionPointerForDelegate(_hookProc); 206nint 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)

782Marshal.Copy(bytes, 0, m.LParamInternal, bytes.Length); 783Marshal.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)

706Runtime.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)

69Marshal.GetNativeVariantForObject(value, (nint)(void*)&variant);

System\Windows\Forms\ClipboardTests.cs (2)

655SetClipboardData((uint)CLIPBOARD_FORMAT.CF_UNICODETEXT, (HANDLE)Marshal.StringToHGlobalUni(testString)); 1043Marshal.Copy((nint)buffer, bytes, 0, size);

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

1929Marshal.ThrowExceptionForHR(QueryGetData(ref format));

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

62unionmember = Marshal.GetIUnknownForObject(iStream)

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

3346Marshal.Copy(GetSelResult, 0, m.LParam, GetSelResult.Length);

System\Windows\Forms\MessageTests.cs (4)

185IntPtr ptr = Marshal.AllocHGlobal(Marshal.SizeOf<TestStruct>()); 193Marshal.StructureToPtr(original, ptr, fDeleteOld: false); 205Marshal.FreeHGlobal(ptr);

System\Windows\Forms\RichTextBoxTests.cs (11)

10223IntPtr ptr = Marshal.AllocCoTaskMem(100); 10226Marshal.WriteInt32(ptr, IntPtr.Size * 2, (int)PInvoke.EN_PROTECTED); 10227Marshal.WriteInt32(ptr, IntPtr.Size * 2 + IntPtr.Size, (int)PInvokeCore.EM_SETCHARFORMAT); 10228Marshal.WriteIntPtr(ptr, IntPtr.Size * 2 + IntPtr.Size + 4 + IntPtr.Size, (IntPtr)(&format)); 10243Marshal.FreeCoTaskMem(ptr); 10459IntPtr ptr = Marshal.AllocCoTaskMem(100); 10462Marshal.WriteInt32(ptr, IntPtr.Size * 2, (int)PInvoke.EN_PROTECTED); 10463Marshal.WriteInt32(ptr, IntPtr.Size * 2 + IntPtr.Size, (int)PInvokeCore.EM_SETCHARFORMAT); 10464Marshal.WriteIntPtr(ptr, IntPtr.Size * 2 + IntPtr.Size + 4 + IntPtr.Size, (IntPtr)(&format)); 10482Marshal.FreeCoTaskMem(ptr); 11066int lastWin32Error = Marshal.GetLastWin32Error();

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

TextBoxBaseTests.cs (2)

6141yield return new object[] { Marshal.GetIUnknownForObject(new object()) }; 6172IntPtr 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>());

MS\Internal\Automation\HwndProxyElementProvider.cs (5)

311length = Marshal.SizeOf(typeof(UnsafeNativeMethods.WINDOWPLACEMENT)) 697length = Marshal.SizeOf(typeof(UnsafeNativeMethods.WINDOWPLACEMENT)) 811length = Marshal.SizeOf(typeof(UnsafeNativeMethods.WINDOWPLACEMENT)) 1909int lastWin32Error = Marshal.GetLastWin32Error(); 1934int lastWin32Error = Marshal.GetLastWin32Error();

MS\Internal\Automation\input.cs (2)

67Misc.SendInput(1, ref ki, Marshal.SizeOf(ki)); 86Misc.SendInput(1, ref ki, Marshal.SizeOf(ki));

MS\Internal\Automation\Misc.cs (29)

MS\Internal\Automation\ProxyManager.cs (2)

225int lastWin32Error = Marshal.GetLastWin32Error(); 239int lastWin32Error = Marshal.GetLastWin32Error();

MS\Internal\Automation\UiaCoreApi.cs (16)

140IntPtr dataStart = Marshal.AllocCoTaskMem((properties.Length + patterns.Length) * sizeof(int)); 166Marshal.FreeCoTaskMem(_pProperties); 639UiaEventArgs args = Marshal.PtrToStructure<UiaEventArgs>(argsAddr); 657UiaPropertyChangedEventArgs pcargs = Marshal.PtrToStructure<UiaPropertyChangedEventArgs>(argsAddr); 671UiaStructureChangedEventArgs scargs = Marshal.PtrToStructure<UiaStructureChangedEventArgs>(argsAddr); 678UiaAsyncContentLoadedEventArgs aclargs = Marshal.PtrToStructure<UiaAsyncContentLoadedEventArgs>(argsAddr); 684UiaWindowClosedEventArgs wcargs = Marshal.PtrToStructure<UiaWindowClosedEventArgs>(argsAddr); 691UiaNotificationEventArgs nargs = Marshal.PtrToStructure<UiaNotificationEventArgs>(argsAddr); 693Marshal.PtrToStringUni(nargs._displayString), Marshal.PtrToStringUni(nargs._activityId)); 698UiaActiveTextPositionChangedEventArgs atpcargs = Marshal.PtrToStructure<UiaActiveTextPositionChangedEventArgs>(argsAddr); 1127&& !Marshal.IsComObject(arr[1]) 1140IntPtr errorInfoAsIntPtr = Marshal.GetIUnknownForObject(errorInfo); 1143Marshal.Release(errorInfoAsIntPtr); 1146Marshal.ThrowExceptionForHR(hr); 1205Marshal.ThrowExceptionForHR(hr);

System\Windows\Automation\Condition.cs (5)

29Marshal.FreeCoTaskMem(handle); 39int size = Marshal.SizeOf(uiaCondition); 44IntPtr mem = Marshal.AllocCoTaskMem(size); 47Marshal.StructureToPtr(uiaCondition, sh.handle, false); 61IntPtr mem = Marshal.AllocCoTaskMem(conditions.Length * IntPtr.Size);

MS\Internal\AutomationProxies\CommonXSendMessage.cs (67)

MS\Internal\AutomationProxies\Input.cs (5)

122if( UnsafeNativeMethods.SendInput( 1, ref mi, Marshal.SizeOf(mi) ) == 0 ) 123throw new Win32Exception(Marshal.GetLastWin32Error()); 147if( UnsafeNativeMethods.SendInput( 1, ref ki, Marshal.SizeOf(ki) ) == 0 ) 148throw new Win32Exception(Marshal.GetLastWin32Error()); 171Misc.SendInput(1, ref ki, Marshal.SizeOf(ki));

MS\Internal\AutomationProxies\Misc.cs (59)

MS\Internal\AutomationProxies\SafeCoTaskMem.cs (4)

19SetHandle(Marshal.AllocCoTaskMem(length * sizeof (char))); 24return Marshal.PtrToStringAuto(handle); 30return Marshal.PtrToStringUni(handle, length); 35Marshal.FreeCoTaskMem(handle);

MS\Internal\AutomationProxies\WindowsAltTab.cs (2)

237altTabInfo.cbSize = (uint)Marshal.SizeOf(typeof(UnsafeNativeMethods.ALTTABINFO)); 247int lastWin32Error = Marshal.GetLastWin32Error();

MS\Internal\AutomationProxies\WindowsEditBox.cs (2)

554int cb = Marshal.SizeOf(typeof(NativeMethods.LOGFONT)); 707cbSize = System.Runtime.InteropServices.Marshal.SizeOf(typeof(NativeMethods.ScrollInfo)),

MS\Internal\AutomationProxies\WindowsHyperlink.cs (3)

212bGetItemResult = XSendMessage.XSend(_hwnd, NativeMethods.LM_HITTEST, IntPtr.Zero, new IntPtr(&HitTestInfo), Marshal.SizeOf(HitTestInfo.GetType())); 396return XSendMessage.XSend(_hwnd, NativeMethods.LM_SETITEM, IntPtr.Zero, new IntPtr(&linkItem), Marshal.SizeOf(linkItem.GetType())); 493bGetItemResult = XSendMessage.XSend(_hwnd, NativeMethods.LM_HITTEST, IntPtr.Zero, new IntPtr(&HitTestInfo), Marshal.SizeOf(HitTestInfo.GetType()));

MS\Internal\AutomationProxies\WindowsListView.cs (7)

1270if (XSendMessage.XSend(hwnd, NativeMethods.LVM_GETITEMRECT, new IntPtr(item), new IntPtr(location), Marshal.SizeOf(itemRectangle.GetType()))) 1421result = XSendMessage.XSendGetIndex(hwnd, NativeMethods.LVM_SUBITEMHITTEST, IntPtr.Zero, new IntPtr(&hitTestNative), Marshal.SizeOf(hitTestNative.GetType())); 1430result = XSendMessage.XSendGetIndex(hwnd, NativeMethods.LVM_SUBITEMHITTEST, IntPtr.Zero, new IntPtr(&hitTestNative), Marshal.SizeOf(hitTestNative.GetType())); 1494if (XSendMessage.XSend(hwnd, NativeMethods.LVM_GETSUBITEMRECT, new IntPtr(item), new IntPtr(location), Marshal.SizeOf(itemRectangle.GetType()))) 1667scrollBarInfo.cbSize = Marshal.SizeOf(scrollBarInfo.GetType()); 1678si.cbSize = Marshal.SizeOf (si.GetType ()); 1795if (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)

387while (XSendMessage.XSend (hwnd, NativeMethods.LVM_GETNEXTITEMINDEX, new IntPtr(&ii), flags, Marshal.SizeOf(ii.GetType()))) 391groupInfo.Init(Marshal.SizeOf(typeof(NativeMethods.LVGROUP_V6))); 394bool lresult = XSendMessage.XSend(hwnd, NativeMethods.LVM_GETGROUPINFOBYINDEX, new IntPtr(ii.iGroup), new IntPtr(&groupInfo), Marshal.SizeOf(typeof(NativeMethods.LVGROUP_V6))); 704new IntPtr(_groupID), new IntPtr(&rect), Marshal.SizeOf(rect.GetType())); 815sbi.cbSize = Marshal.SizeOf(sbi.GetType());

MS\Internal\AutomationProxies\WindowsListViewGroupSubsetLink.cs (3)

78XSendMessage.XSend(_hwnd, NativeMethods.LVM_GETGROUPRECT, new IntPtr(0), new IntPtr(&rect), Marshal.SizeOf(rect.GetType())); 89groupInfo.Init(Marshal.SizeOf(typeof(NativeMethods.LVGROUP_V6))); 106group.Init(Marshal.SizeOf(typeof(NativeMethods.LVGROUP_V6)));

MS\Internal\AutomationProxies\WindowsListViewItem.cs (2)

134if (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)

57si.cbSize = Marshal.SizeOf (si.GetType ());

MS\Internal\AutomationProxies\WindowsMenu.cs (6)

505mbi.cbSize = Marshal.SizeOf(mbi.GetType()); 1887menuItemInfo.cbSize = Marshal.SizeOf(menuItemInfo.GetType()); 1902menuItemInfo.cbSize = Marshal.SizeOf (menuItemInfo.GetType ()); 1946menuItemInfo.cbSize = Marshal.SizeOf(menuItemInfo.GetType()); 2553menuItemInfo.cbSize = Marshal.SizeOf(menuItemInfo.GetType()); 2594int readSize = Marshal.SizeOf(msaaMenuInfo.GetType());

MS\Internal\AutomationProxies\WindowsRebar.cs (3)

207return XSendMessage.XSendGetIndex(_hwnd, NativeMethods.RB_HITTEST, IntPtr.Zero, new IntPtr(&rbHitTestInfo), Marshal.SizeOf(rbHitTestInfo.GetType())); 400if (!XSendMessage.XSend(hwnd, NativeMethods.RB_GETRECT, new IntPtr(item), new IntPtr(&rectW32), Marshal.SizeOf(rectW32.GetType()), XSendMessage.ErrorValue.Zero)) 436if (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)

1234Marshal.ThrowExceptionForHR(hr);

MS\Internal\AutomationProxies\WindowsScroll.cs (6)

128sbi.cbSize = Marshal.SizeOf(sbi.GetType()); 144si.cbSize = Marshal.SizeOf (si.GetType ()); 196si.cbSize = Marshal.SizeOf (si.GetType ()); 251si.cbSize = Marshal.SizeOf (si.GetType ()); 292si.cbSize = Marshal.SizeOf(si.GetType ()); 368si.cbSize = Marshal.SizeOf (si.GetType ());

MS\Internal\AutomationProxies\WindowsScrollBar.cs (8)

136sbi.cbSize = Marshal.SizeOf (sbi.GetType ()); 432si.cbSize = Marshal.SizeOf (si.GetType ()); 446sbi.cbSize = Marshal.SizeOf (sbi.GetType ()); 520sbi.cbSize = Marshal.SizeOf (sbi.GetType ()); 573si.cbSize = Marshal.SizeOf (si.GetType ()); 626si.cbSize = Marshal.SizeOf (si.GetType ()); 712sbi.cbSize = Marshal.SizeOf (sbi.GetType ()); 727sbi.cbSize = Marshal.SizeOf(sbi.GetType());

MS\Internal\AutomationProxies\WindowsScrollBarBits.cs (3)

206si.cbSize = Marshal.SizeOf (si.GetType ()); 224sbi.cbSize = Marshal.SizeOf (sbi.GetType ()); 543si.cbSize = Marshal.SizeOf (si.GetType ());

MS\Internal\AutomationProxies\WindowsSlider.cs (2)

461XSendMessage.XSend(hwnd, NativeMethods.TBM_GETCHANNELRECT, IntPtr.Zero, new IntPtr(&rcChannel), Marshal.SizeOf(rcChannel.GetType()), XSendMessage.ErrorValue.NoCheck); 473XSendMessage.XSend(hwnd, NativeMethods.TBM_GETTHUMBRECT, IntPtr.Zero, new IntPtr(&rcThumb), Marshal.SizeOf(rcThumb.GetType()), XSendMessage.ErrorValue.NoCheck);

MS\Internal\AutomationProxies\WindowsSysHeader.cs (2)

162index = XSendMessage.XSendGetIndex(_hwnd, NativeMethods.HDM_HITTEST, IntPtr.Zero, new IntPtr(&HitTestInfo), Marshal.SizeOf(HitTestInfo.GetType())); 569result = 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)

277index = XSendMessage.XSendGetIndex(_hwnd, NativeMethods.TCM_HITTEST, IntPtr.Zero, new IntPtr(&hti), Marshal.SizeOf(hti.GetType())); 654result = XSendMessage.XSend(hwnd, NativeMethods.TCM_GETITEMRECT, new IntPtr(count - 1), new IntPtr(&rectW32), Marshal.SizeOf(rectW32.GetType()), XSendMessage.ErrorValue.Zero); 1273if (!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)

556if (!XSendMessage.XSend(hwnd, NativeMethods.TVM_GETITEMRECT, partialDisplay, rectangle, Marshal.SizeOf(rc.GetType()))) 936if (Marshal.SizeOf(_hItem.GetType()) > sizeof(int)) 1593int readSize = Marshal.SizeOf(ent.GetType());

MS\Win32\NativeMethods.cs (1)

1487internal static int comboboxInfoSize = Marshal.SizeOf(typeof(NativeMethods.COMBOBOXINFO));

MS\Win32\UnsafeNativeMethods.cs (2)

379error = Marshal.GetLastWin32Error(); 386error = Marshal.GetLastWin32Error();

MS\Internal\Automation\UiaCoreProviderApi.cs (1)

106Marshal.ThrowExceptionForHR(hr, (IntPtr)(-1));

MS\Internal\Automation\UiaCoreTypesApi.cs (1)

103Marshal.ThrowExceptionForHR(hr, (IntPtr)(-1));

src\Microsoft.DotNet.Wpf\src\Shared\MS\Win32\NativeMethodsCLR.cs (35)

1526return Marshal.SizeOf(typeof(MONITORINFOEX)); 1539return Marshal.SizeOf(typeof(TRACKMOUSEEVENT)); 1594return Marshal.SizeOf(typeof(NONCLIENTMETRICS)); 1609return Marshal.SizeOf(typeof(ICONMETRICS)); 1739return Marshal.SizeOf(typeof(MENUITEMINFO_T)); 1786return Marshal.SizeOf(typeof(OPENFILENAME_I)); 1965return Marshal.SizeOf(typeof(tagCONTROLINFO)); 1992Marshal.Release(this.data1); 2026IntPtr mem = Marshal.AllocCoTaskMem(16); 2027Marshal.WriteInt16(mem, vt); 2028Marshal.WriteInt16(mem, 2, reserved1); 2029Marshal.WriteInt16(mem, 4, reserved2); 2030Marshal.WriteInt16(mem, 6, reserved3); 2031Marshal.WriteInt32(mem, 8, (int) data1); 2032Marshal.WriteInt32(mem, 12, (int) data2); 2050val = (IntPtr) Marshal.ReadByte(val); 2056val = (IntPtr) Marshal.ReadByte(val); 2063val = (IntPtr) Marshal.ReadInt16(val); 2069val = (IntPtr) Marshal.ReadInt16(val); 2076val = (IntPtr) Marshal.ReadInt32(val); 2083val = (IntPtr) Marshal.ReadInt32(val); 2090longVal = Marshal.ReadInt64(val); 2124return Marshal.PtrToStringUni(val); 2127return Marshal.PtrToStringAnsi(val); 2132return Marshal.GetObjectForIUnknown(val); 2146VARIANT varStruct = Marshal.PtrToStructure<VARIANT>(val); 2150Guid guid = Marshal.PtrToStructure<Guid>(val); 2184return Marshal.ReadIntPtr(value); 2306if (Marshal.SystemDefaultCharSize == 1) 2337IntPtr result = Marshal.AllocCoTaskMem(buffer.Length); 2338Marshal.Copy(buffer, 0, result, buffer.Length); 2361Marshal.Copy(ptr, buffer, 0, buffer.Length); 2395IntPtr result = Marshal.AllocCoTaskMem(buffer.Length * 2); 2396Marshal.Copy(buffer, 0, result, buffer.Length); 2418Marshal.Copy(ptr, buffer, 0, buffer.Length);

src\Microsoft.DotNet.Wpf\src\Shared\MS\Win32\NativeMethodsOther.cs (5)

87return Marshal.SizeOf(typeof(OSVERSIONINFOEX)); 158return Marshal.SizeOf(typeof(DOCHOSTUIINFO)); 514return Marshal.SizeOf(typeof(BITMAPINFO)); 545return Marshal.SizeOf(typeof(SECURITY_ATTRIBUTES)); 1084return Marshal.SizeOf(typeof(ANIMATIONINFO));

src\Microsoft.DotNet.Wpf\src\Shared\MS\Win32\UnsafeNativeMethodsCLR.cs (18)

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

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

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

466startInfo.cb = Marshal.SizeOf(startInfo); 500logger.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)

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

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

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

System\Windows\Integration\WindowsFormsHost.cs (1)

975throw 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);