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-2005 Novell, Inc (http://www.novell.com)
   9 // Copyright 2011 Xamarin Inc (http://www.xamarin.com).
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30
  31 using System.Security;
  32 using System.Security.Policy;
  33 using System.Security.Permissions;
  34 using System.Runtime.Serialization;
  35 using System.Reflection;
  36 using System.IO;
  37 using System.Globalization;
  38 using System.Runtime.CompilerServices;
  39 using System.Runtime.InteropServices;
  40 using System.Collections.Generic;
  41 using System.Configuration.Assemblies;
  42 using System.Threading;
  43 using System.Text;
  44 using System.Diagnostics.Contracts;
  45
  46 using Mono.Security;
  47
  48 namespace System.Reflection {
  49
  50         [ComVisible (true)]
  51         [ComDefaultInterfaceAttribute (typeof (_Assembly))]
  52         [Serializable]
  53         [ClassInterface(ClassInterfaceType.None)]
  54         [StructLayout (LayoutKind.Sequential)]
  55 #if MOBILE
  56         public partial class Assembly : ICustomAttributeProvider, ISerializable
  57 #else
  58         public abstract class Assembly : ICustomAttributeProvider, _Assembly, IEvidenceFactory, ISerializable
  59 #endif
  60         {
  61                 internal class ResolveEventHolder {
  62 #pragma warning disable 67
  63                         public event ModuleResolveEventHandler ModuleResolve;
  64 #pragma warning restore
  65                 }
  66
  67                 //
  68                 // We can't store the event directly in this class, since the
  69                 // compiler would silently insert the fields before _mono_assembly
  70                 //
  71                 public virtual event ModuleResolveEventHandler ModuleResolve {
  72                         [SecurityPermission (SecurityAction.LinkDemand, ControlAppDomain = true)]
  73                         add {
  74                                 throw new NotImplementedException ();
  75                         }
  76                         [SecurityPermission (SecurityAction.LinkDemand, ControlAppDomain = true)]
  77                         remove {
  78                                 throw new NotImplementedException ();
  79                         }
  80                 }
  81
  82                 public virtual string CodeBase {
  83                         get {
  84                                 throw new NotImplementedException ();
  85                         }
  86                 }
  87
  88                 public virtual string EscapedCodeBase {
  89                         get {
  90                                 throw new NotImplementedException ();
  91                         }
  92                 }
  93
  94                 public virtual string FullName {
  95                         get {
  96                                 throw new NotImplementedException ();
  97                         }
  98                 }
  99
 100                 public virtual MethodInfo EntryPoint {
 101                         get {
 102                                 throw new NotImplementedException ();
 103                         }
 104                 }
 105
 106                 public virtual Evidence Evidence {
 107                         [SecurityPermission (SecurityAction.Demand, ControlEvidence = true)]
 108                         get {
 109                                 throw new NotImplementedException ();
 110                         }
 111                 }
 112
 113                 internal virtual Evidence UnprotectedGetEvidence ()
 114                 {
 115                         throw new NotImplementedException ();
 116                 }
 117
 118                 internal virtual IntPtr MonoAssembly {
 119                         get {
 120                                 throw new NotImplementedException ();
 121                         }
 122                 }
 123
 124                 internal virtual bool FromByteArray {
 125                         set {
 126                                 throw new NotImplementedException ();
 127                         }
 128                 }
 129
 130                 public virtual String Location {
 131                         get {
 132                                 throw new NotImplementedException ();
 133                         }
 134                 }
 135
 136                 [ComVisible (false)]
 137                 public virtual string ImageRuntimeVersion {
 138                         get {
 139                                 throw new NotImplementedException ();
 140                         }
 141                 }
 142
 143                 public virtual void GetObjectData (SerializationInfo info, StreamingContext context)
 144                 {
 145                         throw new NotImplementedException ();
 146                 }
 147
 148                 public virtual bool IsDefined (Type attributeType, bool inherit)
 149                 {
 150                         throw new NotImplementedException ();
 151                 }
 152
 153                 public virtual object [] GetCustomAttributes (bool inherit)
 154                 {
 155                         throw new NotImplementedException ();
 156                 }
 157
 158                 public virtual object [] GetCustomAttributes (Type attributeType, bool inherit)
 159                 {
 160                         throw new NotImplementedException ();
 161                 }
 162
 163                 public virtual FileStream[] GetFiles ()
 164                 {
 165                         return GetFiles (false);
 166                 }
 167
 168                 public virtual FileStream [] GetFiles (bool getResourceModules)
 169                 {
 170                         throw new NotImplementedException ();
 171                 }
 172
 173                 public virtual FileStream GetFile (String name)
 174                 {
 175                         throw new NotImplementedException ();
 176                 }
 177
 178                 public virtual Stream GetManifestResourceStream (String name)
 179                 {
 180                         throw new NotImplementedException ();
 181                 }
 182
 183                 public virtual Stream GetManifestResourceStream (Type type, String name)
 184                 {
 185                         throw new NotImplementedException ();
 186                 }
 187
 188                 internal Stream GetManifestResourceStream (Type type, String name, bool skipSecurityCheck, ref StackCrawlMark stackMark)
 189                 {
 190                         StringBuilder sb = new StringBuilder ();
 191                         if (type == null) {
 192                                 if (name == null)
 193                                                 throw new ArgumentNullException ("type");
 194                         } else {
 195                                 String nameSpace = type.Namespace;
 196                                 if (nameSpace != null) {
 197                                         sb.Append (nameSpace);
 198                                         if (name != null)
 199                                                 sb.Append (Type.Delimiter);
 200                                 }
 201                         }
 202
 203                         if (name != null)
 204                                 sb.Append(name);
 205
 206                         return GetManifestResourceStream (sb.ToString());
 207                 }
 208
 209                 internal unsafe Stream GetManifestResourceStream(String name, ref StackCrawlMark stackMark, bool skipSecurityCheck)
 210                 {
 211                         return GetManifestResourceStream (null, name, skipSecurityCheck, ref stackMark);
 212                 }
 213
 214                 internal String GetSimpleName()
 215                 {
 216                         AssemblyName aname = GetName (true);
 217                         return aname.Name;
 218                 }
 219
 220                 internal byte[] GetPublicKey()
 221                 {
 222                         AssemblyName aname = GetName (true);
 223                         return aname.GetPublicKey ();
 224                 }
 225
 226                 internal Version GetVersion()
 227                 {
 228                         AssemblyName aname = GetName (true);
 229                         return aname.Version;
 230                 }
 231
 232                 private AssemblyNameFlags GetFlags()
 233                 {
 234                         AssemblyName aname = GetName (true);
 235                         return aname.Flags;
 236                 }
 237
 238                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 239                 internal virtual extern Type[] GetTypes (bool exportedOnly);
 240
 241                 public virtual Type[] GetTypes ()
 242                 {
 243                         return GetTypes (false);
 244                 }
 245
 246                 public virtual Type[] GetExportedTypes ()
 247                 {
 248                         throw new NotImplementedException ();
 249                 }
 250
 251                 public virtual Type GetType (String name, Boolean throwOnError)
 252                 {
 253                         return GetType (name, throwOnError, false);
 254                 }
 255
 256                 public virtual Type GetType (String name) {
 257                         return GetType (name, false, false);
 258                 }
 259
 260                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 261                 internal extern Type InternalGetType (Module module, String name, Boolean throwOnError, Boolean ignoreCase);
 262
 263                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 264                 internal extern unsafe static void InternalGetAssemblyName (string assemblyFile, out Mono.MonoAssemblyName aname, out string codebase);
 265
 266                 public virtual AssemblyName GetName (Boolean copiedName)
 267                 {
 268                         throw new NotImplementedException ();
 269                 }
 270
 271                 public virtual AssemblyName GetName ()
 272                 {
 273                         return GetName (false);
 274                 }
 275
 276                 public override string ToString ()
 277                 {
 278                         return base.ToString ();
 279                 }
 280
 281                 public static String CreateQualifiedName (String assemblyName, String typeName)
 282                 {
 283                         return typeName + ", " + assemblyName;
 284                 }
 285
 286                 public static Assembly GetAssembly (Type type)
 287                 {
 288                         if (type != null)
 289                                 return type.Assembly;
 290                         throw new ArgumentNullException ("type");
 291                 }
 292
 293
 294                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 295                 public static extern Assembly GetEntryAssembly();
 296
 297                 internal Assembly GetSatelliteAssembly (CultureInfo culture, Version version, bool throwOnError, ref StackCrawlMark stackMark)
 298                 {
 299                         if (culture == null)
 300                                 throw new ArgumentNullException("culture");
 301                         Contract.EndContractBlock();
 302
 303                         String name = GetSimpleName() + ".resources";
 304                         return InternalGetSatelliteAssembly(name, culture, version, true, ref stackMark);
 305                 }
 306
 307                 internal RuntimeAssembly InternalGetSatelliteAssembly (String name, CultureInfo culture, Version version, bool throwOnFileNotFound, ref StackCrawlMark stackMark)
 308                 {
 309                         AssemblyName an = new AssemblyName ();
 310
 311                         an.SetPublicKey (GetPublicKey ());
 312                         an.Flags = GetFlags () | AssemblyNameFlags.PublicKey;
 313
 314                         if (version == null)
 315                                 an.Version = GetVersion ();
 316                         else
 317                                 an.Version = version;
 318
 319                         an.CultureInfo = culture;
 320                         an.Name = name;
 321
 322                         Assembly assembly;
 323
 324                         try {
 325                                 assembly = AppDomain.CurrentDomain.LoadSatellite (an, false, ref stackMark);
 326                                 if (assembly != null)
 327                                         return (RuntimeAssembly)assembly;
 328                         } catch (FileNotFoundException) {
 329                                 assembly = null;
 330                                 // ignore
 331                         }
 332
 333                         if (String.IsNullOrEmpty (Location))
 334                                 return null;
 335
 336                         // Try the assembly directory
 337                         string location = Path.GetDirectoryName (Location);
 338                         string fullName = Path.Combine (location, Path.Combine (culture.Name, an.Name + ".dll"));
 339
 340                         try {
 341                                 return (RuntimeAssembly)LoadFrom (fullName, false, ref stackMark);
 342                         } catch {
 343                                 if (!throwOnFileNotFound && !File.Exists (fullName))
 344                                         return null;
 345                                 throw;
 346                         }
 347                 }
 348
 349 #if !MOBILE
 350                 Type _Assembly.GetType ()
 351                 {
 352                         // Required or object::GetType becomes virtual final
 353                         return base.GetType ();
 354                 }
 355 #endif
 356
 357                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 358                 private extern static Assembly LoadFrom (String assemblyFile, bool refOnly, ref StackCrawlMark stackMark);
 359
 360                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 361                 private extern static Assembly LoadFile_internal (String assemblyFile, ref StackCrawlMark stackMark);
 362
 363                 [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
 364                 public static Assembly LoadFrom (String assemblyFile)
 365                 {
 366                         StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
 367                         return LoadFrom (assemblyFile, false, ref stackMark);
 368                 }
 369
 370                 [Obsolete]
 371                 [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
 372                 public static Assembly LoadFrom (String assemblyFile, Evidence securityEvidence)
 373                 {
 374                         StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
 375                         Assembly a = LoadFrom (assemblyFile, false, ref stackMark);
 376 #if !MOBILE
 377                         if ((a != null) && (securityEvidence != null)) {
 378                                 // merge evidence (i.e. replace defaults with provided evidences)
 379                                 a.Evidence.Merge (securityEvidence);
 380                         }
 381 #endif
 382                         return a;
 383                 }
 384
 385                 [Obsolete]
 386                 [MonoTODO("This overload is not currently implemented")]
 387                 // FIXME: What are we missing?
 388                 public static Assembly LoadFrom (String assemblyFile, Evidence securityEvidence, byte[] hashValue, AssemblyHashAlgorithm hashAlgorithm)
 389                 {
 390                         throw new NotImplementedException ();
 391                 }
 392
 393                 [MonoTODO]
 394                 public static Assembly LoadFrom (String assemblyFile, byte [] hashValue, AssemblyHashAlgorithm hashAlgorithm)
 395                 {
 396                         throw new NotImplementedException ();
 397                 }
 398
 399                 [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
 400                 public static Assembly UnsafeLoadFrom (String assemblyFile)
 401                 {
 402                         StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
 403                         return LoadFrom (assemblyFile, false, ref stackMark);
 404                 }
 405
 406                 [Obsolete]
 407                 [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
 408                 public static Assembly LoadFile (String path, Evidence securityEvidence)
 409                 {
 410                         if (path == null)
 411                                 throw new ArgumentNullException ("path");
 412                         if (path == String.Empty)
 413                                 throw new ArgumentException ("Path can't be empty", "path");
 414                         StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
 415                         Assembly a = LoadFile_internal (path, ref stackMark);
 416                         if (a != null && securityEvidence != null) {
 417                                 throw new NotImplementedException ();
 418                         }
 419                         return a;
 420                 }
 421
 422                 public static Assembly LoadFile (String path)
 423                 {
 424                         return LoadFile (path, null);
 425                 }
 426
 427                 public static Assembly Load (String assemblyString)
 428                 {
 429                         return AppDomain.CurrentDomain.Load (assemblyString);
 430                 }
 431
 432                 [Obsolete]
 433                 public static Assembly Load (String assemblyString, Evidence assemblySecurity)
 434                 {
 435                         return AppDomain.CurrentDomain.Load (assemblyString, assemblySecurity);
 436                 }
 437
 438                 public static Assembly Load (AssemblyName assemblyRef)
 439                 {
 440                         return AppDomain.CurrentDomain.Load (assemblyRef);
 441                 }
 442
 443                 [Obsolete]
 444                 public static Assembly Load (AssemblyName assemblyRef, Evidence assemblySecurity)
 445                 {
 446                         return AppDomain.CurrentDomain.Load (assemblyRef, assemblySecurity);
 447                 }
 448
 449                 public static Assembly Load (Byte[] rawAssembly)
 450                 {
 451                         return AppDomain.CurrentDomain.Load (rawAssembly);
 452                 }
 453
 454                 public static Assembly Load (Byte[] rawAssembly, Byte[] rawSymbolStore)
 455                 {
 456                         return AppDomain.CurrentDomain.Load (rawAssembly, rawSymbolStore);
 457                 }
 458
 459                 [Obsolete]
 460                 public static Assembly Load (Byte[] rawAssembly, Byte[] rawSymbolStore,
 461                                              Evidence securityEvidence)
 462                 {
 463                         return AppDomain.CurrentDomain.Load (rawAssembly, rawSymbolStore, securityEvidence);
 464                 }
 465
 466                 [MonoLimitation ("Argument securityContextSource is ignored")]
 467                 public static Assembly Load (byte [] rawAssembly, byte [] rawSymbolStore, SecurityContextSource securityContextSource)
 468                 {
 469                         return AppDomain.CurrentDomain.Load (rawAssembly, rawSymbolStore);
 470                 }
 471
 472                 public static Assembly ReflectionOnlyLoad (byte[] rawAssembly)
 473                 {
 474                         return AppDomain.CurrentDomain.Load (rawAssembly, null, null, true);
 475                 }
 476
 477                 [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
 478                 public static Assembly ReflectionOnlyLoad (string assemblyString)
 479                 {
 480                         StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
 481                         return AppDomain.CurrentDomain.Load (assemblyString, null, true, ref stackMark);
 482                 }
 483
 484                 [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
 485                 public static Assembly ReflectionOnlyLoadFrom (string assemblyFile)
 486                 {
 487                         if (assemblyFile == null)
 488                                 throw new ArgumentNullException ("assemblyFile");
 489
 490                         StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
 491                         return LoadFrom (assemblyFile, true, ref stackMark);
 492                 }
 493
 494         [Obsolete("This method has been deprecated. Please use Assembly.Load() instead. http://go.microsoft.com/fwlink/?linkid=14202")]
 495                 public static Assembly LoadWithPartialName (string partialName)
 496                 {
 497                         return LoadWithPartialName (partialName, null);
 498                 }
 499
 500                 [MonoTODO ("Not implemented")]
 501                 public Module LoadModule (string moduleName, byte [] rawModule)
 502                 {
 503                         throw new NotImplementedException ();
 504                 }
 505
 506                 [MonoTODO ("Not implemented")]
 507                 public
 508                 virtual
 509                 Module LoadModule (string moduleName, byte [] rawModule, byte [] rawSymbolStore)
 510                 {
 511                         throw new NotImplementedException ();
 512                 }
 513
 514                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 515                 private static extern Assembly load_with_partial_name (string name, Evidence e);
 516
 517         [Obsolete("This method has been deprecated. Please use Assembly.Load() instead. http://go.microsoft.com/fwlink/?linkid=14202")]
 518                 public static Assembly LoadWithPartialName (string partialName, Evidence securityEvidence)
 519                 {
 520                         return LoadWithPartialName (partialName, securityEvidence, true);
 521                 }
 522
 523                 /**
 524                  * LAMESPEC: It is possible for this method to throw exceptions IF the name supplied
 525                  * is a valid gac name and contains filesystem entry charachters at the end of the name
 526                  * ie System/// will throw an exception. However ////System will not as that is canocolized
 527                  * out of the name.
 528                  */
 529
 530                 // FIXME: LoadWithPartialName must look cache (no CAS) or read from disk (CAS)
 531                 internal static Assembly LoadWithPartialName (string partialName, Evidence securityEvidence, bool oldBehavior)
 532                 {
 533                         if (!oldBehavior)
 534                                 throw new NotImplementedException ();
 535
 536                         if (partialName == null)
 537                                 throw new NullReferenceException ();
 538
 539                         return load_with_partial_name (partialName, securityEvidence);
 540                 }
 541
 542                 public Object CreateInstance (String typeName)
 543                 {
 544                         return CreateInstance (typeName, false);
 545                 }
 546
 547                 public Object CreateInstance (String typeName, Boolean ignoreCase)
 548                 {
 549                         Type t = GetType (typeName, false, ignoreCase);
 550                         if (t == null)
 551                                 return null;
 552
 553                         try {
 554                                 return Activator.CreateInstance (t);
 555                         } catch (InvalidOperationException) {
 556                                 throw new ArgumentException ("It is illegal to invoke a method on a Type loaded via ReflectionOnly methods.");
 557                         }
 558                 }
 559
 560                 public
 561                 virtual
 562                 Object CreateInstance (String typeName, Boolean ignoreCase,
 563                                               BindingFlags bindingAttr, Binder binder,
 564                                               Object[] args, CultureInfo culture,
 565                                               Object[] activationAttributes)
 566                 {
 567                         Type t = GetType (typeName, false, ignoreCase);
 568                         if (t == null)
 569                                 return null;
 570
 571                         try {
 572                                 return Activator.CreateInstance (t, bindingAttr, binder, args, culture, activationAttributes);
 573                         } catch (InvalidOperationException) {
 574                                 throw new ArgumentException ("It is illegal to invoke a method on a Type loaded via ReflectionOnly methods.");
 575                         }
 576                 }
 577
 578                 public Module[] GetLoadedModules ()
 579                 {
 580                         return GetLoadedModules (false);
 581                 }
 582
 583                 public Module[] GetModules ()
 584                 {
 585                         return GetModules (false);
 586                 }
 587
 588                 internal virtual Module[] GetModulesInternal () {
 589                         throw new NotImplementedException ();
 590                 }
 591
 592                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 593                 public extern static Assembly GetExecutingAssembly ();
 594
 595                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 596                 public extern static Assembly GetCallingAssembly ();
 597
 598                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 599                 internal static extern IntPtr InternalGetReferencedAssemblies (Assembly module);
 600
 601                 public virtual String[] GetManifestResourceNames ()
 602                 {
 603                         throw new NotImplementedException ();
 604                 }
 605
 606                 internal static AssemblyName[] GetReferencedAssemblies (Assembly module)
 607                 {
 608                         using (var nativeNames = new Mono.SafeGPtrArrayHandle (InternalGetReferencedAssemblies (module))) {
 609                                 var numAssemblies = nativeNames.Length;
 610                                 try {
 611                                         AssemblyName [] result = new AssemblyName[numAssemblies];
 612                                         const bool addVersion = true;
 613                                         const bool addPublicKey = false;
 614                                         const bool defaultToken = true;
 615                                         const bool assemblyRef = true;
 616                                         for (int i = 0; i < numAssemblies; i++) {
 617                                                 AssemblyName name = new AssemblyName ();
 618                                                 unsafe {
 619                                                         Mono.MonoAssemblyName *nativeName = (Mono.MonoAssemblyName*) nativeNames[i];
 620                                                         name.FillName (nativeName, null, addVersion, addPublicKey, defaultToken, assemblyRef);
 621                                                         result[i] = name;
 622                                                 }
 623                                         }
 624                                         return result;
 625                                 } finally {
 626                                         for (int i = 0; i < numAssemblies; i++) {
 627                                                 unsafe {
 628                                                         Mono.MonoAssemblyName* nativeName = (Mono.MonoAssemblyName*) nativeNames[i];
 629                                                         Mono.RuntimeMarshal.FreeAssemblyName (ref *nativeName, true);
 630                                                 }
 631                                         }
 632                                 }
 633                         }
 634                 }
 635
 636                 public virtual ManifestResourceInfo GetManifestResourceInfo (String resourceName)
 637                 {
 638                         throw new NotImplementedException ();
 639                 }
 640
 641                 [MonoTODO ("Currently it always returns zero")]
 642                 [ComVisible (false)]
 643                 public
 644                 virtual
 645                 long HostContext {
 646                         get { return 0; }
 647                 }
 648
 649                 internal virtual Module GetManifestModule () {
 650                         throw new NotImplementedException ();
 651                 }
 652
 653                 [ComVisible (false)]
 654                 public virtual bool ReflectionOnly {
 655                         get {
 656                                 throw new NotImplementedException ();
 657                         }
 658                 }
 659
 660                 public override int GetHashCode ()
 661                 {
 662                         return base.GetHashCode ();
 663                 }
 664
 665                 public override bool Equals (object o)
 666                 {
 667                         return base.Equals (o);
 668                 }
 669
 670 #if !MOBILE
 671                 internal virtual PermissionSet GrantedPermissionSet {
 672                         get {
 673                                 throw new NotImplementedException ();
 674                         }
 675                 }
 676
 677                 internal virtual PermissionSet DeniedPermissionSet {
 678                         get {
 679                                 throw new NotImplementedException ();
 680                         }
 681                 }
 682
 683                 public virtual PermissionSet PermissionSet {
 684                         get {
 685                                 throw new NotImplementedException ();
 686                         }
 687                 }
 688 #endif
 689
 690                 public virtual SecurityRuleSet SecurityRuleSet {
 691                         get { throw CreateNIE (); }
 692                 }
 693
 694                 static Exception CreateNIE ()
 695                 {
 696                         return new NotImplementedException ("Derived classes must implement it");
 697                 }
 698
 699                 public virtual IList<CustomAttributeData> GetCustomAttributesData ()
 700                 {
 701                         throw new NotImplementedException ();
 702                 }
 703
 704                 [MonoTODO]
 705                 public bool IsFullyTrusted {
 706                         get { return true; }
 707                 }
 708
 709                 public virtual Type GetType (string name, bool throwOnError, bool ignoreCase)
 710                 {
 711                         throw CreateNIE ();
 712                 }
 713
 714                 public virtual Module GetModule (String name)
 715                 {
 716                         throw CreateNIE ();
 717                 }
 718
 719                 public virtual AssemblyName[] GetReferencedAssemblies ()
 720                 {
 721                         throw CreateNIE ();
 722                 }
 723
 724                 public virtual Module[] GetModules (bool getResourceModules)
 725                 {
 726                         throw CreateNIE ();
 727                 }
 728
 729                 [MonoTODO ("Always returns the same as GetModules")]
 730                 public virtual Module[] GetLoadedModules (bool getResourceModules)
 731                 {
 732                         throw CreateNIE ();
 733                 }
 734
 735                 public virtual Assembly GetSatelliteAssembly (CultureInfo culture)
 736                 {
 737                         throw CreateNIE ();
 738                 }
 739
 740                 public virtual Assembly GetSatelliteAssembly (CultureInfo culture, Version version)
 741                 {
 742                         throw CreateNIE ();
 743                 }
 744
 745                 public virtual Module ManifestModule {
 746                         get { throw CreateNIE (); }
 747                 }
 748
 749                 public virtual bool GlobalAssemblyCache {
 750                         get { throw CreateNIE (); }
 751                 }
 752
 753                 public virtual bool IsDynamic {
 754                         get { return false; }
 755                 }
 756
 757                 public static bool operator == (Assembly left, Assembly right)
 758                 {
 759                         if ((object)left == (object)right)
 760                                 return true;
 761                         if ((object)left == null ^ (object)right == null)
 762                                 return false;
 763                         return left.Equals (right);
 764                 }
 765
 766                 public static bool operator != (Assembly left, Assembly right)
 767                 {
 768                         if ((object)left == (object)right)
 769                                 return false;
 770                         if ((object)left == null ^ (object)right == null)
 771                                 return true;
 772                         return !left.Equals (right);
 773                 }
 774
 775                 public virtual IEnumerable<TypeInfo> DefinedTypes {
 776                         get {
 777                                 foreach (var type in GetTypes ()) {
 778                                         yield return type.GetTypeInfo ();
 779                                 }
 780                         }
 781                 }
 782
 783                 public virtual IEnumerable<Type> ExportedTypes {
 784                         get { return GetExportedTypes (); }
 785                 }
 786
 787                 public virtual IEnumerable<Module> Modules {
 788                         get { return GetModules (); }
 789                 }
 790
 791                 public virtual IEnumerable<CustomAttributeData> CustomAttributes {
 792                         get { return GetCustomAttributesData (); }
 793                 }
 794
 795                 public virtual Type[] GetForwardedTypes() => throw new PlatformNotSupportedException();
 796         }
 797 }