netcore/System.Private.CoreLib/src/System/ModuleHandle.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.Reflection;
   6 using System.Runtime.CompilerServices;
   7
   8 namespace System
   9 {
  10         public struct ModuleHandle
  11         {
  12                 readonly IntPtr value;
  13
  14                 public static readonly ModuleHandle EmptyHandle = new ModuleHandle (IntPtr.Zero);
  15
  16                 internal ModuleHandle (IntPtr v)
  17                 {
  18                         value = v;
  19                 }
  20
  21                 internal IntPtr Value {
  22                         get {
  23                                 return value;
  24                         }
  25                 }
  26
  27                 public int MDStreamVersion {
  28                         get {
  29                                 if (value == IntPtr.Zero)
  30                                         throw new ArgumentNullException (String.Empty, "Invalid handle");
  31                                 return RuntimeModule.GetMDStreamVersion (value);
  32                         }
  33                 }
  34
  35                 public RuntimeFieldHandle ResolveFieldHandle (int fieldToken)
  36                 {
  37                         return ResolveFieldHandle (fieldToken, null, null);
  38                 }
  39
  40                 public RuntimeMethodHandle ResolveMethodHandle (int methodToken)
  41                 {
  42                         return ResolveMethodHandle (methodToken, null, null);
  43                 }
  44
  45                 public RuntimeTypeHandle ResolveTypeHandle (int typeToken)
  46                 {
  47                         return ResolveTypeHandle (typeToken, null, null);
  48                 }
  49
  50                 static IntPtr[]? ptrs_from_handles (RuntimeTypeHandle[]? handles)
  51                 {
  52                         if (handles == null)
  53                                 return null;
  54
  55                         var res = new IntPtr [handles.Length];
  56                         for (int i = 0; i < handles.Length; ++i)
  57                                 res [i] = handles [i].Value;
  58                         return res;
  59                 }
  60
  61                 public RuntimeTypeHandle ResolveTypeHandle (int typeToken, RuntimeTypeHandle[]? typeInstantiationContext, RuntimeTypeHandle[]? methodInstantiationContext)
  62                 {
  63                         ResolveTokenError error;
  64                         if (value == IntPtr.Zero)
  65                                 throw new ArgumentNullException (String.Empty, "Invalid handle");
  66                         IntPtr res = RuntimeModule.ResolveTypeToken (value, typeToken, ptrs_from_handles (typeInstantiationContext), ptrs_from_handles (methodInstantiationContext), out error);
  67                         if (res == IntPtr.Zero)
  68                                 throw new TypeLoadException (String.Format ("Could not load type '0x{0:x}' from assembly '0x{1:x}'", typeToken, value.ToInt64 ()));
  69                         else
  70                                 return new RuntimeTypeHandle (res);
  71                 }
  72
  73                 public RuntimeMethodHandle ResolveMethodHandle (int methodToken, RuntimeTypeHandle[]? typeInstantiationContext, RuntimeTypeHandle[]? methodInstantiationContext)
  74                 {
  75                         ResolveTokenError error;
  76                         if (value == IntPtr.Zero)
  77                                 throw new ArgumentNullException (String.Empty, "Invalid handle");
  78                         IntPtr res = RuntimeModule.ResolveMethodToken (value, methodToken, ptrs_from_handles (typeInstantiationContext), ptrs_from_handles (methodInstantiationContext), out error);
  79                         if (res == IntPtr.Zero)
  80                                 throw new Exception (String.Format ("Could not load method '0x{0:x}' from assembly '0x{1:x}'", methodToken, value.ToInt64 ()));
  81                         else
  82                                 return new RuntimeMethodHandle (res);
  83                 }
  84
  85                 public RuntimeFieldHandle ResolveFieldHandle (int fieldToken, RuntimeTypeHandle[]? typeInstantiationContext, RuntimeTypeHandle[]? methodInstantiationContext)
  86                 {
  87                         ResolveTokenError error;
  88                         if (value == IntPtr.Zero)
  89                                 throw new ArgumentNullException (String.Empty, "Invalid handle");
  90
  91                         IntPtr res = RuntimeModule.ResolveFieldToken (value, fieldToken, ptrs_from_handles (typeInstantiationContext), ptrs_from_handles (methodInstantiationContext), out error);
  92                         if (res == IntPtr.Zero)
  93                                 throw new Exception (String.Format ("Could not load field '0x{0:x}' from assembly '0x{1:x}'", fieldToken, value.ToInt64 ()));
  94                         else
  95                                 return new RuntimeFieldHandle (res);
  96                 }
  97
  98                 public RuntimeFieldHandle GetRuntimeFieldHandleFromMetadataToken (int fieldToken)
  99                 {
 100                         return ResolveFieldHandle (fieldToken);
 101                 }
 102
 103                 public RuntimeMethodHandle GetRuntimeMethodHandleFromMetadataToken (int methodToken)
 104                 {
 105                         return ResolveMethodHandle (methodToken);
 106                 }
 107
 108                 public RuntimeTypeHandle GetRuntimeTypeHandleFromMetadataToken (int typeToken)
 109                 {
 110                         return ResolveTypeHandle (typeToken);
 111                 }
 112
 113                 public override bool Equals (object? obj)
 114                 {
 115                         if (obj == null || GetType () != obj.GetType ())
 116                                 return false;
 117
 118                         return value == ((ModuleHandle)obj).Value;
 119                 }
 120
 121                 public bool Equals (ModuleHandle handle)
 122                 {
 123                         return value == handle.Value;
 124                 }
 125
 126                 public override int GetHashCode ()
 127                 {
 128                         return value.GetHashCode ();
 129                 }
 130
 131                 public static bool operator == (ModuleHandle left, ModuleHandle right)
 132                 {
 133                         return Equals (left, right);
 134                 }
 135
 136                 public static bool operator != (ModuleHandle left, ModuleHandle right)
 137                 {
 138                         return !Equals (left, right);
 139                 }
 140         }
 141 }
 142