mcs/class/corlib/System/AppDomain.cs

   1 //
   2 // System/AppDomain.cs
   3 //
   4 // Authors:
   5 //   Paolo Molaro (lupus@ximian.com)
   6 //   Dietmar Maurer (dietmar@ximian.com)
   7 //   Miguel de Icaza (miguel@ximian.com)
   8 //   Gonzalo Paniagua (gonzalo@ximian.com)
   9 //
  10 // (C) 2001, 2002 Ximian, Inc.  http://www.ximian.com
  11 //
  12
  13 using System;
  14 using System.Collections;
  15 using System.Globalization;
  16 using System.Reflection;
  17 using System.Reflection.Emit;
  18 using System.Runtime.CompilerServices;
  19 using System.Runtime.Remoting;
  20 using System.Security.Principal;
  21 using System.Security.Policy;
  22 using System.Security;
  23
  24 namespace System {
  25
  26         public sealed class AppDomain : MarshalByRefObject , _AppDomain , IEvidenceFactory {
  27
  28                 IntPtr _mono_app_domain;
  29
  30                 // Evidence evidence;
  31
  32                 private AppDomain () {}
  33
  34                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
  35                 private extern AppDomainSetup getSetup ();
  36
  37                 public AppDomainSetup SetupInformation {
  38
  39                         get {
  40                                 return getSetup ();
  41                         }
  42                 }
  43
  44                 public string BaseDirectory {
  45
  46                         get {
  47                                 return SetupInformation.ApplicationBase;
  48                         }
  49                 }
  50
  51                 public string RelativeSearchPath {
  52
  53                         get {
  54                                 return SetupInformation.PrivateBinPath;
  55                         }
  56                 }
  57
  58                 public string DynamicDirectory {
  59
  60                         get {
  61                                 // fixme: dont know if this is right?
  62                                 return SetupInformation.DynamicBase;
  63                         }
  64                 }
  65
  66                 public bool ShadowCopyFiles {
  67
  68                         get {
  69                                 if (SetupInformation.ShadowCopyFiles == "true")
  70                                         return true;
  71                                 return false;
  72                         }
  73                 }
  74
  75                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
  76                 private extern string getFriendlyName ();
  77
  78                 public string FriendlyName {
  79
  80                         get {
  81                                 return getFriendlyName ();
  82                         }
  83                 }
  84
  85                 public Evidence Evidence {
  86
  87                         get {
  88                                 return null;
  89                                 //return evidence;
  90                         }
  91                 }
  92
  93                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
  94                 private static extern AppDomain getCurDomain ();
  95
  96                 public static AppDomain CurrentDomain
  97                 {
  98                         get {
  99                                 return getCurDomain ();
 100                         }
 101                 }
 102
 103                 [MonoTODO]
 104                 public void AppendPrivatePath (string path)
 105                 {
 106                         throw new NotImplementedException ();
 107                 }
 108
 109                 [MonoTODO]
 110                 public void ClearPrivatePath ()
 111                 {
 112                         throw new NotImplementedException ();
 113                 }
 114
 115                 [MonoTODO]
 116                 public void ClearShadowCopyPath ()
 117                 {
 118                         throw new NotImplementedException ();
 119                 }
 120
 121                 public ObjectHandle CreateInstance (string assemblyName, string typeName)
 122                 {
 123                         if (assemblyName == null)
 124                                 throw new ArgumentNullException ("assemblyName");
 125
 126                         return Activator.CreateInstance (assemblyName, typeName);
 127                 }
 128
 129                 public ObjectHandle CreateInstance (string assemblyName, string typeName,
 130                                                     object[] activationAttributes)
 131                 {
 132                         if (assemblyName == null)
 133                                 throw new ArgumentNullException ("assemblyName");
 134
 135                         return Activator.CreateInstance (assemblyName, typeName, activationAttributes);
 136                 }
 137
 138                 public ObjectHandle CreateInstance (string assemblyName,
 139                                                     string typeName,
 140                                                     bool ignoreCase,
 141                                                     BindingFlags bindingAttr,
 142                                                     Binder binder,
 143                                                     object[] args,
 144                                                     CultureInfo culture,
 145                                                     object[] activationAttributes,
 146                                                     Evidence securityAttributes)
 147                 {
 148                         if (assemblyName == null)
 149                                 throw new ArgumentNullException ("assemblyName");
 150
 151                         return Activator.CreateInstance (assemblyName,
 152                                                          typeName,
 153                                                          ignoreCase,
 154                                                          bindingAttr,
 155                                                          binder,
 156                                                          args,
 157                                                          culture,
 158                                                          activationAttributes,
 159                                                          securityAttributes);
 160                 }
 161
 162                 public object CreateInstanceAndUnwrap (string assemblyName, string typeName)
 163                 {
 164                         ObjectHandle oh = CreateInstance (assemblyName, typeName);
 165                         return (oh != null) ? oh.Unwrap () : null;
 166                 }
 167
 168                 public object CreateInstanceAndUnwrap (string assemblyName,
 169                                                        string typeName,
 170                                                        object [] activationAttributes)
 171                 {
 172                         ObjectHandle oh = CreateInstance (assemblyName, typeName, activationAttributes);
 173                         return (oh != null) ? oh.Unwrap () : null;
 174                 }
 175
 176                 public object CreateInstanceAndUnwrap (string assemblyName,
 177                                                        string typeName,
 178                                                        bool ignoreCase,
 179                                                        BindingFlags bindingAttr,
 180                                                        Binder binder,
 181                                                        object[] args,
 182                                                        CultureInfo culture,
 183                                                        object[] activationAttributes,
 184                                                        Evidence securityAttributes)
 185                 {
 186                         ObjectHandle oh = CreateInstance (assemblyName,
 187                                                           typeName,
 188                                                           ignoreCase,
 189                                                           bindingAttr,
 190                                                           binder,
 191                                                           args,
 192                                                           culture,
 193                                                           activationAttributes,
 194                                                           securityAttributes);
 195                         return (oh != null) ? oh.Unwrap () : null;
 196                 }
 197
 198                 public ObjectHandle CreateInstanceFrom (string assemblyName, string typeName)
 199                 {
 200                         if (assemblyName == null)
 201                                 throw new ArgumentNullException ("assemblyName");
 202
 203                         return Activator.CreateInstanceFrom (assemblyName, typeName);
 204                 }
 205
 206                 public ObjectHandle CreateInstanceFrom (string assemblyName, string typeName,
 207                                                         object[] activationAttributes)
 208                 {
 209                         if (assemblyName == null)
 210                                 throw new ArgumentNullException ("assemblyName");
 211
 212                         return Activator.CreateInstanceFrom (assemblyName, typeName, activationAttributes);
 213                 }
 214
 215                 public ObjectHandle CreateInstanceFrom (string assemblyName,
 216                                                         string typeName,
 217                                                         bool ignoreCase,
 218                                                         BindingFlags bindingAttr,
 219                                                         Binder binder,
 220                                                         object[] args,
 221                                                         CultureInfo culture,
 222                                                         object[] activationAttributes,
 223                                                         Evidence securityAttributes)
 224                 {
 225                         if (assemblyName == null)
 226                                 throw new ArgumentNullException ("assemblyName");
 227
 228                         return Activator.CreateInstanceFrom (assemblyName,
 229                                                              typeName,
 230                                                              ignoreCase,
 231                                                              bindingAttr,
 232                                                              binder,
 233                                                              args,
 234                                                              culture,
 235                                                              activationAttributes,
 236                                                              securityAttributes);
 237                 }
 238
 239                 public object CreateInstanceFromAndUnwrap (string assemblyName, string typeName)
 240                 {
 241                         ObjectHandle oh = CreateInstanceFrom (assemblyName, typeName);
 242                         return (oh != null) ? oh.Unwrap () : null;
 243                 }
 244
 245                 public object CreateInstanceFromAndUnwrap (string assemblyName,
 246                                                            string typeName,
 247                                                            object [] activationAttributes)
 248                 {
 249                         ObjectHandle oh = CreateInstanceFrom (assemblyName, typeName, activationAttributes);
 250                         return (oh != null) ? oh.Unwrap () : null;
 251                 }
 252
 253                 public object CreateInstanceFromAndUnwrap (string assemblyName,
 254                                                            string typeName,
 255                                                            bool ignoreCase,
 256                                                            BindingFlags bindingAttr,
 257                                                            Binder binder,
 258                                                            object[] args,
 259                                                            CultureInfo culture,
 260                                                            object[] activationAttributes,
 261                                                            Evidence securityAttributes)
 262                 {
 263                         ObjectHandle oh = CreateInstanceFrom (assemblyName,
 264                                                               typeName,
 265                                                               ignoreCase,
 266                                                               bindingAttr,
 267                                                               binder,
 268                                                               args,
 269                                                               culture,
 270                                                               activationAttributes,
 271                                                               securityAttributes);
 272                         return (oh != null) ? oh.Unwrap () : null;
 273                 }
 274
 275                 public AssemblyBuilder DefineDynamicAssembly (AssemblyName name,
 276                                                               AssemblyBuilderAccess access)
 277                 {
 278                         return DefineDynamicAssembly (name, access, null, null,
 279                                                       null, null, null, false);
 280                 }
 281
 282                 public AssemblyBuilder DefineDynamicAssembly (AssemblyName name,
 283                                                               AssemblyBuilderAccess access,
 284                                                               Evidence evidence)
 285                 {
 286                         return DefineDynamicAssembly (name, access, null, evidence,
 287                                                       null, null, null, false);
 288                 }
 289
 290                 public AssemblyBuilder DefineDynamicAssembly (AssemblyName name,
 291                                                               AssemblyBuilderAccess access,
 292                                                               string dir)
 293                 {
 294                         return DefineDynamicAssembly (name, access, dir, null,
 295                                                       null, null, null, false);
 296                 }
 297
 298                 public AssemblyBuilder DefineDynamicAssembly (AssemblyName name,
 299                                                               AssemblyBuilderAccess access,
 300                                                               string dir,
 301                                                               Evidence evidence)
 302                 {
 303                         return DefineDynamicAssembly (name, access, dir, evidence,
 304                                                       null, null, null, false);
 305                 }
 306
 307                 public AssemblyBuilder DefineDynamicAssembly (AssemblyName name,
 308                                                               AssemblyBuilderAccess access,
 309                                                               PermissionSet requiredPermissions,
 310                                                               PermissionSet optionalPermissions,
 311                                                               PermissionSet refusedPersmissions)
 312                 {
 313                         return DefineDynamicAssembly (name, access, null, null,
 314                                                       requiredPermissions, optionalPermissions,
 315                                                       refusedPersmissions, false);
 316                 }
 317
 318                 public AssemblyBuilder DefineDynamicAssembly (AssemblyName name,
 319                                                               AssemblyBuilderAccess access,
 320                                                               Evidence evidence,
 321                                                               PermissionSet requiredPermissions,
 322                                                               PermissionSet optionalPermissions,
 323                                                               PermissionSet refusedPersmissions)
 324                 {
 325                         return DefineDynamicAssembly (name, access, null, evidence,
 326                                                       requiredPermissions, optionalPermissions,
 327                                                       refusedPersmissions, false);
 328                 }
 329
 330                 public AssemblyBuilder DefineDynamicAssembly (AssemblyName name,
 331                                                               AssemblyBuilderAccess access,
 332                                                               string dir,
 333                                                               PermissionSet requiredPermissions,
 334                                                               PermissionSet optionalPermissions,
 335                                                               PermissionSet refusedPersmissions)
 336                 {
 337                         return DefineDynamicAssembly (name, access, dir, null,
 338                                                       requiredPermissions, optionalPermissions,
 339                                                       refusedPersmissions, false);
 340                 }
 341
 342                 public AssemblyBuilder DefineDynamicAssembly (AssemblyName name,
 343                                                               AssemblyBuilderAccess access,
 344                                                               string dir,
 345                                                               Evidence evidence,
 346                                                               PermissionSet requiredPermissions,
 347                                                               PermissionSet optionalPermissions,
 348                                                               PermissionSet refusedPersmissions)
 349                 {
 350                         return DefineDynamicAssembly (name, access, dir, evidence,
 351                                                       requiredPermissions, optionalPermissions,
 352                                                       refusedPersmissions, false);
 353
 354                 }
 355
 356                 public AssemblyBuilder DefineDynamicAssembly (AssemblyName name,
 357                                                               AssemblyBuilderAccess access,
 358                                                               string dir,
 359                                                               Evidence evidence,
 360                                                               PermissionSet requiredPermissions,
 361                                                               PermissionSet optionalPermissions,
 362                                                               PermissionSet refusedPersmissions,
 363                                                               bool isSynchronized)
 364                 {
 365                         // FIXME: examine all other parameters
 366
 367                         AssemblyBuilder ab = new AssemblyBuilder (name, dir, access);
 368                         return ab;
 369                 }
 370
 371
 372                 [MonoTODO]
 373                 public void DoCallBack (CrossAppDomainDelegate theDelegate)
 374                 {
 375                         throw new NotImplementedException ();
 376                 }
 377
 378                 public override bool Equals (object other)
 379                 {
 380                         if (!(other is AppDomain))
 381                                 return false;
 382
 383                         return this._mono_app_domain == ((AppDomain)other)._mono_app_domain;
 384                 }
 385
 386                 public int ExecuteAssembly (string assemblyFile)
 387                 {
 388                         return ExecuteAssembly (assemblyFile, new Evidence (), null);
 389                 }
 390
 391                 public int ExecuteAssembly (string assemblyFile, Evidence assemblySecurity)
 392                 {
 393                         return ExecuteAssembly (assemblyFile, new Evidence (), null);
 394                 }
 395
 396                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 397                 public extern int ExecuteAssembly (string assemblyFile, Evidence assemblySecurity, string[] args);
 398
 399                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 400                 public extern Assembly [] GetAssemblies ();
 401
 402                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 403                 public extern object GetData (string name);
 404
 405                 public override int GetHashCode ()
 406                 {
 407                         return (int)_mono_app_domain;
 408                 }
 409
 410                 [MonoTODO]
 411                 public override object InitializeLifetimeService ()
 412                 {
 413                         throw new NotImplementedException ();
 414                 }
 415
 416                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 417                 private extern Assembly LoadAssembly (AssemblyName assemblyRef, Evidence securityEvidence);
 418
 419                 public Assembly Load (AssemblyName assemblyRef)
 420                 {
 421                         return Load (assemblyRef, new Evidence ());
 422                 }
 423
 424                 public Assembly Load (AssemblyName assemblyRef, Evidence assemblySecurity)
 425                 {
 426                         return LoadAssembly (assemblyRef, assemblySecurity);
 427                 }
 428
 429                 public Assembly Load (string assemblyString)
 430                 {
 431                         AssemblyName an = new AssemblyName ();
 432                         an.Name = assemblyString;
 433
 434                         return Load (an, new Evidence ());
 435                 }
 436
 437                 public Assembly Load (string assemblyString, Evidence assemblySecurity)
 438                 {
 439                         AssemblyName an = new AssemblyName ();
 440                         an.Name = assemblyString;
 441
 442                         return Load (an, assemblySecurity);
 443                 }
 444
 445                 public Assembly Load (byte[] rawAssembly)
 446                 {
 447                         return Load (rawAssembly, null, new Evidence ());
 448                 }
 449
 450                 public Assembly Load (byte[] rawAssembly, byte[] rawSymbolStore)
 451                 {
 452                         return Load (rawAssembly, rawSymbolStore, new Evidence ());
 453                 }
 454
 455                 [MonoTODO]
 456                 public Assembly Load (byte[] rawAssembly, byte[] rawSymbolStore, Evidence securityEvidence)
 457                 {
 458                         throw new NotImplementedException ();
 459                 }
 460
 461                 [MonoTODO]
 462                 public void SetAppDomainPolicy (PolicyLevel domainPolicy)
 463                 {
 464                         throw new NotImplementedException ();
 465                 }
 466
 467                 public void SetCachePath (string s)
 468                 {
 469                         SetupInformation.CachePath = s;
 470                 }
 471
 472                 [MonoTODO]
 473                 public void SetPrincipalPolicy (PrincipalPolicy policy)
 474                 {
 475                         throw new NotImplementedException ();
 476                 }
 477
 478                 [MonoTODO]
 479                 public void SetShadowCopyPath (string s)
 480                 {
 481                         throw new NotImplementedException ();
 482                 }
 483
 484                 [MonoTODO]
 485                 public void SetThreadPrincipal (IPrincipal principal)
 486                 {
 487                         throw new NotImplementedException ();
 488                 }
 489
 490                 public static AppDomain CreateDomain (string friendlyName)
 491                 {
 492                         return CreateDomain (friendlyName, new Evidence (), new AppDomainSetup ());
 493                 }
 494
 495                 public static AppDomain CreateDomain (string friendlyName, Evidence securityInfo)
 496                 {
 497                         return CreateDomain (friendlyName, securityInfo, new AppDomainSetup ());
 498                 }
 499
 500                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 501                 private static extern AppDomain createDomain (string friendlyName, AppDomainSetup info);
 502
 503                 public static AppDomain CreateDomain (string friendlyName,
 504                                                       Evidence securityInfo,
 505                                                       AppDomainSetup info)
 506                 {
 507                         //TODO: treat securityInfo (can be null)
 508                         if (friendlyName == null)
 509                                 throw new System.ArgumentNullException ("friendlyName");
 510
 511                         if (info == null)
 512                                 throw new System.ArgumentNullException ("info");
 513
 514                         AppDomain ad = createDomain (friendlyName, info);
 515
 516                         // ad.evidence = securityInfo;
 517
 518                         return ad;
 519                 }
 520
 521                 public static AppDomain CreateDomain (string friendlyName, Evidence securityInfo,
 522                                                       string appBasePath, string appRelativeSearchPath,
 523                                                       bool shadowCopyFiles)
 524                 {
 525                         AppDomainSetup info = new AppDomainSetup ();
 526
 527                         info.ApplicationBase = appBasePath;
 528                         info.PrivateBinPath = appRelativeSearchPath;
 529
 530                         if (shadowCopyFiles)
 531                                 info.ShadowCopyFiles = "true";
 532                         else
 533                                 info.ShadowCopyFiles = "false";
 534
 535                         return CreateDomain (friendlyName, securityInfo, info);
 536                 }
 537
 538
 539                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 540                 public static extern void Unload (AppDomain domain);
 541
 542                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 543                 public extern void SetData (string name, object data);
 544
 545                 [MonoTODO]
 546                 public static int GetCurrentThreadId ()
 547                 {
 548                         throw new NotImplementedException ();
 549                 }
 550
 551                 public override string ToString () {
 552                         return getFriendlyName ();
 553                 }
 554
 555
 556                 public event AssemblyLoadEventHandler AssemblyLoad;
 557
 558                 public event ResolveEventHandler AssemblyResolve;
 559
 560                 public event EventHandler DomainUnload;
 561
 562                 public event EventHandler ProcessExit;
 563
 564                 public event ResolveEventHandler ResourceResolve;
 565
 566                 public event ResolveEventHandler TypeResolve;
 567
 568                 public event UnhandledExceptionEventHandler UnhandledException;
 569
 570         }
 571 }