HandleRef<THandle>
struct HandleRef<THandle> : IHandle<THandle>, IEquatable<HandleRef<THandle>> where THandle : ValueType modreq(System.Runtime.InteropServices.UnmanagedType), IEquatable<THandle>
Adapter to use when owning classes cannot directly implement IHandle<T>.
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace Windows.Win32.Foundation
{
[RequiredMember]
internal readonly struct HandleRef<[IsUnmanaged] THandle> : IHandle<THandle>, IEquatable<HandleRef<THandle>> where THandle : struct, IEquatable<THandle>
{
[Nullable(2)]
[RequiredMember]
[field: Nullable(2)]
public object Wrapper {
[NullableContext(2)]
get;
[NullableContext(2)]
set;
}
[RequiredMember]
public THandle Handle { get; set; }
public bool IsNull => Handle.Equals(default(THandle));
[SetsRequiredMembers]
public HandleRef([Nullable(2)] object wrapper, THandle handle)
{
Wrapper = wrapper;
Handle = handle;
}
[SetsRequiredMembers]
public HandleRef([Nullable(new byte[] {
2,
0
})] IHandle<THandle> handle)
{
Wrapper = handle;
Handle = ((handle != null) ? handle.Handle : default(THandle));
}
public bool Equals(HandleRef<THandle> other)
{
if (other.Handle.Equals(Handle))
return object.Equals(other.Wrapper, Wrapper);
return false;
}
[NullableContext(2)]
public override bool Equals([NotNullWhen(true)] object obj)
{
if (obj is THandle) {
THandle val = (THandle)obj;
return Equals(val);
}
return false;
}
public override int GetHashCode()
{
return HashCode.Combine<object, THandle>(Wrapper, Handle);
}
public static bool operator ==(HandleRef<THandle> left, HandleRef<THandle> right)
{
return left.Equals(right);
}
public static bool operator !=(HandleRef<THandle> left, HandleRef<THandle> right)
{
return !(left == right);
}
public unsafe static explicit operator HandleRef(HandleRef<THandle> handle)
{
if (sizeof(IntPtr) != sizeof(THandle))
throw new InvalidCastException();
THandle source = handle.Handle;
return new HandleRef(handle.Wrapper, Unsafe.As<THandle, IntPtr>(ref source));
}
public unsafe static explicit operator HandleRef<THandle>(HandleRef handle)
{
if (sizeof(IntPtr) != sizeof(THandle))
throw new InvalidCastException();
IntPtr source = handle.Handle;
return new HandleRef<THandle>(handle.Wrapper, Unsafe.As<IntPtr, THandle>(ref source));
}
}
}