mcs/class/corlib/System.Reflection/Assembly.cs

   1 //
   2 // System.Reflection/Assembly.cs
   3 //
   4 // Author:
   5 //   Paolo Molaro (lupus@ximian.com)
   6 //
   7 // (C) 2001 Ximian, Inc.  http://www.ximian.com
   8 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using System;
  31 using System.Security;
  32 using System.Security.Policy;
  33 using System.Security.Permissions;
  34 using System.Runtime.Serialization;
  35 using System.Reflection.Emit;
  36 using System.IO;
  37 using System.Globalization;
  38 using System.Runtime.CompilerServices;
  39 using System.Runtime.InteropServices;
  40 using System.Collections;
  41 using System.Configuration.Assemblies;
  42
  43 namespace System.Reflection {
  44
  45         internal class ResolveEventHolder {
  46                 public event ModuleResolveEventHandler ModuleResolve;
  47         }
  48
  49         [Serializable]
  50         [ClassInterface(ClassInterfaceType.AutoDual)]
  51         public class Assembly : System.Reflection.ICustomAttributeProvider,
  52                 System.Security.IEvidenceFactory, System.Runtime.Serialization.ISerializable {
  53
  54                 // Note: changes to fields must be reflected in _MonoReflectionAssembly struct (object-internals.h)
  55                 private IntPtr _mono_assembly;
  56
  57                 private ResolveEventHolder resolve_event_holder;
  58                 private Evidence _evidence;
  59                 internal PermissionSet _minimum;                // for SecurityAction.RequestMinimum
  60                 internal PermissionSet _optional;       // for SecurityAction.RequestOptional
  61                 internal PermissionSet _refuse;         // for SecurityAction.RequestRefuse
  62                 private PermissionSet _granted;         // for the resolved assembly granted permissions
  63                 private PermissionSet _denied;          // for the resolved assembly denied permissions
  64
  65                 internal Assembly ()
  66                 {
  67                         resolve_event_holder = new ResolveEventHolder ();
  68                 }
  69
  70                 //
  71                 // We can't store the event directly in this class, since the
  72                 // compile would silently insert the fields before _mono_assembly
  73                 //
  74                 public event ModuleResolveEventHandler ModuleResolve {
  75                         add {
  76                                 resolve_event_holder.ModuleResolve -= value;
  77                         }
  78                         remove {
  79                                 resolve_event_holder.ModuleResolve -= value;
  80                         }
  81                 }
  82
  83                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  84                 private extern string get_code_base ();
  85
  86                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  87                 private extern string get_location ();
  88
  89                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  90                 private extern string InternalImageRuntimeVersion ();
  91
  92                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  93                 private extern bool get_global_assembly_cache ();
  94
  95                 public virtual string CodeBase {
  96                         get {
  97                                 return get_code_base ();
  98                         }
  99                 }
 100
 101                 internal virtual string CopiedCodeBase {
 102                         get {
 103                                 return get_code_base ();
 104                         }
 105                 }
 106
 107                 [MonoTODO]
 108                 public virtual string EscapedCodeBase {
 109                         get {
 110                                 //FIXME: escape characters -> Uri
 111                                 return get_code_base ();
 112                         }
 113                 }
 114
 115                 public virtual string FullName {
 116                         get {
 117                                 //
 118                                 // FIXME: This is wrong, but it gets us going
 119                                 // in the compiler for now
 120                                 //
 121                                 return GetName (false).ToString ();
 122                         }
 123                 }
 124
 125                 public virtual extern MethodInfo EntryPoint {
 126                         [MethodImplAttribute (MethodImplOptions.InternalCall)]
 127                         get;
 128                 }
 129
 130                 public virtual Evidence Evidence {
 131                         get {
 132                                 // if the host (runtime) hasn't provided it's own evidence...
 133                                 if (_evidence == null) {
 134                                         // ... we will provide our own
 135                                         lock (this) {
 136                                                 _evidence = Evidence.GetDefaultHostEvidence (this);
 137                                         }
 138                                 }
 139                                 return _evidence;
 140                         }
 141                 }
 142
 143                 public bool GlobalAssemblyCache {
 144                         get {
 145                                 return get_global_assembly_cache ();
 146                         }
 147                 }
 148
 149                 public virtual String Location {
 150                         get {
 151                                 return get_location ();
 152                         }
 153                 }
 154
 155 #if NET_1_1
 156                 [ComVisible (false)]
 157                 public virtual string ImageRuntimeVersion {
 158                         get {
 159                                 return InternalImageRuntimeVersion ();
 160                         }
 161                 }
 162 #endif
 163
 164                 public virtual void GetObjectData (SerializationInfo info, StreamingContext context)
 165                 {
 166                         UnitySerializationHolder.GetAssemblyData (this, info, context);
 167                 }
 168
 169                 public virtual bool IsDefined (Type attributeType, bool inherit)
 170                 {
 171                         return MonoCustomAttrs.IsDefined (this, attributeType, inherit);
 172                 }
 173
 174                 public virtual object [] GetCustomAttributes (bool inherit)
 175                 {
 176                         return MonoCustomAttrs.GetCustomAttributes (this, inherit);
 177                 }
 178
 179                 public virtual object [] GetCustomAttributes (Type attributeType, bool inherit)
 180                 {
 181                         return MonoCustomAttrs.GetCustomAttributes (this, attributeType, inherit);
 182                 }
 183
 184                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 185                 private extern object GetFilesInternal (String name, bool getResourceModules);
 186
 187                 public virtual FileStream[] GetFiles ()
 188                 {
 189                         return GetFiles (false);
 190                 }
 191
 192                 public virtual FileStream [] GetFiles (bool getResourceModules)
 193                 {
 194                         string[] names = (string[]) GetFilesInternal (null, getResourceModules);
 195                         if (names == null)
 196                                 return new FileStream [0];
 197
 198                         FileStream[] res = new FileStream [names.Length];
 199                         for (int i = 0; i < names.Length; ++i)
 200                                 res [i] = new FileStream (names [i], FileMode.Open, FileAccess.Read);
 201                         return res;
 202                 }
 203
 204                 public virtual FileStream GetFile (String name)
 205                 {
 206                         if (name == null)
 207                                 throw new ArgumentNullException ("name");
 208                         if (name.Length == 0)
 209                                 throw new ArgumentException ("name");
 210
 211                         string filename = (string)GetFilesInternal (name, true);
 212                         if (filename != null)
 213                                 return new FileStream (filename, FileMode.Open, FileAccess.Read);
 214                         else
 215                                 return null;
 216                 }
 217
 218                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 219                 private extern IntPtr GetManifestResourceInternal (String name, out int size, out Module module);
 220
 221                 public virtual Stream GetManifestResourceStream (String name)
 222                 {
 223                         if (name == null)
 224                                 throw new ArgumentNullException ("name");
 225                         if (name == "")
 226                                 throw new ArgumentException ("name cannot have zero length.");
 227
 228                         ManifestResourceInfo info = GetManifestResourceInfo (name);
 229                         if (info == null)
 230                                 return null;
 231
 232                         if (info.ReferencedAssembly != null)
 233                                 return info.ReferencedAssembly.GetManifestResourceStream (name);
 234                         if ((info.FileName != null) && (info.ResourceLocation == 0)) {
 235                                 string filename = Path.Combine (Path.GetDirectoryName (Location),
 236                                                                                         info.FileName);
 237                                 return new FileStream (filename, FileMode.Open, FileAccess.Read);
 238                         }
 239
 240                         int size;
 241                         Module module;
 242                         IntPtr data = GetManifestResourceInternal (name, out size, out module);
 243                         if (data == (IntPtr) 0)
 244                                 return null;
 245                         else {
 246                                 IntPtrStream stream = new IntPtrStream (data, size);
 247                                 /*
 248                                  * The returned pointer points inside metadata, so
 249                                  * we have to increase the refcount of the module, and decrease
 250                                  * it when the stream is finalized.
 251                                  */
 252                                 stream.Closed += new EventHandler (new ResourceCloseHandler (module).OnClose);
 253                                 return stream;
 254                         }
 255                 }
 256
 257                 public virtual Stream GetManifestResourceStream (Type type, String name)
 258                 {
 259                         string ns;
 260                         if (type != null)
 261                                 ns = type.Namespace;
 262                         else
 263                                 ns = null;
 264
 265                         if ((ns == null) || (ns == ""))
 266                                 return GetManifestResourceStream (name);
 267                         else
 268                                 return GetManifestResourceStream (ns + "." + name);
 269                 }
 270
 271                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 272                 private extern Type[] GetTypes (bool exportedOnly);
 273
 274                 public virtual Type[] GetTypes ()
 275                 {
 276                         return GetTypes (false);
 277                 }
 278
 279                 public virtual Type[] GetExportedTypes ()
 280                 {
 281                         return GetTypes (true);
 282                 }
 283
 284                 public virtual Type GetType (String name, Boolean throwOnError)
 285                 {
 286                         return GetType (name, throwOnError, false);
 287                 }
 288
 289                 public virtual Type GetType (String name) {
 290                         return GetType (name, false, false);
 291                 }
 292
 293                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 294                 internal extern Type InternalGetType (Module module, String name, Boolean throwOnError, Boolean ignoreCase);
 295
 296                 public Type GetType (string name, bool throwOnError, bool ignoreCase)
 297                 {
 298                         if (name == null)
 299                                 throw new ArgumentNullException (name);
 300
 301                         return InternalGetType (null, name, throwOnError, ignoreCase);
 302                 }
 303
 304                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 305                 internal extern static void InternalGetAssemblyName (string assemblyFile, AssemblyName aname);
 306
 307                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 308                 static extern void FillName (Assembly ass, AssemblyName aname);
 309
 310                 [MonoTODO ("true == not supported")]
 311                 public virtual AssemblyName GetName (Boolean copiedName)
 312                 {
 313                         AssemblyName aname = new AssemblyName ();
 314                         FillName (this, aname);
 315                         return aname;
 316                 }
 317
 318                 public virtual AssemblyName GetName ()
 319                 {
 320                         return GetName (false);
 321                 }
 322
 323                 public override String ToString ()
 324                 {
 325                         return GetName ().ToString ();
 326                 }
 327
 328                 public static String CreateQualifiedName (String assemblyName, String typeName)
 329                 {
 330                         return typeName + ", " + assemblyName;
 331                 }
 332
 333                 public static Assembly GetAssembly (Type type)
 334                 {
 335                         if (type != null)
 336                                 return type.Assembly;
 337                         throw new ArgumentNullException ("type");
 338                 }
 339
 340
 341                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 342                 public static extern Assembly GetEntryAssembly();
 343
 344                 public Assembly GetSatelliteAssembly (CultureInfo culture)
 345                 {
 346                         return GetSatelliteAssembly (culture, null);
 347                 }
 348
 349                 public Assembly GetSatelliteAssembly (CultureInfo culture, Version version)
 350                 {
 351                         if (culture == null)
 352                                 throw new ArgumentException ("culture");
 353
 354                         AssemblyName aname = GetName (true);
 355                         if (version != null)
 356                                 aname.Version = version;
 357
 358                         aname.CultureInfo = culture;
 359                         aname.Name = aname.Name + ".resources";
 360                         return Load (aname);
 361                 }
 362
 363                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 364                 public extern static Assembly LoadFrom (String assemblyFile);
 365
 366                 public static Assembly LoadFrom (String assemblyFile, Evidence securityEvidence)
 367                 {
 368                         Assembly a = LoadFrom (assemblyFile);
 369                         if ((a != null) && (securityEvidence != null)) {
 370                                 // merge evidence (i.e. replace defaults with provided evidences)
 371                                 a.Evidence.Merge (securityEvidence);
 372                         }
 373                         return a;
 374                 }
 375
 376 #if NET_1_1
 377
 378                 [MonoTODO]
 379                 public static Assembly LoadFrom (String assemblyFile, Evidence securityEvidence, byte[] hashValue, AssemblyHashAlgorithm hashAlgorithm)
 380                 {
 381                         if (assemblyFile == null)
 382                                 throw new ArgumentNullException ("assemblyFile");
 383                         if (assemblyFile == String.Empty)
 384                                 throw new ArgumentException ("Name can't be the empty string", "assemblyFile");
 385                         throw new NotImplementedException ();
 386                 }
 387
 388                 [MonoTODO]
 389                 public static Assembly LoadFile (String path, Evidence securityEvidence) {
 390                         if (path == null)
 391                                 throw new ArgumentNullException ("path");
 392                         if (path == String.Empty)
 393                                 throw new ArgumentException ("Path can't be empty", "path");
 394                         // FIXME: Make this do the right thing
 395                         return LoadFrom (path, securityEvidence);
 396                 }
 397
 398                 public static Assembly LoadFile (String path) {
 399                         return LoadFile (path, null);
 400                 }
 401 #endif
 402
 403                 public static Assembly Load (String assemblyString)
 404                 {
 405                         return AppDomain.CurrentDomain.Load (assemblyString);
 406                 }
 407
 408                 public static Assembly Load (String assemblyString, Evidence assemblySecurity)
 409                 {
 410                         return AppDomain.CurrentDomain.Load (assemblyString, assemblySecurity);
 411                 }
 412
 413                 public static Assembly Load (AssemblyName assemblyRef)
 414                 {
 415                         return AppDomain.CurrentDomain.Load (assemblyRef);
 416                 }
 417
 418                 public static Assembly Load (AssemblyName assemblyRef, Evidence assemblySecurity)
 419                 {
 420                         return AppDomain.CurrentDomain.Load (assemblyRef, assemblySecurity);
 421                 }
 422
 423                 public static Assembly Load (Byte[] rawAssembly)
 424                 {
 425                         return AppDomain.CurrentDomain.Load (rawAssembly);
 426                 }
 427
 428                 public static Assembly Load (Byte[] rawAssembly, Byte[] rawSymbolStore)
 429                 {
 430                         return AppDomain.CurrentDomain.Load (rawAssembly, rawSymbolStore);
 431                 }
 432
 433                 public static Assembly Load (Byte[] rawAssembly, Byte[] rawSymbolStore,
 434                                              Evidence securityEvidence)
 435                 {
 436                         return AppDomain.CurrentDomain.Load (rawAssembly, rawSymbolStore, securityEvidence);
 437                 }
 438
 439 #if NET_2_0
 440                 [MonoTODO]
 441                 public static Assembly ReflectionOnlyLoad (byte[] rawAssembly)
 442                 {
 443                         throw new NotImplementedException ();
 444                 }
 445
 446                 [MonoTODO]
 447                 public static Assembly ReflectionOnlyLoad (string assemblyString) {
 448                         throw new NotImplementedException ();
 449                 }
 450
 451                 [MonoTODO]
 452                 public static Assembly ReflectionOnlyLoadFrom (string assemblyFile) {
 453                         throw new NotImplementedException ();
 454                 }
 455 #endif
 456
 457 #if NET_2_0
 458                 [Obsolete ("")]
 459 #endif
 460                 public static Assembly LoadWithPartialName (string partialName)
 461                 {
 462                         return LoadWithPartialName (partialName, null);
 463                 }
 464
 465                 [MonoTODO]
 466                 public Module LoadModule (string moduleName, byte [] rawModule)
 467                 {
 468                         throw new NotImplementedException ();
 469                 }
 470
 471                 [MonoTODO]
 472                 public Module LoadModule (string moduleName, byte [] rawModule, byte [] rawSymbolStore)
 473                 {
 474                         throw new NotImplementedException ();
 475                 }
 476
 477                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 478                 private static extern Assembly load_with_partial_name (string name, Evidence e);
 479
 480 #if NET_2_0
 481                 [Obsolete ("")]
 482 #endif
 483                 public static Assembly LoadWithPartialName (string partialName, Evidence securityEvidence)
 484                 {
 485                         return LoadWithPartialName (partialName, securityEvidence, true);
 486                 }
 487
 488                 /**
 489                  * LAMESPEC: It is possible for this method to throw exceptions IF the name supplied
 490                  * is a valid gac name and contains filesystem entry charachters at the end of the name
 491                  * ie System/// will throw an exception. However ////System will not as that is canocolized
 492                  * out of the name.
 493                  */
 494 #if NET_2_0
 495                 [Obsolete ("")]
 496                 [ComVisible (false)]
 497                 [MonoTODO]
 498                 public
 499 #else
 500                 internal
 501 #endif
 502                 static Assembly LoadWithPartialName (string partialName, Evidence securityEvidence, bool oldBehavior)
 503                 {
 504                         if (!oldBehavior)
 505                                 throw new NotImplementedException ();
 506
 507                         if (partialName == null)
 508                                 throw new NullReferenceException ();
 509
 510                         int ci = partialName.IndexOf (',');
 511                         if (ci > 0)
 512                                 partialName = partialName.Substring (0, ci);
 513
 514                         return load_with_partial_name (partialName, securityEvidence);
 515                 }
 516
 517                 public Object CreateInstance (String typeName)
 518                 {
 519                         return CreateInstance (typeName, false);
 520                 }
 521
 522                 public Object CreateInstance (String typeName, Boolean ignoreCase)
 523                 {
 524                         Type t = GetType (typeName, false, ignoreCase);
 525                         if (t == null)
 526                                 return null;
 527
 528                         return Activator.CreateInstance (t);
 529                 }
 530
 531                 public Object CreateInstance (String typeName, Boolean ignoreCase,
 532                                               BindingFlags bindingAttr, Binder binder,
 533                                               Object[] args, CultureInfo culture,
 534                                               Object[] activationAttributes)
 535                 {
 536                         Type t = GetType (typeName, false, ignoreCase);
 537                         if (t == null)
 538                                 return null;
 539
 540                         return Activator.CreateInstance (t, bindingAttr, binder, args, culture, activationAttributes);
 541                 }
 542
 543                 public Module[] GetLoadedModules ()
 544                 {
 545                         return GetLoadedModules (false);
 546                 }
 547
 548                 [MonoTODO]
 549                 public Module[] GetLoadedModules (bool getResourceModules)
 550                 {
 551                         // Currently, the two sets of modules are equal
 552                         return GetModules (getResourceModules);
 553                 }
 554
 555                 public Module[] GetModules ()
 556                 {
 557                         return GetModules (false);
 558                 }
 559
 560                 public Module GetModule (String name)
 561                 {
 562                         if (name == null)
 563                                 throw new ArgumentNullException ("name");
 564                         if (name == "")
 565                                 throw new ArgumentException ("Name can't be empty");
 566
 567                         Module[] modules = GetModules (true);
 568                         foreach (Module module in modules) {
 569                                 if (module.ScopeName == name)
 570                                         return module;
 571                         }
 572
 573                         return null;
 574                 }
 575
 576                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 577                 internal extern Module[] GetModulesInternal ();
 578
 579                 public Module[] GetModules (bool getResourceModules) {
 580                         Module[] modules = GetModulesInternal ();
 581
 582                         if (!getResourceModules) {
 583                                 ArrayList result = new ArrayList (modules.Length);
 584                                 foreach (Module m in modules)
 585                                         if (!m.IsResource ())
 586                                                 result.Add (m);
 587                                 return (Module[])result.ToArray (typeof (Module));
 588                         }
 589                         else
 590                                 return modules;
 591                 }
 592
 593                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 594                 internal extern string[] GetNamespaces ();
 595
 596                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 597                 public extern virtual String[] GetManifestResourceNames ();
 598
 599                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 600                 public extern static Assembly GetExecutingAssembly ();
 601
 602                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 603                 public extern static Assembly GetCallingAssembly ();
 604
 605                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 606                 public extern AssemblyName[] GetReferencedAssemblies ();
 607
 608                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 609                 private extern bool GetManifestResourceInfoInternal (String name, ManifestResourceInfo info);
 610
 611                 public virtual ManifestResourceInfo GetManifestResourceInfo (String resourceName)
 612                 {
 613                         if (resourceName == null)
 614                                 throw new ArgumentNullException ("resourceName");
 615                         if (resourceName == "")
 616                                 throw new ArgumentException ("String cannot have zero length.");
 617                         ManifestResourceInfo result = new ManifestResourceInfo ();
 618                         bool found = GetManifestResourceInfoInternal (resourceName, result);
 619                         if (found)
 620                                 return result;
 621                         else
 622                                 return null;
 623                 }
 624
 625                 private class ResourceCloseHandler {
 626
 627                         Module module;
 628
 629                         public ResourceCloseHandler (Module module) {
 630                                 this.module = module;
 631                         }
 632
 633                         public void OnClose (object sender, EventArgs e) {
 634                                 // The module dtor will take care of things
 635                                 module = null;
 636                         }
 637                 }
 638
 639                 //
 640                 // The following functions are only for the Mono Debugger.
 641                 //
 642
 643                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 644                 internal static extern MethodBase MonoDebugger_GetMethod (Assembly assembly, int token);
 645
 646                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 647                 internal static extern int MonoDebugger_GetMethodToken (Assembly assembly, MethodBase method);
 648
 649                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 650                 internal static extern Type MonoDebugger_GetLocalTypeFromSignature (Assembly assembly, byte[] signature);
 651
 652                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 653                 internal static extern Type MonoDebugger_GetType (Assembly assembly, int token);
 654
 655                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 656                 internal static extern string MonoDebugger_CheckRuntimeVersion (string filename);
 657
 658 #if NET_2_0
 659                 [MonoTODO]
 660                 [ComVisible (false)]
 661                 public long HostContext {
 662                         get { return 0; }
 663                 }
 664
 665                 [ComVisible (false)]
 666                 public ImageFileMachine ImageFileMachine {
 667                         get {
 668                                 ImageFileMachine machine;
 669                                 PortableExecutableKind kind;
 670                                 ModuleHandle handle = ManifestModule.ModuleHandle;
 671                                 handle.GetPEKind (out kind, out machine);
 672                                 return machine;
 673                         }
 674                 }
 675
 676                 [ComVisible (false)]
 677                 public extern Module ManifestModule {
 678                         [MethodImplAttribute (MethodImplOptions.InternalCall)]
 679                         get;
 680                 }
 681
 682                 [ComVisible (false)]
 683                 public extern int MetadataToken {
 684                         [MethodImplAttribute (MethodImplOptions.InternalCall)]
 685                         get;
 686                 }
 687
 688                 [ComVisible (false)]
 689                 public PortableExecutableKind PortableExecutableKind {
 690                         get {
 691                                 ImageFileMachine machine;
 692                                 PortableExecutableKind kind;
 693                                 ModuleHandle handle = ManifestModule.ModuleHandle;
 694                                 handle.GetPEKind (out kind, out machine);
 695                                 return kind;
 696                         }
 697                 }
 698
 699                 [MonoTODO ("see ReflectionOnlyLoad")]
 700                 [ComVisible (false)]
 701                 public virtual bool ReflectionOnly {
 702                         get { return false; }
 703                 }
 704 #endif
 705
 706                 // Code Access Security
 707
 708                 internal void Resolve ()
 709                 {
 710                         lock (this) {
 711                                 _granted = SecurityManager.ResolvePolicy (Evidence, _minimum, _optional,
 712                                         _refuse, out _denied);
 713                         }
 714 #if false
 715                         Console.WriteLine ("Granted: {0}", _granted);
 716                         if (_denied != null)
 717                                 Console.WriteLine ("Denied: {0}", _denied);
 718 #endif
 719                 }
 720
 721                 internal PermissionSet GrantedPermissionSet {
 722                         get {
 723                                 if (_granted == null) {
 724                                         Resolve ();
 725                                 }
 726                                 return _granted;
 727                         }
 728                 }
 729
 730                 internal PermissionSet DeniedPermissionSet {
 731                         get {
 732                                 // yes we look for granted, as denied may be null
 733                                 if (_granted == null) {
 734                                         Resolve ();
 735                                 }
 736                                 return _denied;
 737                         }
 738                 }
 739
 740                 // Result isn't affected by overrides (like Assert, Deny and PermitOnly)
 741                 internal bool Demand (IPermission p)
 742                 {
 743                         Type t = p.GetType ();
 744
 745                         // have we been explicitely denied this permission ?
 746                         if (_denied != null) {
 747                                 IPermission denied = _denied.GetPermission (t);
 748                                 if (denied != null) {
 749                                         if (p.IsSubsetOf (denied))
 750                                                 return false;
 751                                 }
 752                         }
 753
 754                         // is it part of the optional permissions requested by the assembly ?
 755                         if (_optional != null) {
 756                                 IPermission optional = _optional.GetPermission (t);
 757                                 if (optional != null) {
 758                                         // there is! so we can only request a subset of it
 759                                         if (!p.IsSubsetOf (optional))
 760                                                 return false;
 761                                 }
 762                         }
 763
 764                         // don't check IUnrestrictedPermission if we have "Full Trust"
 765                         // note: that won't work for code identity permissions (e.g. Zone)
 766                         if ((p is IUnrestrictedPermission) && GrantedPermissionSet.IsUnrestricted ())
 767                                 return true;
 768
 769                         // finally does the resolved policy allow this requested permission ?
 770                         IPermission granted = GrantedPermissionSet.GetPermission (t);
 771                         if (granted != null) {
 772                                 if (!p.IsSubsetOf (granted))
 773                                         return false;
 774                         }
 775                         return true;
 776                 }
 777
 778                 // Result isn't affected by overrides (like Assert, Deny and PermitOnly)
 779                 internal bool Demand (PermissionSet ps)
 780                 {
 781                         // have we been explicitely denied this permission ?
 782                         if (DeniedPermissionSet != null) {
 783                                 if (ps.IsSubsetOf (DeniedPermissionSet)) {
 784                                         return false;
 785                                 }
 786                         }
 787
 788                         // is it part of the optional permissions requested by the assembly ?
 789                         if (_optional != null) {
 790                                 // there is! so we can only request a subset of it
 791                                 if (!ps.IsSubsetOf (_optional)) {
 792                                         return false;
 793                                 }
 794                         }
 795
 796                         return ps.IsSubsetOf (GrantedPermissionSet);
 797                 }
 798         }
 799 }