Exemple #1
0
        protected TimeSpan RunInternal(AssemblyDefinition assembly, GeneratorProjectInfo projectInfo, ProjectGenerationSettings settings)
        {
            OnProjectGenerationStarted(assembly);

            string projFilePath = Path.Combine(projectInfo.Out, Path.GetFileNameWithoutExtension(projectInfo.Target) + projectInfo.Language.VSProjectFileExtension + (settings.JustDecompileSupportedProjectType ? string.Empty : MSBuildProjectBuilder.ErrorFileExtension));

            DecompilationPreferences preferences = new DecompilationPreferences();

            preferences.WriteFullNames              = false;
            preferences.WriteDocumentation          = projectInfo.AddDocumentation;
            preferences.RenameInvalidMembers        = projectInfo.RenameInvalidMembers;
            preferences.WriteLargeNumbersInHex      = projectInfo.WriteLargeNumbersInHex;
            preferences.DecompileDangerousResources = projectInfo.DecompileDangerousResources;

            IFrameworkResolver      frameworkResolver      = new ConsoleFrameworkResolver(projectInfo.FrameworkVersion);
            ITargetPlatformResolver targetPlatformResolver = TargetPlatformResolver.Instance;

            BaseProjectBuilder projectBuilder = GetProjectBuilder(assembly, projectInfo, settings, projectInfo.Language, projFilePath, preferences, frameworkResolver, targetPlatformResolver);

            AttachProjectBuilderEventHandlers(projectBuilder);

            //As per https://github.com/telerik/JustDecompileEngine/pull/2
            DateTime startTime = DateTime.UtcNow;

            projectBuilder.BuildProject();
            TimeSpan projectGenerationTime = DateTime.UtcNow - startTime;

            DetachProjectBuilderEventHandlers(projectBuilder);

            return(projectGenerationTime);
        }
        public static IAssemblyDecompilationResults GenerateFiles(string assemblyFilePath, AssemblyDefinition assembly, string targetPath, SupportedLanguage language, CancellationToken cancellationToken, bool decompileDangerousResources, IFileGenerationNotifier notifier = null)
        {
            ILanguage decompilerLanguage = GetLanguage(language);
            string    csprojFileName     = Path.ChangeExtension(Path.GetFileName(assemblyFilePath), decompilerLanguage.VSProjectFileExtension);
            string    csprojTargetPath   = Path.Combine(targetPath, csprojFileName);

            Dictionary <ModuleDefinition, Mono.Collections.Generic.Collection <TypeDefinition> > assemblyUserDefinedTypes = Utilities.GetUserDefinedTypes(assembly, decompileDangerousResources);
            Dictionary <ModuleDefinition, Mono.Collections.Generic.Collection <Resource> >       assemblyResources        = Utilities.GetResources(assembly);

            IDecompilationPreferences decompilationPreferences = new DecompilationPreferences()
            {
                DecompileDangerousResources = decompileDangerousResources
            };

            JustAssemblyProjectBuilder projectBuilder;

            if (notifier != null)
            {
                projectBuilder = new JustAssemblyProjectBuilder(assemblyFilePath, assembly, assemblyUserDefinedTypes, assemblyResources, csprojTargetPath, decompilerLanguage, decompilationPreferences, new FileGenerationNotifier(notifier));
            }
            else
            {
                projectBuilder = new JustAssemblyProjectBuilder(assemblyFilePath, assembly, assemblyUserDefinedTypes, assemblyResources, csprojTargetPath, decompilerLanguage, decompilationPreferences, null);
            }

            return(projectBuilder.GenerateFiles(cancellationToken));
        }
