[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
public static Assembly?LoadWithPartialName(string partialName)
{
if (partialName == null)
{
throw new ArgumentNullException(nameof(partialName));
}
if ((partialName.Length == 0) || (partialName[0] == '\0'))
{
throw new ArgumentException(SR.Format_StringZeroLength, nameof(partialName));
}
try
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return(RuntimeAssembly.InternalLoad(
partialName,
ref stackMark,
AssemblyLoadContext.CurrentContextualReflectionContext
));
}
catch (FileNotFoundException)
{
return(null);
}
}
internal static RuntimeAssembly GetExecutingAssembly(ref StackCrawlMark stackMark)
{
RuntimeAssembly?retAssembly = null;
GetExecutingAssemblyNative(JitHelpers.GetStackCrawlMarkHandle(ref stackMark), JitHelpers.GetObjectHandleOnStack(ref retAssembly));
return(retAssembly);
}
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
static public T CreateInstance <T>()
{
RuntimeType rt = typeof(T) as RuntimeType;
// This is a hack to maintain compatibility with V2. Without this we would throw a NotSupportedException for void[].
// Array, Ref, and Pointer types don't have default constructors.
if (rt.HasElementType)
{
throw new MissingMethodException(Environment.GetResourceString("Arg_NoDefCTor"));
}
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
// Skip the CreateInstanceCheckThis call to avoid perf cost and to maintain compatibility with V2 (throwing the same exceptions).
#if FEATURE_CORECLR
// In SL2/3 CreateInstance<T> doesn't do any security checks. This would mean that Assembly B can create instances of an internal
// type in Assembly A upon A's request:
// TypeInAssemblyA.DoWork() { AssemblyB.Create<InternalTypeInAssemblyA>();}
// TypeInAssemblyB.Create<T>() {return new T();}
// This violates type safety but we saw multiple user apps that have put a dependency on it. So for compatability we allow this if
// the SL app was built against SL2/3.
// Note that in SL2/3 it is possible for app code to instantiate public transparent types with public critical default constructors.
// Fortunately we don't have such types in out platform assemblies.
if (CompatibilitySwitches.IsAppEarlierThanSilverlight4 ||
CompatibilitySwitches.IsAppEarlierThanWindowsPhone8)
{
return((T)rt.CreateInstanceSlow(true /*publicOnly*/, true /*skipCheckThis*/, false /*fillCache*/, ref stackMark));
}
else
#endif // FEATURE_CORECLR
return((T)rt.CreateInstanceDefaultCtor(true /*publicOnly*/, true /*skipCheckThis*/, true /*fillCache*/, true /*wrapExceptions*/, ref stackMark));
}
internal static RuntimeAssembly GetExecutingAssembly(ref StackCrawlMark stackMark)
{
RuntimeAssembly?retAssembly = null;
GetExecutingAssemblyNative(JitHelpers.GetStackCrawlMarkHandle(ref stackMark), JitHelpers.GetObjectHandleOnStack(ref retAssembly));
return(retAssembly !); // TODO-NULLABLE: Confirm this can never be null
}
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
static public Object CreateInstance(Type type,
BindingFlags bindingAttr,
Binder binder,
Object[] args,
CultureInfo culture,
Object[] activationAttributes)
{
if ((object)type == null)
{
throw new ArgumentNullException("type");
}
Contract.EndContractBlock();
if (type is System.Reflection.Emit.TypeBuilder)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_CreateInstanceWithTypeBuilder"));
}
// If they didn't specify a lookup, then we will provide the default lookup.
if ((bindingAttr & (BindingFlags)LookupMask) == 0)
{
bindingAttr |= Activator.ConstructorDefault;
}
if (activationAttributes != null && activationAttributes.Length > 0)
{
// If type does not derive from MBR
// throw notsupportedexception
#if FEATURE_REMOTING
if (type.IsMarshalByRef)
{
// The fix below is preventative.
//
if (!(type.IsContextful))
{
if (activationAttributes.Length > 1 || !(activationAttributes[0] is UrlAttribute))
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_NonUrlAttrOnMBR"));
}
}
}
else
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_ActivAttrOnNonMBR"));
}
#else
throw new PlatformNotSupportedException(Environment.GetResourceString("NotSupported_ActivAttr"));
#endif
}
RuntimeType rt = type.UnderlyingSystemType as RuntimeType;
if (rt == null)
{
throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "type");
}
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return(rt.CreateInstanceImpl(bindingAttr, binder, args, culture, activationAttributes, ref stackMark));
}
static Assembly ResolveAssembly(string name, Func <AssemblyName, Assembly> assemblyResolver, bool throwOnError,
ref StackCrawlMark stackMark)
{
var aname = new AssemblyName(name);
if (assemblyResolver == null)
{
if (throwOnError)
{
return(Assembly.Load(aname, ref stackMark, IntPtr.Zero));
}
else
{
try {
return(Assembly.Load(aname, ref stackMark, IntPtr.Zero));
} catch (FileNotFoundException) {
return(null);
}
}
}
else
{
var assembly = assemblyResolver(aname);
if (assembly == null && throwOnError)
{
throw new FileNotFoundException(SR.FileNotFound_ResolveAssembly, name);
}
return(assembly);
}
}
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
public static ObjectHandle CreateInstance(string assemblyName,
string typeName,
bool ignoreCase,
BindingFlags bindingAttr,
Binder binder,
object[] args,
CultureInfo culture,
object[] activationAttributes)
{
#if MONO
if (assemblyName == null)
{
assemblyName = Assembly.GetCallingAssembly().GetName().Name;
}
#endif
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return(CreateInstance(assemblyName,
typeName,
ignoreCase,
bindingAttr,
binder,
args,
culture,
activationAttributes,
null,
ref stackMark));
}
internal static Type GetType(
string typeName,
Func <AssemblyName, Assembly> assemblyResolver,
Func <Assembly, string, bool, Type> typeResolver,
bool throwOnError,
bool ignoreCase,
ref StackCrawlMark stackMark)
{
if (typeName == null)
{
throw new ArgumentNullException(nameof(typeName));
}
ParsedName pname = ParseName(typeName, false, 0, out int end_pos);
if (pname == null)
{
if (throwOnError)
{
throw new ArgumentException();
}
return(null);
}
return(ConstructType(pname, assemblyResolver, typeResolver, throwOnError, ignoreCase, ref stackMark));
}
internal static RuntimeAssembly GetExecutingAssembly(ref StackCrawlMark stackMark)
{
RuntimeAssembly?retAssembly = null;
GetExecutingAssemblyNative(new StackCrawlMarkHandle(ref stackMark), ObjectHandleOnStack.Create(ref retAssembly));
return(retAssembly !);
}
internal static RuntimeAssembly GetExecutingAssembly(ref StackCrawlMark stackMark)
{
RuntimeAssembly?retAssembly = null;
GetExecutingAssemblyNative(JitHelpers.GetStackCrawlMarkHandle(ref stackMark), JitHelpers.GetObjectHandleOnStack(ref retAssembly));
return(retAssembly !); // TODO-NULLABLE: Remove ! when nullable attributes are respected
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
internal static Type GetType_Compat(String assemblyString, String typeName)
{
// Normally we would get the stackMark only in public APIs. This is internal API, but it is AppCompat replacement of public API
// call Assembly.Load(assemblyString).GetType(typeName), therefore we take the stackMark here as well, to be fully compatible with
// the call sequence.
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
RuntimeAssembly assembly;
AssemblyName assemblyName = RuntimeAssembly.CreateAssemblyName(
assemblyString,
false /*forIntrospection*/,
out assembly);
if (assembly == null)
{
if (assemblyName.ContentType == AssemblyContentType.WindowsRuntime)
{
return(Type.GetType(typeName + ", " + assemblyString, true /*throwOnError*/, false /*ignoreCase*/));
}
assembly = RuntimeAssembly.InternalLoadAssemblyName(
assemblyName, null, null, ref stackMark,
true /*thrownOnFileNotFound*/, false /*forIntrospection*/);
}
return(assembly.GetType(typeName, true /*throwOnError*/, false /*ignoreCase*/));
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
public static Assembly Load(AssemblyName assemblyRef)
{
ArgumentNullException.ThrowIfNull(assemblyRef);
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return(RuntimeAssembly.InternalLoad(assemblyRef, ref stackMark, AssemblyLoadContext.CurrentContextualReflectionContext));
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
public static Assembly GetCallingAssembly()
{
// LookForMyCallersCaller is not guarantee to return the correct stack frame
// because of inlining, tail calls, etc. As a result GetCallingAssembly is not
// ganranteed to return the correct result. We should document it as such.
StackCrawlMark stackMark = StackCrawlMark.LookForMyCallersCaller;
return RuntimeAssembly.GetExecutingAssembly(ref stackMark);
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
public static Assembly Load(String assemblyString)
{
Contract.Ensures(Contract.Result <Assembly>() != null);
Contract.Ensures(!Contract.Result <Assembly>().ReflectionOnly);
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return(RuntimeAssembly.InternalLoad(assemblyString, null, ref stackMark, false /*forIntrospection*/));
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
public static Assembly GetCallingAssembly()
{
// LookForMyCallersCaller is not guaranteed to return the correct stack frame
// because of inlining, tail calls, etc. As a result GetCallingAssembly is not
// guaranteed to return the correct result. It's also documented as such.
StackCrawlMark stackMark = StackCrawlMark.LookForMyCallersCaller;
return(GetExecutingAssembly(ref stackMark));
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
public static Type?GetType(
string typeName,
Func <AssemblyName, Assembly?>?assemblyResolver,
Func <Assembly?, string, bool, Type?>?typeResolver)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return(TypeNameParser.GetType(typeName, assemblyResolver, typeResolver, false, false, ref stackMark));
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
public static Assembly Load(string assemblyString)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return(RuntimeAssembly.InternalLoad(
assemblyString,
ref stackMark,
AssemblyLoadContext.CurrentContextualReflectionContext
));
}
public static Type GetType(
string typeName,
Func <AssemblyName, Assembly> assemblyResolver,
Func <Assembly, string, bool, Type> typeResolver,
bool throwOnError)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return(TypeNameParser.GetType(typeName, assemblyResolver, typeResolver, throwOnError, false, ref stackMark));
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
public static Assembly Load(AssemblyName assemblyRef)
{
if (assemblyRef == null)
{
throw new ArgumentNullException(nameof(assemblyRef));
}
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return(Load(assemblyRef, ref stackMark, IntPtr.Zero));
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
public static Assembly Load(AssemblyName assemblyRef)
{
if (assemblyRef == null)
{
throw new ArgumentNullException(nameof(assemblyRef));
}
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return(RuntimeAssembly.InternalLoad(assemblyRef, ref stackMark, AssemblyLoadContext.CurrentContextualReflectionContext));
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
public Assembly LoadFromAssemblyName(AssemblyName assemblyName)
{
if (assemblyName == null)
{
throw new ArgumentNullException(nameof(assemblyName));
}
// Attempt to load the assembly, using the same ordering as static load, in the current load context.
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return(Assembly.Load(assemblyName, ref stackMark, m_pNativeAssemblyLoadContext));
}
public Type GetType(String typeName)
{
if (typeName == null)
{
throw new ArgumentNullException("typeName");
}
Contract.EndContractBlock();
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return(RuntimeTypeHandle.GetTypeByName(
typeName, false /*throwOnError*/, false /*ignoreCase*/, false /*reflectionOnly*/, ref stackMark, m_contextObject, false /*loadTypeFromPartialName*/));
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
internal static Assembly Load(AssemblyName assemblyRef, IntPtr ptrLoadContextBinder)
{
Contract.Ensures(Contract.Result <Assembly>() != null);
Contract.Ensures(!Contract.Result <Assembly>().ReflectionOnly);
if (assemblyRef != null && assemblyRef.CodeBase != null)
{
throw new NotSupportedException(Environment.GetResourceString("NotSupported_AssemblyLoadCodeBase"));
}
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return(RuntimeAssembly.InternalLoadAssemblyName(assemblyRef, null, null, ref stackMark, true /*thrownOnFileNotFound*/, false /*forIntrospection*/, ptrLoadContextBinder));
}
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
static public Object CreateInstance(Type type, bool nonPublic)
{
if ((object)type == null)
throw new ArgumentNullException("type");
Contract.EndContractBlock();
RuntimeType rt = type.UnderlyingSystemType as RuntimeType;
if (rt == null)
throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "type");
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return rt.CreateInstanceDefaultCtor(!nonPublic, false, true, ref stackMark);
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
public static Assembly Load(AssemblyName assemblyRef)
{
Contract.Ensures(Contract.Result <Assembly>() != null);
Contract.Ensures(!Contract.Result <Assembly>().ReflectionOnly);
if (assemblyRef != null && assemblyRef.CodeBase != null)
{
throw new NotSupportedException(SR.NotSupported_AssemblyLoadCodeBase);
}
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return(RuntimeAssembly.InternalLoadAssemblyName(assemblyRef, null, null, ref stackMark, true /*thrownOnFileNotFound*/, false /*forIntrospection*/));
}
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
static public ObjectHandle CreateInstance(String assemblyName,
String typeName)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return CreateInstance(assemblyName,
typeName,
false,
Activator.ConstructorDefault,
null,
null,
null,
null,
null,
ref stackMark);
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
internal static Assembly LoadFrom(String assemblyFile,
Evidence securityEvidence)
{
Contract.Ensures(Contract.Result <Assembly>() != null);
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return(RuntimeAssembly.InternalLoadFrom(
assemblyFile,
securityEvidence,
null, // hashValue
AssemblyHashAlgorithm.None,
false, // forIntrospection);
ref stackMark));
}
static internal ObjectHandle CreateInstance(String assemblyName,
String typeName,
bool ignoreCase,
BindingFlags bindingAttr,
Binder binder,
Object[] args,
CultureInfo culture,
Object[] activationAttributes,
Evidence securityInfo,
ref StackCrawlMark stackMark)
{
Assembly assembly;
if (assemblyName == null)
{
assembly = Assembly.nGetExecutingAssembly(ref stackMark);
}
else
{
assembly = Assembly.InternalLoad(assemblyName, securityInfo, ref stackMark);
}
Log(assembly != null, "CreateInstance:: ", "Loaded " + assembly.FullName, "Failed to Load: " + assemblyName);
if (assembly == null)
{
return(null);
}
Type t = assembly.GetTypeInternal(typeName, true, ignoreCase, false);
Object o = Activator.CreateInstance(t,
bindingAttr,
binder,
args,
culture,
activationAttributes);
Log(o != null, "CreateInstance:: ", "Created Instance of class " + typeName, "Failed to create instance of class " + typeName);
if (o == null)
{
return(null);
}
else
{
ObjectHandle Handle = new ObjectHandle(o);
return(Handle);
}
}
internal static Assembly Load(AssemblyName assemblyRef, ref StackCrawlMark stackMark, AssemblyLoadContext?assemblyLoadContext)
{
AssemblyName modifiedAssemblyRef;
if (assemblyRef.CodeBase != null)
{
modifiedAssemblyRef = (AssemblyName)assemblyRef.Clone();
modifiedAssemblyRef.CodeBase = null;
}
else
{
modifiedAssemblyRef = assemblyRef;
}
return(RuntimeAssembly.InternalLoadAssemblyName(modifiedAssemblyRef, ref stackMark, assemblyLoadContext));
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
static public T CreateInstance <T>()
{
RuntimeType rt = typeof(T) as RuntimeType;
// This is a workaround to maintain compatibility with V2. Without this we would throw a NotSupportedException for void[].
// Array, Ref, and Pointer types don't have default constructors.
if (rt.HasElementType)
{
throw new MissingMethodException(Environment.GetResourceString("Arg_NoDefCTor"));
}
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
// Skip the CreateInstanceCheckThis call to avoid perf cost and to maintain compatibility with V2 (throwing the same exceptions).
return((T)rt.CreateInstanceDefaultCtor(true /*publicOnly*/, true /*skipCheckThis*/, true /*fillCache*/, ref stackMark));
}
internal extern static Assembly nGetExecutingAssembly(ref StackCrawlMark stackMark);
internal static extern RuntimeTypeHandle GetCallerType(ref StackCrawlMark stackMark);
internal static RuntimeMethodHandle GetCurrentMethod(ref StackCrawlMark stackMark)
{
return new RuntimeMethodHandle(_GetCurrentMethod(ref stackMark));
}
private static extern void* _GetCurrentMethod(ref StackCrawlMark stackMark);
internal static RuntimeTypeHandle GetTypeByName(string name, bool throwOnError, bool ignoreCase, bool reflectionOnly, ref StackCrawlMark stackMark)
{
if (name == null || name.Length == 0)
{
if (throwOnError)
throw new TypeLoadException(Environment.GetResourceString("Arg_TypeLoadNullStr"));
return new RuntimeTypeHandle();
}
return new RuntimeTypeHandle(_GetTypeByName(name, throwOnError, ignoreCase, reflectionOnly, ref stackMark, false));
}
private unsafe extern byte* GetResource(String resourceName, out ulong length,
ref StackCrawlMark stackMark,
bool skipSecurityCheck);
internal static Assembly InternalLoad(AssemblyName assemblyRef, bool stringized,
Evidence assemblySecurity, ref StackCrawlMark stackMark)
{
if (assemblyRef == null)
throw new ArgumentNullException("assemblyRef");
assemblyRef=(AssemblyName)assemblyRef.Clone();
if (assemblySecurity != null)
new SecurityPermission( SecurityPermissionFlag.ControlEvidence ).Demand();
String codeBase = AppDomain.VerifyCodeBase(assemblyRef.CodeBase);
if (codeBase != null) {
if (String.Compare( codeBase, 0, s_localFilePrefix, 0, 5, true, CultureInfo.InvariantCulture) != 0) {
IPermission perm = CreateWebPermission( assemblyRef.EscapedCodeBase );
if (perm == null) {
BCLDebug.Assert( false, "Unable to create System.Net.WebPermission" );
return null;
}
perm.Demand();
}
else {
System.Security.Util.URLString urlString = new System.Security.Util.URLString( codeBase, true );
new FileIOPermission( FileIOPermissionAccess.Read, urlString.GetFileName() ).Demand();
}
}
return nLoad(assemblyRef, codeBase, stringized, assemblySecurity, true, null, ref stackMark);
}
static internal extern ModuleBuilder nDefineDynamicModule(Assembly containingAssembly, bool emitSymbolInfo, String filename, ref StackCrawlMark stackMark);
internal virtual Stream GetManifestResourceStream(Type type, String name,
bool skipSecurityCheck, ref StackCrawlMark stackMark)
{
StringBuilder sb = new StringBuilder();
if(type == null) {
if (name == null)
throw new ArgumentNullException("type");
}
else {
String nameSpace = type.Namespace;
if(nameSpace != null) {
sb.Append(nameSpace);
if(name != null)
sb.Append(Type.Delimiter);
}
}
if(name != null)
sb.Append(name);
return GetManifestResourceStream(sb.ToString(), ref stackMark, skipSecurityCheck);
}
static internal extern Assembly nLoadImage(byte[] rawAssembly,
byte[] rawSymbolStore,
Evidence evidence,
ref StackCrawlMark stackMark);
private static extern Assembly nLoad(AssemblyName fileName,
String codeBase,
bool isStringized,
Evidence assemblySecurity,
bool throwOnFileNotFound,
Assembly locationHint,
ref StackCrawlMark stackMark);
internal static extern Type GetTypeImpl(String typeName, bool throwOnError,
bool ignoreCase, ref StackCrawlMark stackMark,
ref bool isAssemblyLoading);
internal unsafe virtual Stream GetManifestResourceStream(String name, ref StackCrawlMark stackMark, bool skipSecurityCheck)
{
ulong length = 0;
byte* pbInMemoryResource = GetResource(name, out length, ref stackMark, skipSecurityCheck);
if (pbInMemoryResource != null) {
//Console.WriteLine("Creating an unmanaged memory stream of length "+length);
if (length > Int64.MaxValue)
throw new NotImplementedException(Environment.GetResourceString("NotImplemented_ResourcesLongerThan2^63"));
return new __UnmanagedMemoryStream(pbInMemoryResource, (long)length, (long)length, false);
}
//Console.WriteLine("GetManifestResourceStream: Blob "+name+" not found...");
return null;
}
static internal ObjectHandle CreateInstance(String assemblyName,
String typeName,
bool ignoreCase,
BindingFlags bindingAttr,
Binder binder,
Object[] args,
CultureInfo culture,
Object[] activationAttributes,
Evidence securityInfo,
ref StackCrawlMark stackMark)
{
Assembly assembly;
if(assemblyName == null)
assembly = Assembly.nGetExecutingAssembly(ref stackMark);
else
assembly = Assembly.InternalLoad(assemblyName, securityInfo, ref stackMark);
Log(assembly != null, "CreateInstance:: ", "Loaded " + assembly.FullName, "Failed to Load: " + assemblyName);
if(assembly == null) return null;
Type t = assembly.GetTypeInternal(typeName, true, ignoreCase, false);
Object o = Activator.CreateInstance(t,
bindingAttr,
binder,
args,
culture,
activationAttributes);
Log(o != null, "CreateInstance:: ", "Created Instance of class " + typeName, "Failed to create instance of class " + typeName);
if(o == null)
return null;
else {
ObjectHandle Handle = new ObjectHandle(o);
return Handle;
}
}
private extern int nGetManifestResourceInfo(String resourceName,
out Assembly assemblyRef,
out String fileName,
ref StackCrawlMark stackMark);
internal static Assembly InternalLoad(String assemblyString,
Evidence assemblySecurity,
ref StackCrawlMark stackMark)
{
if (assemblyString == null)
throw new ArgumentNullException("assemblyString");
AssemblyName an = new AssemblyName();
an.Name = assemblyString;
return InternalLoad(an, true, assemblySecurity, ref stackMark);
}
internal extern static void* _GetTypeByName(string name, bool throwOnError, bool ignoreCase, bool reflectionOnly, ref StackCrawlMark stackMark, bool loadTypeFromPartialName);
