示例#1
0
        public static void TypeLoaderApisAfterDispose()
        {
            TypeLoader tl = new TypeLoader();

            tl.Dispose();

            Assert.Throws <ObjectDisposedException>(() => tl.LoadFromAssemblyName(new AssemblyName("Foo")));
            Assert.Throws <ObjectDisposedException>(() => tl.LoadFromAssemblyName("Foo"));
            Assert.Throws <ObjectDisposedException>(() => tl.LoadFromAssemblyPath("Foo"));
            Assert.Throws <ObjectDisposedException>(() => tl.LoadFromByteArray(TestData.s_SimpleAssemblyImage));
            Assert.Throws <ObjectDisposedException>(() => tl.LoadFromStream(new MemoryStream(TestData.s_SimpleAssemblyImage)));
        }
示例#2
0
        public static void LoadFromAssemblyName()
        {
            using (TypeLoader tl = new TypeLoader())
            {
                Stream   peStream = new MemoryStream(TestData.s_SimpleAssemblyImage);
                Assembly a        = tl.LoadFromStream(peStream);
                Assert.NotNull(a);

                Assembly a1 = tl.LoadFromAssemblyName(TestData.s_SimpleAssemblyName);
                Assert.Equal(a, a1);

                Assembly a2 = tl.LoadFromAssemblyName(new AssemblyName(TestData.s_SimpleAssemblyName));
                Assert.Equal(a, a2);
            }
        }
示例#3
0
        public static void AssemblyName_GetName_SimpleNameOnly()
        {
            using (TypeLoader tl = new TypeLoader())
            {
                Assembly     a  = tl.LoadFromByteArray(TestData.s_SimpleNameOnlyImage);
                AssemblyName an = a.GetName(copiedName: false);

                Assert.Equal("SimpleNameOnly", an.Name);

                Assert.Equal(AssemblyNameFlags.PublicKey, an.Flags);

                Version v = an.Version;
                Assert.NotNull(v);
                Assert.Equal(0, v.Major);
                Assert.Equal(0, v.Minor);
                Assert.Equal(0, v.Build);
                Assert.Equal(0, v.Revision);

                string cultureName = an.CultureName;
                Assert.Equal(string.Empty, cultureName);

                byte[] publicKey = an.GetPublicKey();
                Assert.Equal(0, publicKey.Length);

                Assert.Equal(AssemblyContentType.Default, an.ContentType);
                Assert.Equal(AssemblyHashAlgorithm.SHA1, an.HashAlgorithm);

                Assembly aAgain = tl.LoadFromAssemblyName(an);
                Assert.Equal(a, aAgain);
            }
        }
示例#4
0
 public static void LoadFromAssemblyNameNeverLoadedAssembly()
 {
     using (TypeLoader tl = new TypeLoader())
     {
         Assert.Throws <FileNotFoundException>(() => tl.LoadFromAssemblyName("NeverSawThis"));
     }
 }
示例#5
0
 public static void LoadFromAssemblyNameNullAssemblyName()
 {
     using (TypeLoader tl = new TypeLoader())
     {
         Assert.Throws <ArgumentNullException>(() => tl.LoadFromAssemblyName((AssemblyName)null));
     }
 }
示例#6
0
        //
        // For a given assembly name and its full path, Reflection-Only load the assembly directly
        // from the file in disk or load the file to memory and then create assembly instance from
        // memory buffer data.
        //
        private static Assembly ReflectionOnlyLoadAssembly(string assemblyName, string fullPathToAssembly)
        {
            Assembly assembly = null;

            // If the assembly path is empty, try to load assembly by name. LoadFromAssemblyName
            // will result in a TypeLoader.Resolve event that will contain more information about the
            // requested assembly.
            if (String.IsNullOrEmpty(fullPathToAssembly))
            {
                return(_typeLoader.LoadFromAssemblyName(assemblyName));
            }
            else if (_cachedTypeLoaderAssemblies.TryGetValue(fullPathToAssembly, out assembly))
            {
                return(assembly);
            }
            else if (!String.IsNullOrEmpty(assemblyName) && _cachedTypeLoaderAssemblies.TryGetValue(assemblyName, out assembly))
            {
                return(assembly);
            }
            else
            {
                assembly = _typeLoader.LoadFromAssemblyPath(fullPathToAssembly);
            }

            // Add the assembly to the cache. ReflectionHelper.ReflectionOnlyLoadAssembly
            // receives frequent calls requesting the same assembly.
            if (assembly != null && fullPathToAssembly != null)
            {
                _cachedTypeLoaderAssemblies.Add(fullPathToAssembly, assembly);
                _cachedTypeLoaderReferencePaths.Add(Path.GetDirectoryName(fullPathToAssembly));
            }

            return(assembly);
        }
