句柄(Handle)缘来
.NET提供了一个结构体System.IntPtr专门用来代表句柄或指针。
句柄是对象的标识符，当调用这些API创建对象时，它们并不直接返回指向对象的指针，而是会返回一个32位或64位的整数值，这个在进程或系统范围内唯一的整数值就是句柄(Handle),随后程序再次访问对象，或者删除对象，都将句柄作为Windows API的参数来间接对这些对象进行操作。
句柄指向就是指向文件开头，在windows系统所有的东西都是文件，对象也是文件。所以句柄和指针是一样的意思。句柄是面向对象的指针的称呼。
指针是对存储区域的引用，该区域包含您感兴趣的一些数据。指针是面向过程编程的称呼。
IntPtr类是IntPointer的缩写。
C#中用来取代指针，也可以说对指针进行封装，指向托管内存。
它也不常用，因为C#项目中指针都被弃用了，那指针的封装—句柄自然也被弃用了。
但总有特殊的地方会用到指针，比如调用C++动态库之类的；所以微软贴心的为我们做了个句柄，毕竟指针用起来太难受了。
句柄的定义
句柄是一个结构体，简单的来说，它是指针的一个封装，是C#中指针的替代者，下面我们看下句柄的定义。
namespace System
{
//
// 摘要:
// A platform-specific type that is used to represent a pointer or a handle.
public readonly struct IntPtr : IComparable, IComparable<nint>, IEquatable<nint>, ISpanFormattable, IFormattable, ISerializable
{
//
// 摘要:
// A read-only field that represents a pointer or handle that has been initialized
// to zero.
public static readonly IntPtr Zero;
//
// 摘要:
// Initializes a new instance of System.IntPtr using the specified 32-bit pointer
// or handle.
//
// 参数:
// value:
// A pointer or handle contained in a 32-bit signed integer.
public IntPtr(int value);
//
// 摘要:
// Initializes a new instance of System.IntPtr using the specified 64-bit pointer.
//
// 参数:
// value:
// A pointer or handle contained in a 64-bit signed integer.
//
// 异常:
// T:System.OverflowException:
// On a 32-bit platform, value is too large or too small to represent as an System.IntPtr.
public IntPtr(long value);
//
// 摘要:
// Initializes a new instance of System.IntPtr using the specified pointer to an
// unspecified type.
//
// 参数:
// value:
// A pointer to an unspecified type.
[CLSCompliant(false)]
public IntPtr(void* value);
//
// 摘要:
// Represents the largest possible value of System.IntPtr.
public static IntPtr MaxValue { get; }
//
// 摘要:
// Represents the smallest possible value of System.IntPtr.
public static IntPtr MinValue { get; }
//
// 摘要:
// Gets the size of this instance.
//
// 返回结果:
// The size of a pointer or handle in this process, measured in bytes. The value
// of this property is 4 in a 32-bit process, and 8 in a 64-bit process. You can
// define the process type by setting the /platform switch when you compile your
// code with the C# and Visual Basic compilers.
public static int Size { get; }
//
// 摘要:
// Adds an offset to the value of a pointer.
//
// 参数:
// pointer:
// The pointer to add the offset to.
//
// offset:
// The offset to add.
//
// 返回结果:
// A new pointer that reflects the addition of offset to pointer.
public static IntPtr Add(IntPtr pointer, int offset);
//
// 摘要:
// Converts the string representation of a number in a specified style and culture-specific
// format to its signed native integer equivalent.
//
// 参数:
// s:
// A string containing a number to convert.
//
// style:
// A bitwise combination of the enumeration values that indicates the style elements
// that can be present in s.
//
// provider:
// An object that supplies culture-specific formatting information about s.
//
// 返回结果:
// A signed native integer equivalent to the number contained in s.
//
// 异常:
// T:System.ArgumentNullException:
// s is null.
//
// T:System.ArgumentException:
// style is not a System.Globalization.NumberStyles value or style is not a combination
// of System.Globalization.NumberStyles.AllowHexSpecifier and System.Globalization.NumberStyles.HexNumber
// values.
//
// T:System.FormatException:
// s is not in the correct format.
//
// T:System.OverflowException:
// s represents a number less than System.IntPtr.MinValue or greater than System.IntPtr.MaxValue.
public static IntPtr Parse(string s, NumberStyles style, IFormatProvider? provider);
//
// 摘要:
// Converts the read-only span of characters representation of a number in a specified
// style and culture-specific format to its signed native integer equivalent.
//
// 参数:
// s:
// A read-only span of characters containing a number to convert.
//
// style:
// A bitwise combination of the enumeration values that indicates the style elements
// that can be present in s.
//
// provider:
// An object that supplies culture-specific formatting information about s.
//
// 返回结果:
// A signed native integer equivalent to the number contained in s.
//
// 异常:
// T:System.ArgumentException:
// style is not a System.Globalization.NumberStyles value or style is not a combination
// of System.Globalization.NumberStyles.AllowHexSpecifier and System.Globalization.NumberStyles.HexNumber
// values.
//
// T:System.FormatException:
// s is not in the correct format.
//
// T:System.OverflowException:
// s represents a number less than System.IntPtr.MinValue or greater than System.IntPtr.MaxValue.
public static IntPtr Parse(ReadOnlySpan<char> s, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null);
//
// 摘要:
// Converts the string representation of a number in a specified culture-specific
// format to its signed native integer equivalent.
//
// 参数:
// s:
// A string containing a number to convert.
//
// provider:
// An object that supplies culture-specific formatting information about s.
//
// 返回结果:
// A signed native integer equivalent to the number contained in s.
//
// 异常:
// T:System.ArgumentNullException:
// s is null.
//
// T:System.FormatException:
// s is not in the correct format.
//
// T:System.OverflowException:
// s represents a number less than System.IntPtr.MinValue or greater than System.IntPtr.MaxValue.
public static IntPtr Parse(string s, IFormatProvider? provider);
//
// 摘要:
// Converts the string representation of a number in a specified style to its signed
// native integer equivalent.
//
// 参数:
// s:
// A string containing a number to convert.
//
// style:
// A bitwise combination of the enumeration values that indicates the style elements
// that can be present in s.
//
// 返回结果:
// A signed native integer equivalent to the number contained in s.
//
// 异常:
// T:System.ArgumentNullException:
// s is null.
//
// T:System.ArgumentException:
// style is not a System.Globalization.NumberStyles value or style is not a combination
// of System.Globalization.NumberStyles.AllowHexSpecifier and System.Globalization.NumberStyles.HexNumber
// values.
//
// T:System.FormatException:
// s is not in the correct format.
//
// T:System.OverflowException:
// s represents a number less than System.IntPtr.MinValue or greater than System.IntPtr.MaxValue.
public static IntPtr Parse(string s, NumberStyles style);
//
// 摘要:
// Converts the string representation of a number to its signed native integer equivalent.
//
// 参数:
// s:
// A string containing a number to convert.
//
// 返回结果:
// A signed native integer equivalent to the number contained in s.
//
// 异常:
// T:System.ArgumentNullException:
// s is null.
//
// T:System.FormatException:
// s is not in the correct format.
//
// T:System.OverflowException:
// s represents a number less than System.IntPtr.MinValue or greater than System.IntPtr.MaxValue.
public static IntPtr Parse(string s);
//
// 摘要:
// Subtracts an offset from the value of a pointer.
//
// 参数:
// pointer:
// The pointer to subtract the offset from.
//
// offset:
// The offset to subtract.
//
// 返回结果:
// A new pointer that reflects the subtraction of offset from pointer.
public static IntPtr Subtract(IntPtr pointer, int offset);
//
// 摘要:
// Converts the read-only span of characters representation of a number in a specified
// style and culture-specific format to its signed native integer equivalent. A
// return value indicates whether the conversion succeeded.
//
// 参数:
// s:
// A read-only span of characters containing a number to convert. The string is
// interpreted using the style specified by style.
//
// style:
// A bitwise combination of enumeration values that indicates the style elements
// that can be present in s.
//
// provider:
// An object that supplies culture-specific formatting information about s.
//
// result:
// When this method returns, contains the signed native integer value equivalent
// of the number contained in s, if the conversion succeeded, or zero if the conversion
// failed. The conversion fails if the s parameter is empty, is not of the correct
// format, or represents a number less than System.IntPtr.MinValue or greater than
// System.IntPtr.MaxValue. This parameter is passed uninitialized; any value originally
// supplied in result will be overwritten.
//
// 返回结果:
// true if s was converted successfully; otherwise, false.
public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, out IntPtr result);
//
// 摘要:
// Converts the read-only span of characters representation of a number to its signed
// native integer equivalent. A return value indicates whether the conversion succeeded.
//
// 参数:
// s:
// A read-only span of characters containing a number to convert.
//
// result:
// When this method returns, contains the signed native integer equivalent of the
// number contained in s, if the conversion succeeded, or zero if the conversion
// failed. The conversion fails if the s parameter is empty, is not of the correct
// format, or represents a number less than System.IntPtr.MinValue or greater than
// System.IntPtr.MaxValue. This parameter is passed uninitialized; any value originally
// supplied in result will be overwritten.
//
// 返回结果:
// true if s was converted successfully; otherwise, false.
public static bool TryParse(ReadOnlySpan<char> s, out IntPtr result);
//
// 摘要:
// Converts the string representation of a number to its signed native integer equivalent.
// A return value indicates whether the conversion succeeded.
//
// 参数:
// s:
// A string containing a number to convert.
//
// result:
// When this method returns, contains the signed native integer value equivalent
// of the number contained in s, if the conversion succeeded, or zero if the conversion
// failed. The conversion fails if the s parameter is null or empty, is not of the
// correct format, or represents a number less than System.IntPtr.MinValue or greater
// than System.IntPtr.MaxValue. This parameter is passed uninitialized; any value
// originally supplied in result will be overwritten.
//
// 返回结果:
// true if s was converted successfully; otherwise, false.
public static bool TryParse([NotNullWhen(true)] string? s, out IntPtr result);
//
// 摘要:
// Converts the string representation of a number in a specified style and culture-specific
// format to its signed native integer equivalent. A return value indicates whether
// the conversion succeeded.
//
// 参数:
// s:
// A string containing a number to convert. The string is interpreted using the
// style specified by style.
//
// style:
// A bitwise combination of enumeration values that indicates the style elements
// that can be present in s.
//
// provider:
// An object that supplies culture-specific formatting information about s.
//
// result:
// When this method returns, contains the signed native integer value equivalent
// of the number contained in s, if the conversion succeeded, or zero if the conversion
// failed. The conversion fails if the s parameter is null or empty, is not of the
// correct format, or represents a number less than System.IntPtr.MinValue or greater
// than System.IntPtr.MaxValue. This parameter is passed uninitialized; any value
// originally supplied in result will be overwritten.
//
// 返回结果:
// true if s was converted successfully; otherwise, false.
public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, IFormatProvider? provider, out IntPtr result);
//
// 摘要:
// Compares the current instance with another object of the same type and returns
// an integer that indicates whether the current instance precedes, follows, or
// occurs in the same position in the sort order as the other object.
//
// 参数:
// value:
// An object to compare, or null.
//
// 返回结果:
// A value that indicates the relative order of the objects being compared. The
// return value has these meanings:
// Value – Meaning
// Less than zero – This instance precedes obj in the sort order.
// Zero – This instance occurs in the same position in the sort order as obj.
// Greater than zero – This instance follows obj in the sort order.
public int CompareTo(object? value);
//
// 摘要:
// Compares the current instance with another object of the same type and returns
// an integer that indicates whether the current instance precedes, follows, or
// occurs in the same position in the sort order as the other object.
//
// 参数:
// value:
// A signed native integer to compare.
//
// 返回结果:
// A value that indicates the relative order of the objects being compared. The
// return value has these meanings:
// Value – Meaning
// Less than zero – This instance precedes other in the sort order.
// Zero – This instance occurs in the same position in the sort order as other.
// Greater than zero – This instance follows other in the sort order.
public int CompareTo(IntPtr value);
//
// 摘要:
// Indicates whether the current object is equal to another object of the same type.
//
// 参数:
// other:
// An object to compare with this object.
//
// 返回结果:
// true if the current object is equal to other; otherwise, false.
public bool Equals(IntPtr other);
//
// 摘要:
// Returns a value indicating whether this instance is equal to a specified object.
//
// 参数:
// obj:
// An object to compare with this instance or null.
//
// 返回结果:
// true if obj is an instance of System.IntPtr and equals the value of this instance;
// otherwise, false.
public override bool Equals([NotNullWhen(true)] object? obj);
//
// 摘要:
// Returns the hash code for this instance.
//
// 返回结果:
// A 32-bit signed integer hash code.
public override int GetHashCode();
//
// 摘要:
// Converts the value of this instance to a 32-bit signed integer.
//
// 返回结果:
// A 32-bit signed integer equal to the value of this instance.
//
// 异常:
// T:System.OverflowException:
// On a 64-bit platform, the value of this instance is too large or too small to
// represent as a 32-bit signed integer.
public int ToInt32();
//
// 摘要:
// Converts the value of this instance to a 64-bit signed integer.
//
// 返回结果:
// A 64-bit signed integer equal to the value of this instance.
public long ToInt64();
//
// 摘要:
// Converts the value of this instance to a pointer to an unspecified type.
//
// 返回结果:
// A pointer to System.Void; that is, a pointer to memory containing data of an
// unspecified type.
[CLSCompliant(false)]
public void* ToPointer();
//
// 摘要:
// Converts the numeric value of the current System.IntPtr object to its equivalent
// string representation.
//
// 返回结果:
// The string representation of the value of this instance.
public override string ToString();
//
// 摘要:
// Formats the value of the current instance using the specified format.
//
// 参数:
// format:
// The format to use. -or- A null reference (Nothing in Visual Basic) to use the
// default format defined for the type of the System.IFormattable implementation.
//
// provider:
// An object that supplies culture-specific formatting information.
//
// 返回结果:
// The value of the current instance in the specified format.
public string ToString(string? format, IFormatProvider? provider);
//
// 摘要:
// Converts the numeric value of the current System.IntPtr object to its equivalent
// string representation.
//
// 参数:
// format:
// A format specification that governs how the current System.IntPtr object is converted.
//
// 返回结果:
// The string representation of the value of the current System.IntPtr object.
//
// 异常:
// T:System.FormatException:
// format is invalid or not supported.
public string ToString(string? format);
//
// 摘要:
// Converts the numeric value of this instance to its equivalent string representation
// using the specified format and culture-specific format information.
//
// 参数:
// provider:
// An object that supplies culture-specific formatting information.
//
// 返回结果:
// The string representation of the value of this instance as specified by provider.
public string ToString(IFormatProvider? provider);
//
// 摘要:
// Tries to format the value of the current instance into the provided span of characters.
//
// 参数:
// destination:
// The span where this instance's value formatted as a span of characters should
// be written.
//
// charsWritten:
// When this method returns, contains the number of characters that were written
// in destination.
//
// format:
// The characters that represent a standard or custom format string that defines
// the acceptable format for destination.
//
// provider:
// An optional object that supplies culture-specific formatting information for
// destination.
//
// 返回结果:
// true if the formatting was successful; otherwise, false.
public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default, IFormatProvider? provider = null);
//
// 摘要:
// Adds an offset to the value of a pointer.
//
// 参数:
// pointer:
// The pointer to add the offset to.
//
// offset:
// The offset to add.
//
// 返回结果:
// A new pointer that reflects the addition of offset to pointer.
public static IntPtr operator +(IntPtr pointer, int offset);
//
// 摘要:
// Subtracts an offset from the value of a pointer.
//
// 参数:
// pointer:
// The pointer to subtract the offset from.
//
// offset:
// The offset to subtract.
//
// 返回结果:
// A new pointer that reflects the subtraction of offset from pointer.
public static IntPtr operator -(IntPtr pointer, int offset);
//
// 摘要:
// Determines whether two specified instances of System.IntPtr are equal.
//
// 参数:
// value1:
// The first pointer or handle to compare.
//
// value2:
// The second pointer or handle to compare.
//
// 返回结果:
// true if value1 equals value2; otherwise, false.
public static bool operator ==(IntPtr value1, IntPtr value2);
//
// 摘要:
// Determines whether two specified instances of System.IntPtr are not equal.
//
// 参数:
// value1:
// The first pointer or handle to compare.
//
// value2:
// The second pointer or handle to compare.
//
// 返回结果:
// true if value1 does not equal value2; otherwise, false.
public static bool operator !=(IntPtr value1, IntPtr value2);
//
// 摘要:
// Converts the value of a 64-bit signed integer to an System.IntPtr.
//
// 参数:
// value:
// A 64-bit signed integer.
//
// 返回结果:
// A new instance of System.IntPtr initialized to value.
//
// 异常:
// T:System.OverflowException:
// On a 32-bit platform, value is too large to represent as an System.IntPtr.
public static explicit operator IntPtr(long value);
//
// 摘要:
// Converts the value of the specified System.IntPtr to a 32-bit signed integer.
//
// 参数:
// value:
// The pointer or handle to convert.
//
// 返回结果:
// The contents of value.
//
// 异常:
// T:System.OverflowException:
// On a 64-bit platform, the value of value is too large to represent as a 32-bit
// signed integer.
public static explicit operator int(IntPtr value);
//
// 摘要:
// Converts the value of the specified System.IntPtr to a 64-bit signed integer.
//
// 参数:
// value:
// The pointer or handle to convert.
//
// 返回结果:
// The contents of value.
public static explicit operator long(IntPtr value);
//
// 摘要:
// Converts the value of a 32-bit signed integer to an System.IntPtr.
//
// 参数:
// value:
// A 32-bit signed integer.
//
// 返回结果:
// A new instance of System.IntPtr initialized to value.
public static explicit operator IntPtr(int value);
//
// 摘要:
// Converts the value of the specified System.IntPtr to a pointer to an unspecified
// type. This API is not CLS-compliant.
//
// 参数:
// value:
// The pointer or handle to convert.
//
// 返回结果:
// The contents of value.
[CLSCompliant(false)]
public static explicit operator void*(IntPtr value);
//
// 摘要:
// Converts the specified pointer to an unspecified type to an System.IntPtr. This
// API is not CLS-compliant.
//
// 参数:
// value:
// A pointer to an unspecified type.
//
// 返回结果:
// A new instance of System.IntPtr initialized to value.
[CLSCompliant(false)]
public static explicit operator IntPtr(void* value);
}
}
我们可以看到，句柄IntPtr里包含创建指针，获取指针长度，设置偏移量等等方法，并且为了编码方便还声明了些强制转换的方法。
看了句柄的结构体定义，相信稍微有点基础的人已经明白了，在C#中，微软是希望抛弃指针而改用更优秀的IntPtr代替它的。
但我们还会发现，句柄里还提供一个方法是ToPointer()，它的返回类型是Void*，也就是说，我们还是可以从句柄里拿到C++中的指针，既然，微软期望在C#中不要使用指针，那为什么还要提供这样的方法呢？
这是因为，在项目开发中总是会有极特殊的情况，比如，你有一段C++写的非常复杂、完美的函数，而将这个函数转换成C#又及其耗时，那么最简单省力的方法就是直接在C#里启用指针进行移植。
也就是说，C#支持指针，其实是为了体现它的兼容性，并不是提倡大家去使用指针。
使用要点
- C#中的
IntPtr类型被称之为"平台特定的整数类型"，用于本机资源，例如窗口句柄。 - 资源的大小取决于使用的硬件和操作系统，即此类型的实例在32位硬件和操作系统中将是32位，在64位硬件和操作系统中将是64位；但其大小总是足以包含系统的指针(因此也可以包含资源的名称)。
- 在调用API函数时，类似含有窗口句柄参数(HANDLE)的原型函数,应显示地声明为
IntPtr类型。 IntPtr类型对多线程操作是安全的。Int和IntPtr互转。
示例模型
struct ChatDemo
{
public double X;
public double Y;
public ChatDemo(double x, double y)
{
X = x;
Y = y;
}
}
Struct与IntPtr互相转换
public void ConvertStruct()
{
var chatDemo = new ChatDemo(1, 10);
// 通过使用指定的字节数，从进程的非托管内存中分配内存
IntPtr intPtr = Marshal.AllocHGlobal
(
// 内存中的所需字节数
cb: Marshal.SizeOf(typeof(ChatDemo))
);
// 将数据从托管对象封送到非托管内存块
Marshal.StructureToPtr
(
// 包含要封送的数据的托管对象。该对象必须是格式化类的结构或实例
structure: chatDemo,
// 指向非托管内存块的指针，必须在调用此方法之前分配该指针
ptr: intPtr,
// 如果在此方法复制该数据前在DestroyStructure(IntPtr,Type)参数上调用ptr，则为true。该块必须包含有效的数据。请注意，在内存块已包含数据时传递false可能会导致内存泄漏。
fDeleteOld: true
);
// 将数据从非托管内存块封送到托管对象
var chatDemoRes = (ChatDemo)Marshal.PtrToStructure
(
// 指向非托管内存块的指针
ptr: intPtr,
// 要创建的对象的类型。此对象必须表示格式化类或结构
structureType: typeof(ChatDemo)
);
}
Struct对象数组与IntPtr互相转换
public void ConvertStructs()
{
var chatDemos = new List<ChatDemo>() { new ChatDemo(1,3), new ChatDemo(2,10), new ChatDemo(4,200)};
// 将托管对象数组转成指针
var intPtr = MarshalMangagedStruct2Array(chatDemos.ToArray());
// 将指针转成托管对象数组
MarshalUnmananagedArray2Struct(intPtr, chatDemos.Count, out ChatDemo[] chatDemoRes);
}
/// <summary>
/// 将指针转成托管对象数组
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="unmanagedArray">非托管指针</param>
/// <param name="length">数据长度</param>
/// <param name="mangagedArray">托管对象数组</param>
public void MarshalUnmananagedArray2Struct<T>(IntPtr unmanagedArray, int length, out T[] mangagedArray)
{
if (length <= 0) throw new ArgumentException(nameof(length));
// 获取对象的空间大小
var size = Marshal.SizeOf(typeof(T));
mangagedArray = new T[length];
for (int i = 0; i < length; i++)
{
// 增加指针内存位置以便定位到下一个结构体
IntPtr nextStructureMemBlock = new IntPtr(unmanagedArray.ToInt64() + i * size);
mangagedArray[i] = Marshal.PtrToStructure<T>(nextStructureMemBlock);
}
}
/// <summary>
/// 将托管对象数组转成指针
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="mangagedArray"></param>
/// <returns></returns>
public IntPtr MarshalMangagedStruct2Array<T>(T[] mangagedArray) where T : struct
{
if (mangagedArray == null || mangagedArray.Length <= 0) throw new ArgumentException(nameof(mangagedArray));
// 获取对象的空间大小
int size = Marshal.SizeOf(typeof(T));
// 得到非托管内存的总长度
int allSize = size * mangagedArray.Length;
// 申请非托管内存空间
IntPtr ptr = Marshal.AllocHGlobal(allSize);
// 写入长度属性值
Marshal.WriteInt32(ptr, mangagedArray.Length);
// 写入数据
for (int i = 0; i < mangagedArray.Length; i++)
{
// 根据指针+偏移量来写入指定序号的对象数据
Marshal.StructureToPtr<T>(mangagedArray[i], ptr + (size * i), false);
}
return ptr;
}
C++与C#类型对照关系
| C++ 数据类型 | C# 数据类型 |
|---|---|
WORD |
ushort |
DWORD |
uint |
UCHAR |
int/byte |
UCHAR* |
string/InPtr |
unsigned char* |
[MarshalAs(UnmanagedType.LPArray)]byte[] / IntPtr |
char* |
string |
LPCTSTR |
string |
LPTSTR |
[MarshalAs(UnmanagedType.LPTStr)] string |
long |
int |
ulong |
uint |
Handle |
IntPtr |
HWND |
IntPtr |
void* |
IntPtr |
int |
int |
int* |
ref int |
*int |
IntPtr |
unsigned int |
uint |
COLORREF |
uint |