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