Example #1
0
        public void LoadDepencencies(Assembly asm, string assemblyLocation)
        {
            if (asm != null)
            {
                var toLoadAsm = _assemblyWrapper.GetReferencedAssemblies(asm);

                foreach (var toLoad in toLoadAsm)
                {
                    var fullName = toLoad.FullName;
                    if (_loadedAssemblies.Contains(fullName))
                    {
                        continue;
                    }
                    Assembly depAsm = null;
                    try
                    {
                        depAsm = _assemblyWrapper.Load(toLoad);
                    }
                    catch (Exception ex)
                    {
                        depAsm = LoadDependantAssembly(assemblyLocation, toLoad, fullName);
                    }
                    if (depAsm != null)
                    {
                        TryLoadDepencencies(assemblyLocation, fullName, depAsm);
                    }
                }
            }
            else
            {
                throw new Exception(string.Format(ErrorResource.CouldNotLocateAssembly, assemblyLocation));
            }
        }
Example #2
0
        private void FilterAssemblyForTestReference(IAssemblyWrapper assemblyToFilter, IAssemblyWrapper[] loadedAssemblies, IDictionary <IAssemblyWrapper, bool> filterResults)
        {
            if (filterResults.ContainsKey(assemblyToFilter))
            {
                return;
            }

            var references = assemblyToFilter.GetReferencedAssemblies();

            if (references.Any(IsTestReference))
            {
                filterResults[assemblyToFilter] = true;
                return;
            }

            foreach (var reference in references)
            {
                var referencedAssembly = loadedAssemblies.FirstOrDefault(a => a.Name.Name == reference.Name);
                if (referencedAssembly == null)
                {
                    continue;
                }

                FilterAssemblyForTestReference(referencedAssembly, loadedAssemblies, filterResults);

                if (filterResults[referencedAssembly])
                {
                    filterResults[assemblyToFilter] = true;
                    return;
                }
            }

            filterResults[assemblyToFilter] = false;
        }
        public void LoadDepencencies(Assembly asm, string assemblyLocation)
        {
            if (asm != null)
            {
                var toLoadAsm = _assemblyWrapper.GetReferencedAssemblies(asm);

                foreach (var toLoad in toLoadAsm)
                {
                    var fullName = toLoad.FullName;
                    if (_loadedAssemblies.Contains(fullName))
                    {
                        continue;
                    }
                    Assembly depAsm = null;
                    try
                    {
                        depAsm = _assemblyWrapper.Load(toLoad);
                    }
                    catch
                    {
                        var path = Path.GetDirectoryName(assemblyLocation);
                        if (path != null)
                        {
                            var myLoad = Path.Combine(path, toLoad.Name + ".dll");
                            try
                            {
                                depAsm = _assemblyWrapper.LoadFrom(myLoad);
                            }
                            catch (Exception)
                            {
                                if (!_loadedAssemblies.Contains(fullName))
                                {
                                    _loadedAssemblies.Add(fullName);
                                }
                            }
                        }
                    }
                    if (depAsm != null)
                    {
                        if (!_loadedAssemblies.Contains(fullName))
                        {
                            _loadedAssemblies.Add(fullName);
                        }
                        LoadDepencencies(depAsm, assemblyLocation);
                    }
                }
            }
            else
            {
                throw new Exception(string.Format(ErrorResource.CouldNotLocateAssembly, assemblyLocation));
            }
        }
        public AssemblyInterfaceData(IAssemblyWrapper assemblyToAnalyze)
        {
            Assembly = assemblyToAnalyze;

            Name = Assembly.GetName().Name;
            Version = "v" + Assembly.GetName().Version;
            CLRVersion = Assembly.ImageRuntimeVersion;

            ReferencedAssemblies = Assembly.GetReferencedAssemblies().Select(x => x.FullName).ToList();

            var types = Assembly.GetTypes();

            foreach (var type in types)
            {
                var typeEnumValue = GetTypeEnumValueForType(type);
                switch (typeEnumValue)
                {
                    case TypeEnum.Class:
                        Classes.Add(new ClassTypeData(type));
                        break;
                    case TypeEnum.Interface:
                        Interfaces.Add(new InterfaceTypeData(type));
                        break;
                    case TypeEnum.Enum:
                        Enums.Add(new EnumTypeData(type));
                        break;
                    case TypeEnum.Struct:
                        Structs.Add(new StructTypeData(type));
                        break;
                }
            }

            Classes = Classes.OrderBy(x => x.Name).ToList();
            Interfaces = Interfaces.OrderBy(x => x.Name).ToList();
            Enums = Enums.OrderBy(x => x.Name).ToList();
            Structs = Structs.OrderBy(x => x.Name).ToList();
        }