private IEnumerable <MemberDependency> GetDependencies(IAssemblyFile file)
        {
            try
            {
                using (var stream = file.OpenRead())
                    using (var peFile = new PEReader(stream))
                    {
                        var metadataReader = GetMetadataReader(peFile);

                        AddReferencedAssemblies(metadataReader);

                        var helper = new DependencyFinderEngineHelper(_assemblyFilter, metadataReader, file);
                        helper.ComputeData();

                        // Remember this assembly as a user assembly.
                        _userAssemblies.Add(helper.CallingAssembly);

                        return(helper.MemberDependency);
                    }
            }
            catch (Exception exc)
            {
                // InvalidPEAssemblyExceptions may be expected and indicative of a non-PE file
                if (exc is InvalidPEAssemblyException)
                {
                    throw;
                }

                // Other exceptions are unexpected, though, and wil benefit from
                // more details on the scenario that hit them
                throw new PortabilityAnalyzerException(string.Format(LocalizedStrings.MetadataParsingExceptionMessage, file.Name), exc);
            }
        }
        private IEnumerable <MemberDependency> GetDependencies(IAssemblyFile file)
        {
            try
            {
                using (var stream = file.OpenRead())
                {
                    using (var peFile = new PEReader(stream))
                    {
                        var metadataReader = GetMetadataReader(peFile);

                        var helper = new DependencyFinderEngineHelper(_assemblyFilter, metadataReader, file, _objectFinder);

                        if (_assemblyFilter.IsFrameworkAssembly(metadataReader.FormatAssemblyInfo()))
                        {
                            _nonUserAssemblies.Add(helper.CallingAssembly);
                            return(Enumerable.Empty <MemberDependency>());
                        }
                        else
                        {
                            AddReferencedAssemblies(metadataReader);

                            helper.ComputeData();

                            // Remember this assembly as a user assembly.
                            _userAssemblies.Add(helper.CallingAssembly);

                            return(helper.MemberDependency);
                        }
                    }
                }
            }
            catch (Exception exc)
            {
                // InvalidPEAssemblyExceptions may be expected and indicative of a non-PE file
                if (exc is InvalidPEAssemblyException)
                {
                    throw;
                }

                // Occurs when we cannot find the System.Object assembly.
                if (exc is SystemObjectNotFoundException)
                {
                    throw;
                }

                // Other exceptions are unexpected, though, and will benefit from
                // more details on the scenario that hit them
                throw new PortabilityAnalyzerException(string.Format(CultureInfo.CurrentCulture, LocalizedStrings.MetadataParsingExceptionMessage, file.Name), exc);
            }
        }
        private IEnumerable<MemberDependency> GetDependencies(IAssemblyFile file)
        {
            try
            {
                using (var stream = file.OpenRead())
                using (var peFile = new PEReader(stream))
                {
                    var metadataReader = GetMetadataReader(peFile);

                    AddReferencedAssemblies(metadataReader);

                    var helper = new DependencyFinderEngineHelper(_assemblyFilter, metadataReader, file);
                    helper.ComputeData();

                    // Remember this assembly as a user assembly.
                    _userAssemblies.Add(helper.CallingAssembly);

                    return helper.MemberDependency;
                }
            }
            catch (Exception exc)
            {
                // InvalidPEAssemblyExceptions may be expected and indicative of a non-PE file
                if (exc is InvalidPEAssemblyException) throw;

                // Other exceptions are unexpected, though, and wil benefit from
                // more details on the scenario that hit them
                throw new PortabilityAnalyzerException(string.Format(LocalizedStrings.MetadataParsingExceptionMessage, file.Name), exc);
            }
        }