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.Runtime.InteropServices;
  38 using System.Security.Permissions;
  39 using System.Security.Policy;
  40 using System.Configuration.Assemblies;
  41
  42 namespace System
  43 {
  44         [ClassInterface (ClassInterfaceType.None)]
  45 #if NET_2_0
  46         [ComVisible (true)]
  47         [ComDefaultInterface (typeof (_Activator))]
  48 #endif
  49         public sealed class Activator : _Activator
  50         {
  51                 const BindingFlags _flags = BindingFlags.CreateInstance | BindingFlags.Public | BindingFlags.Instance;
  52                 const BindingFlags _accessFlags = BindingFlags.DeclaredOnly | BindingFlags.FlattenHierarchy | BindingFlags.IgnoreCase |
  53                                                                                         BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public |
  54                                                                                         BindingFlags.Static;
  55
  56                 private Activator ()
  57                 {
  58                 }
  59
  60                 [MonoTODO]
  61                 public static ObjectHandle CreateComInstanceFrom (string assemblyName, string typeName)
  62                 {
  63                         if (assemblyName == null)
  64                                 throw new ArgumentNullException ("assemblyName");
  65
  66                         if (typeName == null)
  67                                 throw new ArgumentNullException ("typeName");
  68
  69                         if (assemblyName.Length == 0)
  70                                 throw new ArgumentException ("assemblyName");
  71
  72                         throw new NotImplementedException();
  73                 }
  74
  75 #if NET_1_1
  76                 [MonoTODO]
  77                 public static ObjectHandle CreateComInstanceFrom (string assemblyName, string typeName,
  78                                                                   byte []hashValue, AssemblyHashAlgorithm hashAlgorithm)
  79                 {
  80                         if (assemblyName == null)
  81                                 throw new ArgumentNullException ("assemblyName");
  82
  83                         if (typeName == null)
  84                                 throw new ArgumentNullException ("typeName");
  85
  86                         if (assemblyName.Length == 0)
  87                                 throw new ArgumentException ("assemblyName");
  88
  89                         throw new NotImplementedException();
  90                 }
  91 #endif
  92
  93                 public static ObjectHandle CreateInstanceFrom (string assemblyFile, string typeName)
  94                 {
  95                         return CreateInstanceFrom (assemblyFile, typeName, null);
  96                 }
  97
  98                 public static ObjectHandle CreateInstanceFrom (string assemblyFile, string typeName, object [] activationAttributes)
  99                 {
 100                         return Activator.CreateInstanceFrom (assemblyFile, typeName, false, _flags, null, null, null,
 101                                 activationAttributes, null);
 102                 }
 103
 104                 public static ObjectHandle CreateInstanceFrom (string assemblyFile, string typeName, bool ignoreCase,
 105                                                                BindingFlags bindingAttr, Binder binder, object [] args,
 106                                                                CultureInfo culture, object [] activationAttributes,
 107                                                                Evidence securityInfo)
 108                 {
 109                         Assembly assembly = Assembly.LoadFrom (assemblyFile, securityInfo);
 110                         if (assembly == null)
 111                                 return null;
 112
 113                         Type type = assembly.GetType (typeName, true, ignoreCase);
 114                         if (type == null)
 115                                 return null;
 116
 117                         object obj = CreateInstance (type, bindingAttr, binder, args, culture, activationAttributes);
 118                         return (obj != null) ? new ObjectHandle (obj) : null;
 119                 }
 120
 121                 public static ObjectHandle CreateInstance (string assemblyName, string typeName)
 122                 {
 123                         if (assemblyName == null)
 124                                 assemblyName = Assembly.GetCallingAssembly ().GetName ().Name;
 125
 126                         return Activator.CreateInstance (assemblyName, typeName, null);
 127                 }
 128
 129                 public static ObjectHandle CreateInstance (string assemblyName, string typeName, object [] activationAttributes)
 130                 {
 131                         if (assemblyName == null)
 132                                 assemblyName = Assembly.GetCallingAssembly ().GetName ().Name;
 133
 134                         return Activator.CreateInstance (assemblyName, typeName, false, _flags, null, null, null,
 135                                 activationAttributes, null);
 136                 }
 137
 138                 public static ObjectHandle CreateInstance (string assemblyName, string typeName, bool ignoreCase,
 139                                                            BindingFlags bindingAttr, Binder binder, object [] args,
 140                                                            CultureInfo culture, object [] activationAttributes, Evidence securityInfo)
 141                 {
 142                         Assembly assembly = null;
 143                         if(assemblyName == null)
 144                                 assembly = Assembly.GetCallingAssembly ();
 145                         else
 146                                 assembly = Assembly.Load (assemblyName, securityInfo);
 147                         Type type = assembly.GetType (typeName, true, ignoreCase);
 148                         object obj = CreateInstance (type, bindingAttr, binder, args, culture, activationAttributes);
 149                         return (obj != null) ? new ObjectHandle (obj) : null;
 150                 }
 151
 152 #if NET_2_0
 153                 public static T CreateInstance <T> ()
 154                 {
 155                         return (T) CreateInstance (typeof (T));
 156                 }
 157 #endif
 158
 159                 public static object CreateInstance (Type type)
 160                 {
 161                         return CreateInstance (type, false);
 162                 }
 163
 164                 public static object CreateInstance (Type type, params object [] args)
 165                 {
 166                         return CreateInstance (type, args, new object [0]);
 167                 }
 168
 169                 public static object CreateInstance (Type type, object [] args, object [] activationAttributes)
 170                 {
 171                         return CreateInstance (type, BindingFlags.Default, Binder.DefaultBinder, args, null, activationAttributes);
 172                 }
 173
 174                 public static object CreateInstance (Type type, BindingFlags bindingAttr, Binder binder, object [] args,
 175                                                      CultureInfo culture)
 176                 {
 177                         return CreateInstance (type, bindingAttr, binder, args, culture, new object [0]);
 178                 }
 179
 180                 public static object CreateInstance (Type type, BindingFlags bindingAttr, Binder binder, object [] args,
 181                                                      CultureInfo culture, object [] activationAttributes)
 182                 {
 183                         CheckType (type);
 184
 185 #if NET_2_0
 186                         if (type.ContainsGenericParameters)
 187                                 throw new ArgumentException (type + " is an open generic type", "type");
 188 #endif
 189                         // It seems to apply the same rules documented for InvokeMember: "If the type of lookup
 190                         // is omitted, BindingFlags.Public | BindingFlags.Instance will apply".
 191                         if ((bindingAttr & _accessFlags) == 0)
 192                                 bindingAttr |= BindingFlags.Public | BindingFlags.Instance;
 193
 194                         int length = 0;
 195                         if (args != null)
 196                                 length = args.Length;
 197
 198                         Type[] atypes = length == 0 ? Type.EmptyTypes : new Type [length];
 199                         for (int i = 0; i < length; ++i)
 200                                 if (args [i] != null)
 201                                         atypes [i] = args [i].GetType ();
 202
 203                         if (binder == null)
 204                                 binder = Binder.DefaultBinder;
 205
 206                         ConstructorInfo ctor = (ConstructorInfo) binder.SelectMethod (bindingAttr, type.GetConstructors (bindingAttr), atypes, null);
 207
 208                         if (ctor == null) {
 209                                 // Not sure about this
 210                                 if (type.IsValueType && atypes.Length == 0) {
 211                                         return CreateInstanceInternal (type);
 212                                 }
 213
 214                                 throw new MissingMethodException (Locale.GetText ("Constructor not found. Class: ") +
 215                                                                 type.FullName);
 216                         }
 217
 218                         CheckAbstractType (type);
 219
 220                         if (activationAttributes != null && activationAttributes.Length > 0) {
 221                                 if (!type.IsMarshalByRef) {
 222                                         string msg = Locale.GetText ("Type '{0}' doesn't derive from MarshalByRefObject.", type.FullName);
 223                                         throw new NotSupportedException (msg);
 224                                 }
 225                                 object newOb = ActivationServices.CreateProxyFromAttributes (type, activationAttributes);
 226                                 if (newOb != null)
 227                                         return ctor.Invoke (newOb, bindingAttr, binder, args, culture);
 228                         }
 229
 230                         return ctor.Invoke (bindingAttr, binder, args, culture);
 231                 }
 232
 233                 public static object CreateInstance (Type type, bool nonPublic)
 234                 {
 235                         CheckType (type);
 236 #if NET_2_0
 237                         if (type.ContainsGenericParameters)
 238                                 throw new ArgumentException (type + " is an open generic type", "type");
 239 #endif
 240                         CheckAbstractType (type);
 241
 242                         BindingFlags flags = BindingFlags.Public | BindingFlags.Instance;
 243                         if (nonPublic)
 244                                 flags |= BindingFlags.NonPublic;
 245
 246                         ConstructorInfo ctor = type.GetConstructor (flags, null, CallingConventions.Any, Type.EmptyTypes, null);
 247
 248                         if (ctor == null) {
 249                                 if (type.IsValueType)
 250                                         return CreateInstanceInternal (type);
 251
 252                                 throw new MissingMethodException (Locale.GetText ("Default constructor not found."),
 253                                                                 ".ctor() of " + type.FullName);
 254                         }
 255
 256                         return ctor.Invoke (null);
 257                 }
 258
 259                 private static void CheckType (Type type)
 260                 {
 261                         if (type == null)
 262                                 throw new ArgumentNullException ("type");
 263
 264                         if ((type == typeof (TypedReference)) || (type == typeof (ArgIterator)) || (type == typeof (void)) ||
 265                                 (type == typeof (RuntimeArgumentHandle))) {
 266                                 string msg = Locale.GetText ("CreateInstance cannot be used to create this type ({0}).", type.FullName);
 267                                 throw new NotSupportedException (msg);
 268                         }
 269                 }
 270
 271                 private static void CheckAbstractType (Type type)
 272                 {
 273                         if (type.IsAbstract) {
 274                                 string msg = Locale.GetText ("Cannot create an abstract class '{0}'.", type.FullName);
 275 #if NET_2_0
 276                                 throw new MissingMethodException (msg);
 277 #else
 278                                 throw new MemberAccessException (msg);
 279 #endif
 280                         }
 281                 }
 282
 283                 [SecurityPermission (SecurityAction.LinkDemand, RemotingConfiguration = true)]
 284                 public static object GetObject (Type type, string url)
 285                 {
 286                         if (type == null)
 287                                 throw new ArgumentNullException ("type");
 288
 289                         return RemotingServices.Connect (type, url);
 290                 }
 291
 292                 [SecurityPermission (SecurityAction.LinkDemand, RemotingConfiguration = true)]
 293                 public static object GetObject (Type type, string url, object state)
 294                 {
 295                         if (type == null)
 296                                 throw new ArgumentNullException ("type");
 297
 298                         return RemotingServices.Connect (type, url, state);
 299                 }
 300
 301                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 302                 internal static extern object CreateInstanceInternal (Type type);
 303
 304 #if NET_1_1
 305                 void _Activator.GetIDsOfNames ([In] ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
 306                 {
 307                         throw new NotImplementedException ();
 308                 }
 309
 310                 void _Activator.GetTypeInfo (uint iTInfo, uint lcid, IntPtr ppTInfo)
 311                 {
 312                         throw new NotImplementedException ();
 313                 }
 314
 315                 void _Activator.GetTypeInfoCount (out uint pcTInfo)
 316                 {
 317                         throw new NotImplementedException ();
 318                 }
 319
 320                 void _Activator.Invoke (uint dispIdMember, [In] ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams,
 321                         IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
 322                 {
 323                         throw new NotImplementedException ();
 324                 }
 325 #endif
 326         }
 327 }