示例#7
0
        public static RoType LoadTypeFromAssemblyQualifiedName(string name, RoAssembly defaultAssembly, bool ignoreCase, bool throwOnError)
        {
            if (!name.TypeNameContainsTypeParserMetacharacters())
            {
                // Fast-path: the type contains none of the parser metacharacters nor the escape character. Just treat as plain old type name.
                name.SplitTypeName(out string ns, out string simpleName);
                RoType type = defaultAssembly.GetTypeCore(ns, simpleName, ignoreCase: ignoreCase, out Exception e);
                if (type != null)
                {
                    return(type);
                }
                if (throwOnError)
                {
                    throw e;
                }
            }

            TypeLoader loader = defaultAssembly.Loader;

            Func <AssemblyName, Assembly> assemblyResolver =
                delegate(AssemblyName assemblyName)
            {
                return(loader.LoadFromAssemblyName(assemblyName));
            };

            Func <Assembly, string, bool, Type> typeResolver =
                delegate(Assembly assembly, string fullName, bool ignoreCase2)
            {
                if (assembly == null)
                {
                    assembly = defaultAssembly;
                }

                Debug.Assert(assembly is RoAssembly);
                RoAssembly roAssembly = (RoAssembly)assembly;

                fullName = fullName.UnescapeTypeNameIdentifier();
                fullName.SplitTypeName(out string ns, out string simpleName);
                Type type = roAssembly.GetTypeCore(ns, simpleName, ignoreCase: ignoreCase2, out Exception e);
                if (type != null)
                {
                    return(type);
                }
                if (throwOnError)
                {
                    throw e;
                }
                return(null);
            };

            return((RoType)Type.GetType(name, assemblyResolver: assemblyResolver, typeResolver: typeResolver, throwOnError: throwOnError, ignoreCase: ignoreCase));
        }
示例#8
0
        public static void AssemblyName_GetName_HashWithSha256()
        {
            using (TypeLoader tl = new TypeLoader())
            {
                Assembly     a  = tl.LoadFromByteArray(TestData.s_HashWithSha256Image);
                AssemblyName an = a.GetName(copiedName: false);
                Assert.Equal("HashWithSha256", an.Name);

                Assert.Equal(AssemblyHashAlgorithm.SHA256, an.HashAlgorithm);

                Assembly aAgain = tl.LoadFromAssemblyName(an);
                Assert.Equal(a, aAgain);
            }
        }
示例#9
0
        public static void AssemblyName_GetName_CultureFrCh()
        {
            using (TypeLoader tl = new TypeLoader())
            {
                Assembly     a  = tl.LoadFromByteArray(TestData.s_CultureFrChImage);
                AssemblyName an = a.GetName(copiedName: false);
                Assert.Equal("CultureFrCh", an.Name);

                string cultureName = an.CultureName;
                Assert.Equal("fr-CH", cultureName);

                Assembly aAgain = tl.LoadFromAssemblyName(an);
                Assert.Equal(a, aAgain);
            }
        }
示例#10
0
        public static void LoadExternalAssembly1()
        {
            using (TypeLoader tl = new TypeLoader())
            {
                Assembly runtimeAssembly = typeof(object).Assembly;  // Intentionally not projected.
                string   location        = runtimeAssembly.Location;

                tl.Resolving +=
                    delegate(TypeLoader sender, AssemblyName an)
                {
                    return(runtimeAssembly);
                };

                Assert.Throws <FileLoadException>(() => tl.LoadFromAssemblyName("DontCare"));
            }
        }
