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