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