Exemple #3
0
        public override Task <CreateProjectResponse> CreateProject(CreateProjectRequest request, ServerCallContext context)
        {
            if (string.IsNullOrEmpty(request.OutputPath) || string.IsNullOrEmpty(request.AssemblyFilePath))
            {
                throw new RpcException(new Status(StatusCode.InvalidArgument, "Invalid argument"));
            }

            bool decompileDangerousResources        = request.DecompileDangerousResources;
            VisualStudioVersion visualStudioVersion = this.GetProjectCreationVSVersion(request.ProjectVisualStudioVersion);
            ILanguage           language            = LanguageFactory.GetLanguage(CSharpVersion.V7);

            AssemblyDefinition        assembly = GlobalAssemblyResolver.Instance.GetAssemblyDefinition(request.AssemblyFilePath);
            ProjectGenerationSettings settings = ProjectGenerationSettingsProvider.GetProjectGenerationSettings(request.AssemblyFilePath, NoCacheAssemblyInfoService.Instance,
                                                                                                                EmptyResolver.Instance, visualStudioVersion, language, TargetPlatformResolver.Instance);

            DecompilationPreferences preferences = new DecompilationPreferences()
            {
                WriteFullNames              = false,
                WriteDocumentation          = true,
                RenameInvalidMembers        = true,
                WriteLargeNumbersInHex      = false,
                DecompileDangerousResources = decompileDangerousResources
            };

            BaseProjectBuilder projectBuilder         = this.GetProjectBuilder(assembly, request.AssemblyFilePath, visualStudioVersion, settings, language, request.OutputPath, preferences, EmptyResolver.Instance, TargetPlatformResolver.Instance);
            string             generationErrorMessage = this.CreateProject(projectBuilder);

            return(Task.FromResult(new CreateProjectResponse()
            {
                ErrorMessage = generationErrorMessage
            }));
        }
        private MSBuildProjectBuilder CreateProjectBuilder(string target, string output)
        {
            DecompilationPreferences preferences = new DecompilationPreferences();

            preferences.WriteFullNames              = false;
            preferences.WriteDocumentation          = true;
            preferences.RenameInvalidMembers        = true;
            preferences.WriteLargeNumbersInHex      = true;
            preferences.DecompileDangerousResources = false;

            ILanguage language     = LanguageFactory.GetLanguage(CSharpVersion.None);
            string    projFilePath = Path.Combine(output, Path.GetFileNameWithoutExtension(target) + language.VSProjectFileExtension);

            TestMSBuildProjectBuilder result = new TestMSBuildProjectBuilder(target, projFilePath, language, preferences);

            return(result);
        }
Exemple #5
0
        protected TimeSpan RunInternal(AssemblyDefinition assembly, GeneratorProjectInfo projectInfo, ProjectGenerationSettings settings)
        {
            string projFilePath = Path.Combine(projectInfo.Out, Path.GetFileNameWithoutExtension(projectInfo.Target) + projectInfo.Language.VSProjectFileExtension + (settings.JustDecompileSupportedProjectType ? string.Empty : MSBuildProjectBuilder.ErrorFileExtension));

            DecompilationPreferences preferences = new DecompilationPreferences();

            preferences.WriteFullNames       = false;
            preferences.WriteDocumentation   = projectInfo.AddDocumentation;
            preferences.RenameInvalidMembers = projectInfo.RenameInvalidMembers;

            IFrameworkResolver    frameworkResolver = new ConsoleFrameworkResolver(projectInfo.FrameworkVersion);
            MSBuildProjectBuilder projectBuilder    = GetProjectBuilder(assembly, projectInfo, settings, projectInfo.Language, projFilePath, preferences, frameworkResolver);

            ConfigurateProjectBuilder(projectBuilder);

            DateTime startTime = DateTime.Now;

            projectBuilder.BuildProject();
            TimeSpan projectGenerationTime = DateTime.Now - startTime;

            return(projectGenerationTime);
        }
Exemple #6
0
        private BaseProjectBuilder GetProjectBuilder(AssemblyDefinition assembly, GeneratorProjectInfo projectInfo, ProjectGenerationSettings settings, ILanguage language, string projFilePath, DecompilationPreferences preferences, IFrameworkResolver frameworkResolver, ITargetPlatformResolver targetPlatformResolver)
        {
            TargetPlatform     targetPlatform = targetPlatformResolver.GetTargetPlatform(assembly.MainModule.FilePath, assembly.MainModule);
            BaseProjectBuilder projectBuilder = null;

            if (targetPlatform == TargetPlatform.NetCore)
            {
                projectBuilder = new NetCoreProjectBuilder(projectInfo.Target, projFilePath, language, preferences, null, NoCacheAssemblyInfoService.Instance, projectInfo.VisualStudioVersion, settings);
            }
            else if (targetPlatform == TargetPlatform.WinRT)
            {
                projectBuilder = new WinRTProjectBuilder(projectInfo.Target, projFilePath, language, preferences, null, NoCacheAssemblyInfoService.Instance, projectInfo.VisualStudioVersion, settings);
            }
            else
            {
                projectBuilder = new MSBuildProjectBuilder(projectInfo.Target, projFilePath, language, frameworkResolver, preferences, null, NoCacheAssemblyInfoService.Instance, projectInfo.VisualStudioVersion, settings);
            }

            return(projectBuilder);
        }
 public TestMSBuildProjectBuilder(string assemblyPath, string targetPath, ILanguage language, DecompilationPreferences decompilationPreferences, VisualStudioVersion visualStudioVersion = VisualStudioVersion.VS2010, ProjectGenerationSettings projectGenerationSettings = null, IProjectGenerationNotifier projectNotifier = null)
     : base(assemblyPath, targetPath, language, new TestsFrameworkVersionResolver(), decompilationPreferences, null, NoCacheAssemblyInfoService.Instance, visualStudioVersion, projectGenerationSettings, projectNotifier)
 {
     this.exceptionFormater = TestCaseExceptionFormatter.Instance;
     this.currentAssemblyResolver.ClearCache();
 }