示例#11
0
        public static void AssemblyName_GetName_PublicKeyToken1ee753223f71263d()
        {
            using (TypeLoader tl = new TypeLoader())
            {
                Assembly     a  = tl.LoadFromByteArray(TestData.s_PublicKeyToken1ee753223f71263dImage);
                AssemblyName an = a.GetName(copiedName: false);
                Assert.Equal("PublicKeyToken1ee753223f71263d", an.Name);

                Assert.Equal(AssemblyNameFlags.PublicKey, an.Flags);

                byte[] publicKey = an.GetPublicKey();
                Assert.Equal <byte>(TestData.s_PublicKeyToken1ee753223f71263d_Pk, publicKey);

                Assembly aAgain = tl.LoadFromAssemblyName(an);
                Assert.Equal(a, aAgain);
            }
        }
示例#12
0
        public static void AssemblyName_GetName_Version1_2_65535_65535()
        {
            using (TypeLoader tl = new TypeLoader())
            {
                Assembly     a  = tl.LoadFromByteArray(TestData.s_Version1_2_65535_65535Image);
                AssemblyName an = a.GetName(copiedName: false);
                Assert.Equal("Version1_2_65535_65535", an.Name);

                Version v = an.Version;
                Assert.NotNull(v);
                Assert.Equal(1, v.Major);
                Assert.Equal(2, v.Minor);
                Assert.Equal(65535, v.Build);
                Assert.Equal(65535, v.Revision);

                Assembly aAgain = tl.LoadFromAssemblyName(an);
                Assert.Equal(a, aAgain);
            }
        }
示例#13
0
        public static void LoadFromDifferentLocations()
        {
            using (TempFile tf1 = TempFile.Create(TestData.s_SimpleAssemblyImage))
                using (TempFile tf2 = TempFile.Create(TestData.s_SimpleAssemblyImage))
                    using (TypeLoader tl = new TypeLoader())
                    {
                        // As long as the MVID matches, you can load the same assembly from multiple locations.
                        Assembly a = tl.LoadFromByteArray(TestData.s_SimpleAssemblyImage);
                        Assert.NotNull(a);

                        Assembly a1 = tl.LoadFromByteArray(TestData.s_SimpleAssemblyImage);
                        Assert.Equal(a, a1);

                        Assembly a2 = tl.LoadFromAssemblyName(new AssemblyName(TestData.s_SimpleAssemblyName));
                        Assert.Equal(a, a2);

                        Assembly a3 = tl.LoadFromAssemblyPath(tf1.Path);
                        Assert.Equal(a, a3);

                        Assembly a4 = tl.LoadFromAssemblyPath(tf2.Path);
                        Assert.Equal(a, a4);
                    }
        }
示例#14
0
        public static void CoreAssemblyCanBeAFacade()
        {
            using (TypeLoader tl = new TypeLoader(coreAssemblyName: TestData.s_PhonyCoreAssemblyName))
            {
                Assembly actualCoreAssembly = null;
                tl.Resolving +=
                    delegate(TypeLoader sender, AssemblyName refName)
                {
                    if (refName.Name.Equals("mscorlib", StringComparison.OrdinalIgnoreCase))
                    {
                        return(actualCoreAssembly = sender.LoadFromStream(TestUtils.CreateStreamForCoreAssembly()));
                    }
                    return(null);
                };

                Assembly a = tl.LoadFromByteArray(TestData.s_PhonyCoreAssemblyImage);

                // This is a sanity check to ensure that "TestData.s_PhonyCoreAssemblyName" is actually the def-name of this
                // assembly. It better be since we told our TypeLoader to use it as our core assembly.
                Assembly aAgain = tl.LoadFromAssemblyName(TestData.s_PhonyCoreAssemblyName);

                Type derived = a.GetType("Derived", throwOnError: true, ignoreCase: false);

                // Calling BaseType causes the TypeLoader to parse the typespec "Base<object>". Since "object" is a primitive
                // type, it should be encoded using the short-form "ELEMENT_TYPE_OBJECT." Hence, the TypeLoader is forced
                // to look up "System.Object" in the core assembly we assigned to it, which in this case is "PhonyCoreAssembly"
                // which type-forwards System.Object to "mscorlib".
                Type baseType = derived.BaseType;

                Assert.NotNull(actualCoreAssembly); // Ensure our resolve handler actually ran.
                Assert.NotEqual(a, actualCoreAssembly);
                Assert.True(baseType.IsConstructedGenericType);
                Type retrievedObjectType = baseType.GenericTypeArguments[0];
                Assert.Equal("System.Object", retrievedObjectType.FullName);
                Assert.Equal(actualCoreAssembly, retrievedObjectType.Assembly);
            }
        }