mcs/class/corlib/System/Activator.cs

   1 //
   2 // System.Activator.cs
   3 //
   4 // Authors:
   5 //   Nick Drochak II (ndrochak@gol.com)
   6 //   Gonzalo Paniagua (gonzalo@ximian.com)
   7 //
   8 // (C) 2001 Nick Drochak II
   9 // (c) 2002 Ximian, Inc. (http://www.ximian.com)
  10 // Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 using System.Globalization;
  33 using System.Reflection;
  34 using System.Runtime.Remoting;
  35 using System.Runtime.Remoting.Activation;
  36 using System.Runtime.CompilerServices;
  37 using System.Security.Permissions;
  38 using System.Security.Policy;
  39 using System.Configuration.Assemblies;
  40
  41 namespace System
  42 {
  43         public sealed class Activator
  44         {
  45                 const BindingFlags _flags = BindingFlags.CreateInstance | BindingFlags.Public | BindingFlags.Instance;
  46                 const BindingFlags _accessFlags = BindingFlags.DeclaredOnly | BindingFlags.FlattenHierarchy | BindingFlags.IgnoreCase |
  47                                                                                         BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public |
  48                                                                                         BindingFlags.Static;
  49
  50                 private Activator ()
  51                 {
  52                 }
  53
  54                 [MonoTODO]
  55                 public static ObjectHandle CreateComInstanceFrom (string assemblyName, string typeName)
  56                 {
  57                         if (assemblyName == null)
  58                                 throw new ArgumentNullException ("assemblyName");
  59
  60                         if (typeName == null)
  61                                 throw new ArgumentNullException ("typeName");
  62
  63                         throw new NotImplementedException();
  64                 }
  65
  66 #if NET_1_1
  67                 [MonoTODO]
  68                 public static ObjectHandle CreateComInstanceFrom (string assemblyName, string typeName,
  69                                                                   byte []hashValue, AssemblyHashAlgorithm hashAlgorithm)
  70                 {
  71                         if (assemblyName == null)
  72                                 throw new ArgumentNullException ("assemblyName");
  73
  74                         if (typeName == null)
  75                                 throw new ArgumentNullException ("typeName");
  76
  77                         throw new NotImplementedException();
  78                 }
  79 #endif
  80
  81                 public static ObjectHandle CreateInstanceFrom (string assemblyFile, string typeName)
  82                 {
  83                         return CreateInstanceFrom (assemblyFile, typeName, null);
  84                 }
  85
  86                 public static ObjectHandle CreateInstanceFrom (string assemblyFile, string typeName, object [] activationAttributes)
  87                 {
  88                         return Activator.CreateInstanceFrom (assemblyFile, typeName, false, _flags, null, null, null,
  89                                 activationAttributes, null);
  90                 }
  91
  92                 public static ObjectHandle CreateInstanceFrom (string assemblyFile, string typeName, bool ignoreCase,
  93                                                                BindingFlags bindingAttr, Binder binder, object [] args,
  94                                                                CultureInfo culture, object [] activationAttributes,
  95                                                                Evidence securityInfo)
  96                 {
  97                         Assembly assembly = Assembly.LoadFrom (assemblyFile, securityInfo);
  98                         if (assembly == null)
  99                                 return null;
 100
 101                         Type type = assembly.GetType (typeName, true, ignoreCase);
 102                         if (type == null)
 103                                 return null;
 104
 105                         object obj = CreateInstance (type, bindingAttr, binder, args, culture, activationAttributes);
 106                         return (obj != null) ? new ObjectHandle (obj) : null;
 107                 }
 108
 109                 public static ObjectHandle CreateInstance (string assemblyName, string typeName)
 110                 {
 111                         if (assemblyName == null)
 112                                 assemblyName = Assembly.GetCallingAssembly ().GetName ().Name;
 113
 114                         return Activator.CreateInstance (assemblyName, typeName, null);
 115                 }
 116
 117                 public static ObjectHandle CreateInstance (string assemblyName, string typeName, object [] activationAttributes)
 118                 {
 119                         if (assemblyName == null)
 120                                 assemblyName = Assembly.GetCallingAssembly ().GetName ().Name;
 121
 122                         return Activator.CreateInstance (assemblyName, typeName, false, _flags, null, null, null,
 123                                 activationAttributes, null);
 124                 }
 125
 126                 public static ObjectHandle CreateInstance (string assemblyName, string typeName, bool ignoreCase,
 127                                                            BindingFlags bindingAttr, Binder binder, object [] args,
 128                                                            CultureInfo culture, object [] activationAttributes, Evidence securityInfo)
 129                 {
 130                         Assembly assembly = null;
 131                         if(assemblyName == null)
 132                                 assembly = Assembly.GetCallingAssembly ();
 133                         else
 134                                 assembly = Assembly.Load (assemblyName, securityInfo);
 135                         Type type = assembly.GetType (typeName, true, ignoreCase);
 136                         object obj = CreateInstance (type, bindingAttr, binder, args, culture, activationAttributes);
 137                         return (obj != null) ? new ObjectHandle (obj) : null;
 138                 }
 139
 140                 public static object CreateInstance (Type type)
 141                 {
 142                         return CreateInstance (type, false);
 143                 }
 144
 145                 public static object CreateInstance (Type type, object [] args)
 146                 {
 147                         return CreateInstance (type, args, new object [0]);
 148                 }
 149
 150                 public static object CreateInstance (Type type, object [] args, object [] activationAttributes)
 151                 {
 152                         if (type == null)
 153                                 throw new ArgumentNullException ("type");
 154
 155                         if (type.IsAbstract)
 156                                 throw new MemberAccessException (Locale.GetText ("Cannot create an abstract class. Class name: ") +
 157                                                                 type.FullName);
 158
 159                         int length = 0;
 160                         if (args != null)
 161                                 length = args.Length;
 162
 163                         Type [] atypes = new Type [length];
 164                         for (int i = 0; i < length; ++i)
 165                                 if (args [i] != null)
 166                                         atypes [i] = args [i].GetType ();
 167
 168                         ConstructorInfo ctor = type.GetConstructor (atypes);
 169                         if (ctor == null) {
 170                                 if (type.IsValueType && atypes.Length == 0)
 171                                         return CreateInstanceInternal (type);
 172
 173                                 throw new MissingMethodException (Locale.GetText ("Constructor not found. Class") +
 174                                                                 type.FullName);
 175                         }
 176
 177                         if (activationAttributes != null && activationAttributes.Length > 0 && type.IsMarshalByRef) {
 178                                 object newOb = ActivationServices.CreateProxyFromAttributes (type, activationAttributes);
 179                                 if (newOb != null)
 180                                         return ctor.Invoke (newOb, args);
 181                         }
 182
 183                         return ctor.Invoke (args);
 184                 }
 185
 186                 public static object CreateInstance (Type type, BindingFlags bindingAttr, Binder binder, object [] args,
 187                                                      CultureInfo culture)
 188                 {
 189                         return CreateInstance (type, bindingAttr, binder, args, culture, new object [0]);
 190                 }
 191
 192                 public static object CreateInstance (Type type, BindingFlags bindingAttr, Binder binder, object [] args,
 193                                                      CultureInfo culture, object [] activationAttributes)
 194                 {
 195                         if (type == null)
 196                                 throw new ArgumentNullException ("type");
 197
 198                         if (type.IsAbstract)
 199                                 throw new MemberAccessException (Locale.GetText ("Cannot create an abstract class. Class name: ") +
 200                                                                 type.FullName);
 201
 202                         // It seems to apply the same rules documented for InvokeMember: "If the type of lookup
 203                         // is omitted, BindingFlags.Public | BindingFlags.Instance will apply".
 204                         if ((bindingAttr & _accessFlags) == 0)
 205                                 bindingAttr |= BindingFlags.Public | BindingFlags.Instance;
 206
 207                         int length = 0;
 208                         if (args != null)
 209                                 length = args.Length;
 210
 211                         Type[] atypes = new Type [length];
 212                         for (int i = 0; i < length; ++i)
 213                                 if (args [i] != null)
 214                                         atypes [i] = args [i].GetType ();
 215
 216                         ConstructorInfo ctor = type.GetConstructor (bindingAttr, binder, atypes, null);
 217                         if (ctor == null) {
 218                                 // Not sure about this
 219                                 if (type.IsValueType && atypes.Length == 0) {
 220                                         return CreateInstanceInternal (type);
 221                                 }
 222
 223                                 throw new MissingMethodException (Locale.GetText ("Constructor not found. Class: ") +
 224                                                                 type.FullName);
 225                         }
 226
 227                         if (activationAttributes != null && activationAttributes.Length > 0 && type.IsMarshalByRef) {
 228                                 object newOb = ActivationServices.CreateProxyFromAttributes (type, activationAttributes);
 229                                 if (newOb != null)
 230                                         return ctor.Invoke (newOb, bindingAttr, binder, args, culture);
 231                         }
 232
 233                         return ctor.Invoke (bindingAttr, binder, args, culture);
 234                 }
 235
 236                 public static object CreateInstance (Type type, bool nonPublic)
 237                 {
 238                         if (type == null)
 239                                 throw new ArgumentNullException ("type");
 240
 241                         if (type.IsAbstract)
 242                                 throw new MemberAccessException (Locale.GetText ("Cannot create an abstract class. Class name: ") +
 243                                                                 type.FullName);
 244
 245                         BindingFlags flags = BindingFlags.Public | BindingFlags.Instance;
 246                         if (nonPublic)
 247                                 flags |= BindingFlags.NonPublic;
 248
 249                         ConstructorInfo ctor = type.GetConstructor (flags, null, CallingConventions.Any, Type.EmptyTypes, null);
 250
 251                         if (ctor == null) {
 252                                 if (type.IsValueType)
 253                                         return CreateInstanceInternal (type);
 254
 255                                 throw new MissingMethodException (Locale.GetText ("Default constructor not found."),
 256                                                                 ".ctor() of " + type.FullName);
 257                         }
 258
 259                         return ctor.Invoke (null);
 260                 }
 261
 262                 [SecurityPermission (SecurityAction.LinkDemand, RemotingConfiguration = true)]
 263                 public static object GetObject (Type type, string url)
 264                 {
 265                         return RemotingServices.Connect (type, url);
 266                 }
 267
 268                 [SecurityPermission (SecurityAction.LinkDemand, RemotingConfiguration = true)]
 269                 public static object GetObject (Type type, string url, object state)
 270                 {
 271                         return RemotingServices.Connect (type, url, state);
 272                 }
 273
 274                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 275                 internal static extern object CreateInstanceInternal (Type type);
 276         }
 277 }