netcore/System.Private.CoreLib/shared/System/Runtime/InteropServices/Marshal.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System.Security;
   6 using System.Reflection;
   7 using System.Runtime.CompilerServices;
   8 using System.Text;
   9
  10 using Internal.Runtime.CompilerServices;
  11 using System.Diagnostics.CodeAnalysis;
  12
  13 #pragma warning disable SA1121 // explicitly using type aliases instead of built-in types
  14 #if BIT64
  15 using nuint = System.UInt64;
  16 #else
  17 using nuint = System.UInt32;
  18 #endif
  19
  20 namespace System.Runtime.InteropServices
  21 {
  22     /// <summary>
  23     /// This class contains methods that are mainly used to marshal between unmanaged
  24     /// and managed types.
  25     /// </summary>
  26     public static partial class Marshal
  27     {
  28         /// <summary>
  29         /// The default character size for the system. This is always 2 because
  30         /// the framework only runs on UTF-16 systems.
  31         /// </summary>
  32         public static readonly int SystemDefaultCharSize = 2;
  33
  34         /// <summary>
  35         /// The max DBCS character size for the system.
  36         /// </summary>
  37         public static readonly int SystemMaxDBCSCharSize = GetSystemMaxDBCSCharSize();
  38
  39         public static IntPtr AllocHGlobal(int cb) => AllocHGlobal((IntPtr)cb);
  40
  41         public static unsafe string? PtrToStringAnsi(IntPtr ptr)
  42         {
  43             if (ptr == IntPtr.Zero || IsWin32Atom(ptr))
  44             {
  45                 return null;
  46             }
  47
  48             return new string((sbyte*)ptr);
  49         }
  50
  51         public static unsafe string PtrToStringAnsi(IntPtr ptr, int len)
  52         {
  53             if (ptr == IntPtr.Zero)
  54             {
  55                 throw new ArgumentNullException(nameof(ptr));
  56             }
  57             if (len < 0)
  58             {
  59                 throw new ArgumentOutOfRangeException(nameof(len), len, SR.ArgumentOutOfRange_NeedNonNegNum);
  60             }
  61
  62             return new string((sbyte*)ptr, 0, len);
  63         }
  64
  65         public static unsafe string? PtrToStringUni(IntPtr ptr)
  66         {
  67             if (ptr == IntPtr.Zero || IsWin32Atom(ptr))
  68             {
  69                 return null;
  70             }
  71
  72             return new string((char*)ptr);
  73         }
  74
  75         public static unsafe string PtrToStringUni(IntPtr ptr, int len)
  76         {
  77             if (ptr == IntPtr.Zero)
  78             {
  79                 throw new ArgumentNullException(nameof(ptr));
  80             }
  81             if (len < 0)
  82             {
  83                 throw new ArgumentOutOfRangeException(nameof(len), len, SR.ArgumentOutOfRange_NeedNonNegNum);
  84             }
  85
  86             return new string((char*)ptr, 0, len);
  87         }
  88
  89         public static unsafe string? PtrToStringUTF8(IntPtr ptr)
  90         {
  91             if (ptr == IntPtr.Zero || IsWin32Atom(ptr))
  92             {
  93                 return null;
  94             }
  95
  96             int nbBytes = string.strlen((byte*)ptr);
  97             return string.CreateStringFromEncoding((byte*)ptr, nbBytes, Encoding.UTF8);
  98         }
  99
 100         public static unsafe string PtrToStringUTF8(IntPtr ptr, int byteLen)
 101         {
 102             if (ptr == IntPtr.Zero)
 103             {
 104                 throw new ArgumentNullException(nameof(ptr));
 105             }
 106             if (byteLen < 0)
 107             {
 108                 throw new ArgumentOutOfRangeException(nameof(byteLen), byteLen, SR.ArgumentOutOfRange_NeedNonNegNum);
 109             }
 110
 111             return string.CreateStringFromEncoding((byte*)ptr, byteLen, Encoding.UTF8);
 112         }
 113
 114         public static int SizeOf(object structure)
 115         {
 116             if (structure is null)
 117             {
 118                 throw new ArgumentNullException(nameof(structure));
 119             }
 120
 121             return SizeOfHelper(structure.GetType(), throwIfNotMarshalable: true);
 122         }
 123
 124         public static int SizeOf<T>(T structure)
 125         {
 126             if (structure is null)
 127             {
 128                 throw new ArgumentNullException(nameof(structure));
 129             }
 130
 131             return SizeOfHelper(structure.GetType(), throwIfNotMarshalable: true);
 132         }
 133
 134         public static int SizeOf(Type t)
 135         {
 136             if (t is null)
 137             {
 138                 throw new ArgumentNullException(nameof(t));
 139             }
 140             if (!t.IsRuntimeImplemented())
 141             {
 142                 throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(t));
 143             }
 144             if (t.IsGenericType)
 145             {
 146                 throw new ArgumentException(SR.Argument_NeedNonGenericType, nameof(t));
 147             }
 148
 149             return SizeOfHelper(t, throwIfNotMarshalable: true);
 150         }
 151
 152         public static int SizeOf<T>() => SizeOf(typeof(T));
 153
 154         /// <summary>
 155         /// IMPORTANT NOTICE: This method does not do any verification on the array.
 156         /// It must be used with EXTREME CAUTION since passing in invalid index or
 157         /// an array that is not pinned can cause unexpected results.
 158         /// </summary>
 159         public static unsafe IntPtr UnsafeAddrOfPinnedArrayElement(Array arr, int index)
 160         {
 161             if (arr is null)
 162                 throw new ArgumentNullException(nameof(arr));
 163
 164             void* pRawData = Unsafe.AsPointer(ref arr.GetRawArrayData());
 165             return (IntPtr)((byte*)pRawData + (uint)index * (nuint)arr.GetElementSize());
 166         }
 167
 168         public static unsafe IntPtr UnsafeAddrOfPinnedArrayElement<T>(T[] arr, int index)
 169         {
 170             if (arr is null)
 171                 throw new ArgumentNullException(nameof(arr));
 172
 173             void* pRawData = Unsafe.AsPointer(ref arr.GetRawSzArrayData());
 174             return (IntPtr)((byte*)pRawData + (uint)index * (nuint)Unsafe.SizeOf<T>());
 175         }
 176
 177         public static IntPtr OffsetOf<T>(string fieldName) => OffsetOf(typeof(T), fieldName);
 178
 179         public static void Copy(int[] source, int startIndex, IntPtr destination, int length)
 180         {
 181             CopyToNative(source, startIndex, destination, length);
 182         }
 183
 184         public static void Copy(char[] source, int startIndex, IntPtr destination, int length)
 185         {
 186             CopyToNative(source, startIndex, destination, length);
 187         }
 188
 189         public static void Copy(short[] source, int startIndex, IntPtr destination, int length)
 190         {
 191             CopyToNative(source, startIndex, destination, length);
 192         }
 193
 194         public static void Copy(long[] source, int startIndex, IntPtr destination, int length)
 195         {
 196             CopyToNative(source, startIndex, destination, length);
 197         }
 198
 199         public static void Copy(float[] source, int startIndex, IntPtr destination, int length)
 200         {
 201             CopyToNative(source, startIndex, destination, length);
 202         }
 203
 204         public static void Copy(double[] source, int startIndex, IntPtr destination, int length)
 205         {
 206             CopyToNative(source, startIndex, destination, length);
 207         }
 208
 209         public static void Copy(byte[] source, int startIndex, IntPtr destination, int length)
 210         {
 211             CopyToNative(source, startIndex, destination, length);
 212         }
 213
 214         public static void Copy(IntPtr[] source, int startIndex, IntPtr destination, int length)
 215         {
 216             CopyToNative(source, startIndex, destination, length);
 217         }
 218
 219         private static unsafe void CopyToNative<T>(T[] source, int startIndex, IntPtr destination, int length)
 220         {
 221             if (source is null)
 222                 throw new ArgumentNullException(nameof(source));
 223             if (destination == IntPtr.Zero)
 224                 throw new ArgumentNullException(nameof(destination));
 225
 226             // The rest of the argument validation is done by CopyTo
 227
 228             new Span<T>(source, startIndex, length).CopyTo(new Span<T>((void*)destination, length));
 229         }
 230
 231         public static void Copy(IntPtr source, int[] destination, int startIndex, int length)
 232         {
 233             CopyToManaged(source, destination, startIndex, length);
 234         }
 235
 236         public static void Copy(IntPtr source, char[] destination, int startIndex, int length)
 237         {
 238             CopyToManaged(source, destination, startIndex, length);
 239         }
 240
 241         public static void Copy(IntPtr source, short[] destination, int startIndex, int length)
 242         {
 243             CopyToManaged(source, destination, startIndex, length);
 244         }
 245
 246         public static void Copy(IntPtr source, long[] destination, int startIndex, int length)
 247         {
 248             CopyToManaged(source, destination, startIndex, length);
 249         }
 250
 251         public static void Copy(IntPtr source, float[] destination, int startIndex, int length)
 252         {
 253             CopyToManaged(source, destination, startIndex, length);
 254         }
 255
 256         public static void Copy(IntPtr source, double[] destination, int startIndex, int length)
 257         {
 258             CopyToManaged(source, destination, startIndex, length);
 259         }
 260
 261         public static void Copy(IntPtr source, byte[] destination, int startIndex, int length)
 262         {
 263             CopyToManaged(source, destination, startIndex, length);
 264         }
 265
 266         public static void Copy(IntPtr source, IntPtr[] destination, int startIndex, int length)
 267         {
 268             CopyToManaged(source, destination, startIndex, length);
 269         }
 270
 271         private static unsafe void CopyToManaged<T>(IntPtr source, T[] destination, int startIndex, int length)
 272         {
 273             if (source == IntPtr.Zero)
 274                 throw new ArgumentNullException(nameof(source));
 275             if (destination is null)
 276                 throw new ArgumentNullException(nameof(destination));
 277             if (startIndex < 0)
 278                 throw new ArgumentOutOfRangeException(nameof(startIndex), SR.ArgumentOutOfRange_StartIndex);
 279             if (length < 0)
 280                 throw new ArgumentOutOfRangeException(nameof(length), SR.ArgumentOutOfRange_NeedNonNegNum);
 281
 282             // The rest of the argument validation is done by CopyTo
 283
 284             new Span<T>((void*)source, length).CopyTo(new Span<T>(destination, startIndex, length));
 285         }
 286
 287         public static unsafe byte ReadByte(IntPtr ptr, int ofs)
 288         {
 289             try
 290             {
 291                 byte* addr = (byte*)ptr + ofs;
 292                 return *addr;
 293             }
 294             catch (NullReferenceException)
 295             {
 296                 // this method is documented to throw AccessViolationException on any AV
 297                 throw new AccessViolationException();
 298             }
 299         }
 300
 301         public static byte ReadByte(IntPtr ptr) => ReadByte(ptr, 0);
 302
 303         public static unsafe short ReadInt16(IntPtr ptr, int ofs)
 304         {
 305             try
 306             {
 307                 byte* addr = (byte*)ptr + ofs;
 308                 if ((unchecked((int)addr) & 0x1) == 0)
 309                 {
 310                     // aligned read
 311                     return *((short*)addr);
 312                 }
 313                 else
 314                 {
 315                     return Unsafe.ReadUnaligned<short>(addr);
 316                 }
 317             }
 318             catch (NullReferenceException)
 319             {
 320                 // this method is documented to throw AccessViolationException on any AV
 321                 throw new AccessViolationException();
 322             }
 323         }
 324
 325         public static short ReadInt16(IntPtr ptr) => ReadInt16(ptr, 0);
 326
 327         public static unsafe int ReadInt32(IntPtr ptr, int ofs)
 328         {
 329             try
 330             {
 331                 byte* addr = (byte*)ptr + ofs;
 332                 if ((unchecked((int)addr) & 0x3) == 0)
 333                 {
 334                     // aligned read
 335                     return *((int*)addr);
 336                 }
 337                 else
 338                 {
 339                     return Unsafe.ReadUnaligned<int>(addr);
 340                 }
 341             }
 342             catch (NullReferenceException)
 343             {
 344                 // this method is documented to throw AccessViolationException on any AV
 345                 throw new AccessViolationException();
 346             }
 347         }
 348
 349         public static int ReadInt32(IntPtr ptr) => ReadInt32(ptr, 0);
 350
 351         public static IntPtr ReadIntPtr(object ptr, int ofs)
 352         {
 353 #if BIT64
 354             return (IntPtr)ReadInt64(ptr, ofs);
 355 #else // 32
 356             return (IntPtr)ReadInt32(ptr, ofs);
 357 #endif
 358         }
 359
 360         public static IntPtr ReadIntPtr(IntPtr ptr, int ofs)
 361         {
 362 #if BIT64
 363             return (IntPtr)ReadInt64(ptr, ofs);
 364 #else // 32
 365             return (IntPtr)ReadInt32(ptr, ofs);
 366 #endif
 367         }
 368
 369         public static IntPtr ReadIntPtr(IntPtr ptr) => ReadIntPtr(ptr, 0);
 370
 371         public static unsafe long ReadInt64(IntPtr ptr, int ofs)
 372         {
 373             try
 374             {
 375                 byte* addr = (byte*)ptr + ofs;
 376                 if ((unchecked((int)addr) & 0x7) == 0)
 377                 {
 378                     // aligned read
 379                     return *((long*)addr);
 380                 }
 381                 else
 382                 {
 383                     return Unsafe.ReadUnaligned<long>(addr);
 384                 }
 385             }
 386             catch (NullReferenceException)
 387             {
 388                 // this method is documented to throw AccessViolationException on any AV
 389                 throw new AccessViolationException();
 390             }
 391         }
 392
 393         public static long ReadInt64(IntPtr ptr) => ReadInt64(ptr, 0);
 394
 395         public static unsafe void WriteByte(IntPtr ptr, int ofs, byte val)
 396         {
 397             try
 398             {
 399                 byte* addr = (byte*)ptr + ofs;
 400                 *addr = val;
 401             }
 402             catch (NullReferenceException)
 403             {
 404                 // this method is documented to throw AccessViolationException on any AV
 405                 throw new AccessViolationException();
 406             }
 407         }
 408
 409         public static void WriteByte(IntPtr ptr, byte val) => WriteByte(ptr, 0, val);
 410
 411         public static unsafe void WriteInt16(IntPtr ptr, int ofs, short val)
 412         {
 413             try
 414             {
 415                 byte* addr = (byte*)ptr + ofs;
 416                 if ((unchecked((int)addr) & 0x1) == 0)
 417                 {
 418                     // aligned write
 419                     *((short*)addr) = val;
 420                 }
 421                 else
 422                 {
 423                     Unsafe.WriteUnaligned(addr, val);
 424                 }
 425             }
 426             catch (NullReferenceException)
 427             {
 428                 // this method is documented to throw AccessViolationException on any AV
 429                 throw new AccessViolationException();
 430             }
 431         }
 432
 433         public static void WriteInt16(IntPtr ptr, short val) => WriteInt16(ptr, 0, val);
 434
 435         public static void WriteInt16(IntPtr ptr, int ofs, char val) => WriteInt16(ptr, ofs, (short)val);
 436
 437         public static void WriteInt16([In, Out]object ptr, int ofs, char val) => WriteInt16(ptr, ofs, (short)val);
 438
 439         public static void WriteInt16(IntPtr ptr, char val) => WriteInt16(ptr, 0, (short)val);
 440
 441         public static unsafe void WriteInt32(IntPtr ptr, int ofs, int val)
 442         {
 443             try
 444             {
 445                 byte* addr = (byte*)ptr + ofs;
 446                 if ((unchecked((int)addr) & 0x3) == 0)
 447                 {
 448                     // aligned write
 449                     *((int*)addr) = val;
 450                 }
 451                 else
 452                 {
 453                     Unsafe.WriteUnaligned(addr, val);
 454                 }
 455             }
 456             catch (NullReferenceException)
 457             {
 458                 // this method is documented to throw AccessViolationException on any AV
 459                 throw new AccessViolationException();
 460             }
 461         }
 462
 463         public static void WriteInt32(IntPtr ptr, int val) => WriteInt32(ptr, 0, val);
 464
 465         public static void WriteIntPtr(IntPtr ptr, int ofs, IntPtr val)
 466         {
 467 #if BIT64
 468             WriteInt64(ptr, ofs, (long)val);
 469 #else // 32
 470             WriteInt32(ptr, ofs, (int)val);
 471 #endif
 472         }
 473
 474         public static void WriteIntPtr(object ptr, int ofs, IntPtr val)
 475         {
 476 #if BIT64
 477             WriteInt64(ptr, ofs, (long)val);
 478 #else // 32
 479             WriteInt32(ptr, ofs, (int)val);
 480 #endif
 481         }
 482
 483         public static void WriteIntPtr(IntPtr ptr, IntPtr val) => WriteIntPtr(ptr, 0, val);
 484
 485         public static unsafe void WriteInt64(IntPtr ptr, int ofs, long val)
 486         {
 487             try
 488             {
 489                 byte* addr = (byte*)ptr + ofs;
 490                 if ((unchecked((int)addr) & 0x7) == 0)
 491                 {
 492                     // aligned write
 493                     *((long*)addr) = val;
 494                 }
 495                 else
 496                 {
 497                     Unsafe.WriteUnaligned(addr, val);
 498                 }
 499             }
 500             catch (NullReferenceException)
 501             {
 502                 // this method is documented to throw AccessViolationException on any AV
 503                 throw new AccessViolationException();
 504             }
 505         }
 506
 507         public static void WriteInt64(IntPtr ptr, long val) => WriteInt64(ptr, 0, val);
 508
 509         public static void Prelink(MethodInfo m)
 510         {
 511             if (m is null)
 512             {
 513                 throw new ArgumentNullException(nameof(m));
 514             }
 515
 516             PrelinkCore(m);
 517         }
 518
 519         public static void PrelinkAll(Type c)
 520         {
 521             if (c is null)
 522             {
 523                 throw new ArgumentNullException(nameof(c));
 524             }
 525
 526             MethodInfo[] mi = c.GetMethods();
 527
 528             for (int i = 0; i < mi.Length; i++)
 529             {
 530                 Prelink(mi[i]);
 531             }
 532         }
 533
 534         public static void StructureToPtr<T>([DisallowNull] T structure, IntPtr ptr, bool fDeleteOld)
 535         {
 536             StructureToPtr((object)structure!, ptr, fDeleteOld);
 537         }
 538
 539         /// <summary>
 540         /// Creates a new instance of "structuretype" and marshals data from a
 541         /// native memory block to it.
 542         /// </summary>
 543         public static object? PtrToStructure(IntPtr ptr, Type structureType)
 544         {
 545             if (ptr == IntPtr.Zero)
 546             {
 547                 return null;
 548             }
 549
 550             if (structureType is null)
 551             {
 552                 throw new ArgumentNullException(nameof(structureType));
 553             }
 554             if (structureType.IsGenericType)
 555             {
 556                 throw new ArgumentException(SR.Argument_NeedNonGenericType, nameof(structureType));
 557             }
 558             if (!structureType.IsRuntimeImplemented())
 559             {
 560                 throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(structureType));
 561             }
 562
 563             return PtrToStructureHelper(ptr, structureType);
 564         }
 565
 566         /// <summary>
 567         /// Marshals data from a native memory block to a preallocated structure class.
 568         /// </summary>
 569         public static void PtrToStructure(IntPtr ptr, object structure)
 570         {
 571             PtrToStructureHelper(ptr, structure, allowValueClasses: false);
 572         }
 573
 574         public static void PtrToStructure<T>(IntPtr ptr, [DisallowNull] T structure)
 575         {
 576             PtrToStructure(ptr, (object)structure!);
 577         }
 578
 579         [return: MaybeNull]
 580         public static T PtrToStructure<T>(IntPtr ptr) => (T)PtrToStructure(ptr, typeof(T))!;
 581
 582         public static void DestroyStructure<T>(IntPtr ptr) => DestroyStructure(ptr, typeof(T));
 583
 584         /// <summary>
 585         /// Converts the HRESULT to a CLR exception.
 586         /// </summary>
 587         public static Exception? GetExceptionForHR(int errorCode) => GetExceptionForHR(errorCode, IntPtr.Zero);
 588
 589         public static Exception? GetExceptionForHR(int errorCode, IntPtr errorInfo)
 590         {
 591             if (errorCode >= 0)
 592             {
 593                 return null;
 594             }
 595
 596             return GetExceptionForHRInternal(errorCode, errorInfo);
 597         }
 598
 599         /// <summary>
 600         /// Throws a CLR exception based on the HRESULT.
 601         /// </summary>
 602         public static void ThrowExceptionForHR(int errorCode)
 603         {
 604             if (errorCode < 0)
 605             {
 606                 throw GetExceptionForHR(errorCode, IntPtr.Zero)!;
 607             }
 608         }
 609
 610         public static void ThrowExceptionForHR(int errorCode, IntPtr errorInfo)
 611         {
 612             if (errorCode < 0)
 613             {
 614                 throw GetExceptionForHR(errorCode, errorInfo)!;
 615             }
 616         }
 617
 618         public static IntPtr SecureStringToBSTR(SecureString s)
 619         {
 620             if (s is null)
 621             {
 622                 throw new ArgumentNullException(nameof(s));
 623             }
 624
 625             return s.MarshalToBSTR();
 626         }
 627
 628         public static IntPtr SecureStringToCoTaskMemAnsi(SecureString s)
 629         {
 630             if (s is null)
 631             {
 632                 throw new ArgumentNullException(nameof(s));
 633             }
 634
 635             return s.MarshalToString(globalAlloc: false, unicode: false);
 636         }
 637
 638         public static IntPtr SecureStringToCoTaskMemUnicode(SecureString s)
 639         {
 640             if (s is null)
 641             {
 642                 throw new ArgumentNullException(nameof(s));
 643             }
 644
 645             return s.MarshalToString(globalAlloc: false, unicode: true);
 646         }
 647
 648         public static IntPtr SecureStringToGlobalAllocAnsi(SecureString s)
 649         {
 650             if (s is null)
 651             {
 652                 throw new ArgumentNullException(nameof(s));
 653             }
 654
 655             return s.MarshalToString(globalAlloc: true, unicode: false);
 656         }
 657
 658         public static IntPtr SecureStringToGlobalAllocUnicode(SecureString s)
 659         {
 660             if (s is null)
 661             {
 662                 throw new ArgumentNullException(nameof(s));
 663             }
 664
 665             return s.MarshalToString(globalAlloc: true, unicode: true); ;
 666         }
 667
 668         public static unsafe IntPtr StringToHGlobalAnsi(string? s)
 669         {
 670             if (s is null)
 671             {
 672                 return IntPtr.Zero;
 673             }
 674
 675             long lnb = (s.Length + 1) * (long)SystemMaxDBCSCharSize;
 676             int nb = (int)lnb;
 677
 678             // Overflow checking
 679             if (nb != lnb)
 680             {
 681                 throw new ArgumentOutOfRangeException(nameof(s));
 682             }
 683
 684             IntPtr hglobal = AllocHGlobal((IntPtr)nb);
 685
 686             StringToAnsiString(s, (byte*)hglobal, nb);
 687             return hglobal;
 688         }
 689
 690         public static unsafe IntPtr StringToHGlobalUni(string? s)
 691         {
 692             if (s is null)
 693             {
 694                 return IntPtr.Zero;
 695             }
 696
 697             int nb = (s.Length + 1) * 2;
 698
 699             // Overflow checking
 700             if (nb < s.Length)
 701             {
 702                 throw new ArgumentOutOfRangeException(nameof(s));
 703             }
 704
 705             IntPtr hglobal = AllocHGlobal((IntPtr)nb);
 706
 707             fixed (char* firstChar = s)
 708             {
 709                 string.wstrcpy((char*)hglobal, firstChar, s.Length + 1);
 710             }
 711             return hglobal;
 712         }
 713
 714         private static unsafe IntPtr StringToHGlobalUTF8(string? s)
 715         {
 716             if (s is null)
 717             {
 718                 return IntPtr.Zero;
 719             }
 720
 721             int nb = Encoding.UTF8.GetMaxByteCount(s.Length);
 722
 723             IntPtr pMem = AllocHGlobal(nb + 1);
 724
 725             int nbWritten;
 726             byte* pbMem = (byte*)pMem;
 727
 728             fixed (char* firstChar = s)
 729             {
 730                 nbWritten = Encoding.UTF8.GetBytes(firstChar, s.Length, pbMem, nb);
 731             }
 732
 733             pbMem[nbWritten] = 0;
 734
 735             return pMem;
 736         }
 737
 738         public static unsafe IntPtr StringToCoTaskMemUni(string? s)
 739         {
 740             if (s is null)
 741             {
 742                 return IntPtr.Zero;
 743             }
 744
 745             int nb = (s.Length + 1) * 2;
 746
 747             // Overflow checking
 748             if (nb < s.Length)
 749             {
 750                 throw new ArgumentOutOfRangeException(nameof(s));
 751             }
 752
 753             IntPtr hglobal = AllocCoTaskMem(nb);
 754
 755             fixed (char* firstChar = s)
 756             {
 757                 string.wstrcpy((char*)hglobal, firstChar, s.Length + 1);
 758             }
 759             return hglobal;
 760         }
 761
 762         public static unsafe IntPtr StringToCoTaskMemUTF8(string? s)
 763         {
 764             if (s is null)
 765             {
 766                 return IntPtr.Zero;
 767             }
 768
 769             int nb = Encoding.UTF8.GetMaxByteCount(s.Length);
 770
 771             IntPtr pMem = AllocCoTaskMem(nb + 1);
 772
 773             int nbWritten;
 774             byte* pbMem = (byte*)pMem;
 775
 776             fixed (char* firstChar = s)
 777             {
 778                 nbWritten = Encoding.UTF8.GetBytes(firstChar, s.Length, pbMem, nb);
 779             }
 780
 781             pbMem[nbWritten] = 0;
 782
 783             return pMem;
 784         }
 785
 786         public static unsafe IntPtr StringToCoTaskMemAnsi(string? s)
 787         {
 788             if (s is null)
 789             {
 790                 return IntPtr.Zero;
 791             }
 792
 793             long lnb = (s.Length + 1) * (long)SystemMaxDBCSCharSize;
 794             int nb = (int)lnb;
 795
 796             // Overflow checking
 797             if (nb != lnb)
 798             {
 799                 throw new ArgumentOutOfRangeException(nameof(s));
 800             }
 801
 802             IntPtr hglobal = AllocCoTaskMem(nb);
 803
 804             StringToAnsiString(s, (byte*)hglobal, nb);
 805             return hglobal;
 806         }
 807
 808         /// <summary>
 809         /// Generates a GUID for the specified type. If the type has a GUID in the
 810         /// metadata then it is returned otherwise a stable guid is generated based
 811         /// on the fully qualified name of the type.
 812         /// </summary>
 813         public static Guid GenerateGuidForType(Type type)
 814         {
 815             if (type is null)
 816             {
 817                 throw new ArgumentNullException(nameof(type));
 818             }
 819             if (!type.IsRuntimeImplemented())
 820             {
 821                 throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(type));
 822             }
 823
 824             return type.GUID;
 825         }
 826
 827         /// <summary>
 828         /// This method generates a PROGID for the specified type. If the type has
 829         /// a PROGID in the metadata then it is returned otherwise a stable PROGID
 830         /// is generated based on the fully qualified name of the type.
 831         /// </summary>
 832         public static string? GenerateProgIdForType(Type type)
 833         {
 834             if (type is null)
 835             {
 836                 throw new ArgumentNullException(nameof(type));
 837             }
 838             if (type.IsImport)
 839             {
 840                 throw new ArgumentException(SR.Argument_TypeMustNotBeComImport, nameof(type));
 841             }
 842             if (type.IsGenericType)
 843             {
 844                 throw new ArgumentException(SR.Argument_NeedNonGenericType, nameof(type));
 845             }
 846
 847             ProgIdAttribute? progIdAttribute = type.GetCustomAttribute<ProgIdAttribute>();
 848             if (progIdAttribute != null)
 849             {
 850                 return progIdAttribute.Value ?? string.Empty;
 851             }
 852
 853             // If there is no prog ID attribute then use the full name of the type as the prog id.
 854             return type.FullName;
 855         }
 856
 857         public static Delegate GetDelegateForFunctionPointer(IntPtr ptr, Type t)
 858         {
 859             if (ptr == IntPtr.Zero)
 860             {
 861                 throw new ArgumentNullException(nameof(ptr));
 862             }
 863             if (t is null)
 864             {
 865                 throw new ArgumentNullException(nameof(t));
 866             }
 867             if (!t.IsRuntimeImplemented())
 868             {
 869                 throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(t));
 870             }
 871             if (t.IsGenericType)
 872             {
 873                 throw new ArgumentException(SR.Argument_NeedNonGenericType, nameof(t));
 874             }
 875
 876             Type? c = t.BaseType;
 877             if (c != typeof(Delegate) && c != typeof(MulticastDelegate))
 878             {
 879                 throw new ArgumentException(SR.Arg_MustBeDelegate, nameof(t));
 880             }
 881
 882             return GetDelegateForFunctionPointerInternal(ptr, t);
 883         }
 884
 885         public static TDelegate GetDelegateForFunctionPointer<TDelegate>(IntPtr ptr)
 886         {
 887             return (TDelegate)(object)GetDelegateForFunctionPointer(ptr, typeof(TDelegate));
 888         }
 889
 890         public static IntPtr GetFunctionPointerForDelegate(Delegate d)
 891         {
 892             if (d is null)
 893             {
 894                 throw new ArgumentNullException(nameof(d));
 895             }
 896
 897             return GetFunctionPointerForDelegateInternal(d);
 898         }
 899
 900         public static IntPtr GetFunctionPointerForDelegate<TDelegate>(TDelegate d) where TDelegate : notnull
 901         {
 902             return GetFunctionPointerForDelegate((Delegate)(object)d);
 903         }
 904
 905         public static int GetHRForLastWin32Error()
 906         {
 907             int dwLastError = GetLastWin32Error();
 908             if ((dwLastError & 0x80000000) == 0x80000000)
 909             {
 910                 return dwLastError;
 911             }
 912
 913             return (dwLastError & 0x0000FFFF) | unchecked((int)0x80070000);
 914         }
 915
 916         public static IntPtr /* IDispatch */ GetIDispatchForObject(object o) => throw new PlatformNotSupportedException();
 917
 918         public static void ZeroFreeBSTR(IntPtr s)
 919         {
 920             if (s == IntPtr.Zero)
 921             {
 922                 return;
 923             }
 924             RuntimeImports.RhZeroMemory(s, (UIntPtr)SysStringByteLen(s));
 925             FreeBSTR(s);
 926         }
 927
 928         public static unsafe void ZeroFreeCoTaskMemAnsi(IntPtr s)
 929         {
 930             ZeroFreeCoTaskMemUTF8(s);
 931         }
 932
 933         public static unsafe void ZeroFreeCoTaskMemUnicode(IntPtr s)
 934         {
 935             if (s == IntPtr.Zero)
 936             {
 937                 return;
 938             }
 939             RuntimeImports.RhZeroMemory(s, (UIntPtr)(string.wcslen((char*)s) * 2));
 940             FreeCoTaskMem(s);
 941         }
 942
 943         public static unsafe void ZeroFreeCoTaskMemUTF8(IntPtr s)
 944         {
 945             if (s == IntPtr.Zero)
 946             {
 947                 return;
 948             }
 949             RuntimeImports.RhZeroMemory(s, (UIntPtr)string.strlen((byte*)s));
 950             FreeCoTaskMem(s);
 951         }
 952
 953         public static unsafe void ZeroFreeGlobalAllocAnsi(IntPtr s)
 954         {
 955             if (s == IntPtr.Zero)
 956             {
 957                 return;
 958             }
 959             RuntimeImports.RhZeroMemory(s, (UIntPtr)string.strlen((byte*)s));
 960             FreeHGlobal(s);
 961         }
 962
 963         public static unsafe void ZeroFreeGlobalAllocUnicode(IntPtr s)
 964         {
 965             if (s == IntPtr.Zero)
 966             {
 967                 return;
 968             }
 969             RuntimeImports.RhZeroMemory(s, (UIntPtr)(string.wcslen((char*)s) * 2));
 970             FreeHGlobal(s);
 971         }
 972
 973         internal static unsafe uint SysStringByteLen(IntPtr s)
 974         {
 975             return *(((uint*)s) - 1);
 976         }
 977     }
 978 }