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