void SaveAsync(SaveOptionsVM[] mods) { AppCulture.InitializeCulture(); try { moduleSaver = new ModuleSaver(mods); moduleSaver.OnProgressUpdated += moduleSaver_OnProgressUpdated; moduleSaver.OnLogMessage += moduleSaver_OnLogMessage; moduleSaver.OnWritingFile += moduleSaver_OnWritingFile; moduleSaver.SaveAll(); AsyncAddMessage(dnSpy_AsmEditor_Resources.SaveModules_Log_AllFilesWritten, false, false); } catch (TaskCanceledException) { AsyncAddMessage(dnSpy_AsmEditor_Resources.SaveModules_Log_SaveWasCanceled, true, false); } catch (UnauthorizedAccessException ex) { AsyncAddMessage(string.Format(dnSpy_AsmEditor_Resources.SaveModules_Log_AccessError, ex.Message), true, false); } catch (IOException ex) { AsyncAddMessage(string.Format(dnSpy_AsmEditor_Resources.SaveModules_Log_FileError, ex.Message), true, false); } catch (Exception ex) { AsyncAddMessage(string.Format(dnSpy_AsmEditor_Resources.SaveModules_Log_Exception, ex), true, false); } moduleSaver = null; ExecInOldThread(() => { CurrentFileName = string.Empty; State = SaveState.Saved; }); }
public HexEditorAppSettingsVM(HexEditorSettings hexEditorSettings) { this.hexEditorSettings = hexEditorSettings; this.asciiEncodingVM = new EnumListVM(asciiEncodingList, (a, b) => hexEditorSettings.AsciiEncoding = (AsciiEncoding)AsciiEncodingVM.SelectedItem); this.bytesGroupCountVM = new Int32VM(a => { HasErrorUpdated(); hexEditorSettings.BytesGroupCount = BytesGroupCountVM.Value; }); this.bytesPerLineVM = new Int32VM(a => { HasErrorUpdated(); hexEditorSettings.BytesPerLine = BytesPerLineVM.Value; }) { Min = 0, Max = HexEditorSettings.MAX_BYTES_PER_LINE, }; AsciiEncodingVM.SelectedItem = hexEditorSettings.AsciiEncoding; BytesGroupCountVM.Value = hexEditorSettings.BytesGroupCount; BytesPerLineVM.Value = hexEditorSettings.BytesPerLine; FontFamily = hexEditorSettings.FontFamily; Task.Factory.StartNew(() => { AppCulture.InitializeCulture(); return(FontUtils.GetMonospacedFonts()); }) .ContinueWith(t => { var ex = t.Exception; if (!t.IsCanceled && !t.IsFaulted) { FontFamilies = t.Result; } }, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()); }
public DisplayAppSettingsVM(TextEditorSettings textEditorSettings, FileTreeViewSettings fileTreeViewSettings, FileTabManagerSettings fileTabManagerSettings) { this.textEditorSettings = textEditorSettings; this.fileTreeViewSettings = fileTreeViewSettings; this.fileTabManagerSettings = fileTabManagerSettings; this.fontFamilies = null; this.fontFamilyVM = new FontFamilyVM(textEditorSettings.FontFamily); Task.Factory.StartNew(() => { AppCulture.InitializeCulture(); return(Fonts.SystemFontFamilies.Where(a => !FontUtils.IsSymbol(a)).OrderBy(a => a.Source.ToUpperInvariant()).Select(a => new FontFamilyVM(a)).ToArray()); }) .ContinueWith(t => { var ex = t.Exception; if (!t.IsCanceled && !t.IsFaulted) { FontFamilies = t.Result; } }, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()); var defObjs = typeof(MemberKind).GetEnumValues().Cast <MemberKind>().ToArray(); this.memberKindVMs = new MemberKindVM[defObjs.Length]; for (int i = 0; i < defObjs.Length; i++) { this.memberKindVMs[i] = new MemberKindVM(defObjs[i], ToString(defObjs[i])); } this.memberKindVMs2 = this.memberKindVMs.ToArray(); this.MemberKind0 = this.memberKindVMs.First(a => a.Object == fileTreeViewSettings.MemberKind0); this.MemberKind1 = this.memberKindVMs.First(a => a.Object == fileTreeViewSettings.MemberKind1); this.MemberKind2 = this.memberKindVMs.First(a => a.Object == fileTreeViewSettings.MemberKind2); this.MemberKind3 = this.memberKindVMs.First(a => a.Object == fileTreeViewSettings.MemberKind3); this.MemberKind4 = this.memberKindVMs.First(a => a.Object == fileTreeViewSettings.MemberKind4); }
public static CultureInfo ToCultureInfo(this AppCulture culture) { if (_cultureMapping.TryGetValue(culture, out var value)) { return(new CultureInfo(value.First())); } return(new CultureInfo(_cultureMapping[default].First()));
void ShowInternal(IFileTabContent tabContent, object serializedUI, Action <ShowTabContentEventArgs> onShownHandler, bool isRefresh) { Debug.Assert(asyncWorkerContext == null); var oldUIContext = UIContext; UIContext = tabContent.CreateUIContext(fileTabUIContextLocator); var cachedUIContext = UIContext; Debug.Assert(cachedUIContext.FileTab == null || cachedUIContext.FileTab == this); cachedUIContext.FileTab = this; Debug.Assert(cachedUIContext.FileTab == this); Debug.Assert(tabContent.FileTab == null || tabContent.FileTab == this); tabContent.FileTab = this; Debug.Assert(tabContent.FileTab == this); UpdateTitleAndToolTip(); var showCtx = new ShowContext(cachedUIContext, isRefresh); tabContent.OnShow(showCtx); bool asyncShow = false; var asyncTabContent = tabContent as IAsyncFileTabContent; if (asyncTabContent != null) { if (asyncTabContent.CanStartAsyncWorker(showCtx)) { asyncShow = true; var ctx = new AsyncWorkerContext(); asyncWorkerContext = ctx; Task.Factory.StartNew(() => { AppCulture.InitializeCulture(); asyncTabContent.AsyncWorker(showCtx, ctx.CancellationTokenSource); }, ctx.CancellationTokenSource.Token) .ContinueWith(t => { bool canShowAsyncOutput = ctx == asyncWorkerContext && cachedUIContext.FileTab == this && UIContext == cachedUIContext; if (asyncWorkerContext == ctx) { asyncWorkerContext = null; } ctx.Dispose(); asyncTabContent.EndAsyncShow(showCtx, new AsyncShowResult(t, canShowAsyncOutput)); bool success = !t.IsFaulted && !t.IsCanceled; OnShown(serializedUI, onShownHandler, showCtx, success); }, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()); } else { asyncTabContent.EndAsyncShow(showCtx, new AsyncShowResult()); } } if (!asyncShow) { OnShown(serializedUI, onShownHandler, showCtx, true); } fileTabManager.OnNewTabContentShown(this); }
void InitializeCulture(CultureInfo info) { if (info == null) { return; } Thread.CurrentThread.CurrentUICulture = info; AppCulture.__Initialize(Thread.CurrentThread.CurrentCulture, info); Debug.Assert(Thread.CurrentThread.CurrentUICulture.Equals(info)); }
void InitializeExecutionEngine(bool loadConfig, bool showHelp) { Debug.Assert(execState == null); if (execState != null) { throw new InvalidOperationException(); } execState = new ExecState(this, new CancellationTokenSource()); var execStateCache = execState; Task.Run(() => { AppCulture.InitializeCulture(); execStateCache.CancellationTokenSource.Token.ThrowIfCancellationRequested(); var userOpts = new UserScriptOptions(); if (loadConfig) { userOpts.LibPaths.AddRange(GetDefaultLibPaths()); userOpts.LoadPaths.AddRange(GetDefaultLoadPaths()); InitializeUserScriptOptions(userOpts); } var opts = ScriptOptions.Default; opts = opts.WithMetadataResolver(ScriptMetadataResolver.Default .WithBaseDirectory(AppDirectories.BinDirectory) .WithSearchPaths(userOpts.LibPaths.Distinct(StringComparer.OrdinalIgnoreCase))); opts = opts.WithSourceResolver(ScriptSourceResolver.Default .WithBaseDirectory(AppDirectories.BinDirectory) .WithSearchPaths(userOpts.LoadPaths.Distinct(StringComparer.OrdinalIgnoreCase))); opts = opts.WithImports(userOpts.Imports); opts = opts.WithReferences(userOpts.References); execStateCache.ScriptOptions = opts; var script = Create <object>(string.Empty, execStateCache.ScriptOptions, typeof(IScriptGlobals), null); execStateCache.CancellationTokenSource.Token.ThrowIfCancellationRequested(); execStateCache.ScriptState = script.RunAsync(execStateCache.Globals, execStateCache.CancellationTokenSource.Token).Result; if (showHelp) { this.replEditor.OutputPrintLine(Help); } }, execStateCache.CancellationTokenSource.Token) .ContinueWith(t => { execStateCache.IsInitializing = false; var ex = t.Exception; if (!t.IsCanceled && !t.IsFaulted) { CommandExecuted(); } else { replEditor.OutputPrintLine(string.Format("Could not create the script:\n\n{0}", ex)); } }, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()); }
void SearchNewThread(object o) { AppCulture.InitializeCulture(); try { var searchMsg = SearchResult.CreateMessage(filterSearcherOptions.Context, dnSpy_Resources.Searching, TextTokenKind.Text, true); SearchingResult = searchMsg; AddSearchResultNoCheck(searchMsg); var opts = new ParallelOptions { CancellationToken = cancellationTokenSource.Token, MaxDegreeOfParallelism = Environment.ProcessorCount, }; if (o is IDnSpyFileNode[]) { Parallel.ForEach((IDnSpyFileNode[])o, opts, node => { AppCulture.InitializeCulture(); cancellationTokenSource.Token.ThrowIfCancellationRequested(); var searcher = new FilterSearcher(filterSearcherOptions); searcher.SearchAssemblies(new IDnSpyFileNode[] { node }); }); } else if (o is SearchTypeInfo[]) { Parallel.ForEach((SearchTypeInfo[])o, opts, info => { AppCulture.InitializeCulture(); cancellationTokenSource.Token.ThrowIfCancellationRequested(); var searcher = new FilterSearcher(filterSearcherOptions); searcher.SearchTypes(new SearchTypeInfo[] { info }); }); } else { throw new InvalidOperationException(); } } catch (AggregateException ex) { if (ex.InnerExceptions.Any(a => a is TooManyResultsException)) { TooManyResults = true; } else { throw; } } catch (TooManyResultsException) { TooManyResults = true; } finally { filterSearcherOptions.Dispatcher.BeginInvoke(DISPATCHER_PRIO, new Action(SearchCompleted)); } }
void ThreadProc() { AppCulture.InitializeCulture(); try { task.Execute(this); } catch (OperationCanceledException) { QueueAction(new MyAction(() => WasCanceled = true), false); } catch (Exception ex) { errorMessage = ex.Message; } QueueAction(new MyAction(OnTaskCompleted), false); }
void ThreadMethodImpl() { Debug.Assert(isRunning); Debug.Assert(!completedSuccessfully); AppCulture.InitializeCulture(); try { ThreadMethod(); completedSuccessfully = true; } catch (OperationCanceledException) { } ExecInUIThread(RemoveMessageNode_UI); isRunning = false; }
void Refresh() { if (IsRefreshing) { return; } Collection.Clear(); cancellationToken = new CancellationTokenSource(); refreshThread = new Thread(() => { AppCulture.InitializeCulture(); RefreshAsync(); }); OnPropertyChanged("IsRefreshing"); refreshThread.Start(); }
public OpenFileListVM(bool syntaxHighlight, FileListManager fileListManager, Func <string, string> askUser) { this.syntaxHighlight = syntaxHighlight; this.fileListManager = fileListManager; this.askUser = askUser; this.fileListColl = new ObservableCollection <FileListVM>(); this.collectionView = (ListCollectionView)CollectionViewSource.GetDefaultView(fileListColl); this.collectionView.CustomSort = new FileListVM_Comparer(); this.selectedItems = new FileListVM[0]; this.removedFileLists = new HashSet <FileListVM>(); this.addedFileLists = new List <FileListVM>(); this.cancellationTokenSource = new CancellationTokenSource(); this.searchingForDefaultLists = true; var hash = new HashSet <string>(StringComparer.OrdinalIgnoreCase); foreach (var fileList in fileListManager.FileLists) { hash.Add(fileList.Name); fileListColl.Add(new FileListVM(this, fileList, true, true)); } Refilter(); Task.Factory.StartNew(() => { AppCulture.InitializeCulture(); return(new DefaultFileListFinder(cancellationTokenSource.Token).Find()); }, cancellationTokenSource.Token) .ContinueWith(t => { var ex = t.Exception; SearchingForDefaultLists = false; if (!t.IsCanceled && !t.IsFaulted) { foreach (var defaultList in t.Result) { if (hash.Contains(defaultList.Name)) { continue; } var fileList = new FileList(defaultList); fileListColl.Add(new FileListVM(this, fileList, false, false)); } Refilter(); } }, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()); }
void SearchNewThread(object o) { AppCulture.InitializeCulture(); var files = (IDnSpyFileNode[])o; try { var searchMsg = SearchResult.CreateMessage(filterSearcherOptions.Context, dnSpy_Resources.Searching, TextTokenKind.Text, true); SearchingResult = searchMsg; AddSearchResultNoCheck(searchMsg); var searcher = new FilterSearcher(filterSearcherOptions); searcher.SearchAssemblies(files); } catch (TooManyResultsException) { TooManyResults = true; } finally { filterSearcherOptions.Dispatcher.BeginInvoke(DISPATCHER_PRIO, new Action(SearchCompleted)); } }
public void AsyncExec(Action <CancellationTokenSource> preExec, Action asyncAction, Action <IAsyncShowResult> postExec) { CancelAsyncWorker(); var ctx = new AsyncWorkerContext(); asyncWorkerContext = ctx; preExec(ctx.CancellationTokenSource); Task.Factory.StartNew(() => { AppCulture.InitializeCulture(); asyncAction(); }, ctx.CancellationTokenSource.Token) .ContinueWith(t => { if (asyncWorkerContext == ctx) { asyncWorkerContext = null; } ctx.Dispose(); postExec(new AsyncShowResult(t, false)); }, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()); }
public OpenFromGACVM(bool syntaxHighlight) { this.syntaxHighlight = syntaxHighlight; this.gacFileList = new ObservableCollection <GACFileVM>(); this.collectionView = (ListCollectionView)CollectionViewSource.GetDefaultView(gacFileList); this.collectionView.CustomSort = new GACFileVM_Comparer(); this.cancellationTokenSource = new CancellationTokenSource(); this.searchingGAC = true; this.uniqueFiles = new HashSet <GACFileVM>(new GACFileVM_EqualityComparer()); var dispatcher = Dispatcher.CurrentDispatcher; Task.Factory.StartNew(() => { AppCulture.InitializeCulture(); new GACFileFinder(this, dispatcher, cancellationTokenSource.Token).Find(); }, cancellationTokenSource.Token) .ContinueWith(t => { var ex = t.Exception; SearchingGAC = false; Refilter(); }, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()); }
public void Execute(ExportToProjectVM vm) { vm.ProgressMinimum = 0; vm.ProgressMaximum = 1; vm.TotalProgress = 0; vm.IsIndeterminate = false; Task.Factory.StartNew(() => { AppCulture.InitializeCulture(); var decompilationContext = new DecompilationContext { CancellationToken = cancellationTokenSource.Token, GetDisableAssemblyLoad = () => owner.fileTreeView.FileManager.DisableAssemblyLoad(), }; var options = new ProjectCreatorOptions(vm.Directory, cancellationTokenSource.Token); options.ProjectVersion = vm.ProjectVersion; if (vm.CreateSolution) { options.SolutionFilename = vm.SolutionFilename; } options.Logger = this; options.ProgressListener = this; bool hasProjectGuid = vm.ProjectGuid.Value != null; string guidFormat = null; int guidNum = 0; if (hasProjectGuid) { string guidStr = vm.ProjectGuid.Value.ToString(); guidNum = int.Parse(guidStr.Substring(36 - 8, 8), NumberStyles.HexNumber); guidFormat = guidStr.Substring(0, 36 - 8) + "{0:X8}"; } foreach (var module in modules.OrderBy(a => a.Location, StringComparer.InvariantCultureIgnoreCase)) { var projOpts = new ProjectModuleOptions(module, vm.Language, decompilationContext) { DontReferenceStdLib = vm.DontReferenceStdLib, UnpackResources = vm.UnpackResources, CreateResX = vm.CreateResX, DecompileXaml = vm.DecompileXaml, ProjectGuid = hasProjectGuid ? new Guid(string.Format(guidFormat, guidNum++)) : Guid.NewGuid(), }; if (bamlDecompiler != null) { var o = BamlDecompilerOptions.Create(vm.Language); projOpts.DecompileBaml = (a, b, c, d) => bamlDecompiler.Decompile(a, b, c, o, d); } options.ProjectModules.Add(projOpts); } var creator = new MSBuildProjectCreator(options); creator.Create(); if (vm.CreateSolution) { fileToOpen = creator.SolutionFilename; } else { fileToOpen = creator.ProjectFilenames.FirstOrDefault(); } }, cancellationTokenSource.Token) .ContinueWith(t => { var ex = t.Exception; if (ex != null) { Error(string.Format(dnSpy_Resources.ErrorExceptionOccurred, ex)); } EmtpyErrorList(); vm.OnExportComplete(); if (!vm.ExportErrors) { dlg.Close(); if (vm.OpenProject) { OpenProject(); } } }, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()); }
bool ExecuteCommandInternal(string input) { Debug.Assert(execState != null && !execState.IsInitializing); if (execState == null || execState.IsInitializing) { return(true); } lock (lockObj) { Debug.Assert(execState.ExecTask == null && !execState.Executing); if (execState.ExecTask != null || execState.Executing) { return(true); } execState.Executing = true; } try { var scState = ParseScriptCommand(input); if (scState != null) { if (execState != null) { lock (lockObj) execState.Executing = false; } scState.Command.Execute(this, scState.Arguments); bool isReset = scState.Command is ResetCommand; if (!isReset) { CommandExecuted(); } return(true); } var oldState = execState; var taskSched = TaskScheduler.FromCurrentSynchronizationContext(); Task.Run(() => { AppCulture.InitializeCulture(); oldState.CancellationTokenSource.Token.ThrowIfCancellationRequested(); var opts = oldState.ScriptOptions.WithReferences(Array.Empty <MetadataReference>()).WithImports(Array.Empty <string>()); var execTask = oldState.ScriptState.ContinueWithAsync(input, opts, oldState.CancellationTokenSource.Token); oldState.CancellationTokenSource.Token.ThrowIfCancellationRequested(); lock (lockObj) { if (oldState == execState) { oldState.ExecTask = execTask; } } execTask.ContinueWith(t => { var ex = t.Exception; bool isActive; lock (lockObj) { isActive = oldState == execState; if (isActive) { oldState.ExecTask = null; } } if (isActive) { if (ex != null) { replEditor.OutputPrintLine(ex.ToString()); } if (!t.IsCanceled && !t.IsFaulted) { oldState.ScriptState = t.Result; var val = t.Result.ReturnValue; if (val != null) { replEditor.OutputPrintLine(Format(val)); } } CommandExecuted(); } }, CancellationToken.None, TaskContinuationOptions.None, taskSched); }) .ContinueWith(t => { if (execState != null) { lock (lockObj) execState.Executing = false; } var innerEx = t.Exception?.InnerException; if (innerEx is CompilationErrorException) { var cee = (CompilationErrorException)innerEx; PrintDiagnostics(cee.Diagnostics); CommandExecuted(); } else if (innerEx is OperationCanceledException) { CommandExecuted(); } else { ReportException(t); } }, CancellationToken.None, TaskContinuationOptions.None, taskSched); return(true); } catch (Exception ex) { if (execState != null) { lock (lockObj) execState.Executing = false; } replEditor.OutputPrintLine(string.Format("Error executing script:\n\n{0}", ex)); return(false); } }
/// <summary> /// Invoked when the application is launched normally by the end user. Other entry points /// will be used when the application is launched to open a specific file, to display /// search results, and so forth. /// </summary> /// <param name="e">Details about the launch request and process.</param> protected override async void OnLaunched(LaunchActivatedEventArgs e) { #if DEBUG if (System.Diagnostics.Debugger.IsAttached) { this.DebugSettings.EnableFrameRateCounter = true; } #endif Frame rootFrame = Window.Current.Content as Frame; // Do not repeat app initialization when the Window already has content, // just ensure that the window is active if (rootFrame == null) { // Create a Frame to act as the navigation context and navigate to the first page rootFrame = new Frame(); // TODO: change this value to a cache size that is appropriate for your application rootFrame.CacheSize = 1; if (e.PreviousExecutionState == ApplicationExecutionState.Terminated) { // TODO: Load state from previously suspended application } // Place the frame in the current Window Window.Current.Content = rootFrame; } if (rootFrame.Content == null) { #if WINDOWS_PHONE_APP // Removes the turnstile navigation for startup. if (rootFrame.ContentTransitions != null) { this.transitions = new TransitionCollection(); foreach (var c in rootFrame.ContentTransitions) { this.transitions.Add(c); } } rootFrame.ContentTransitions = null; rootFrame.Navigated += this.RootFrame_FirstNavigated; #endif #region AdpPushClient await ADPPushSDK.AdpPushClient.Instance.Init(AppConstant.AppId, AppConstant.ApiKey, AppConstant.Username, AppConstant.Password); ADPPushSDK.AdpPushClient.Instance.SetDevelopment(false); ADPPushSDK.AdpPushClient.Instance.PushNotificationReceived += InstanceOnPushNotificationReceived; #endregion AppCulture.SetCulture(); // When the navigation stack isn't restored navigate to the first page, // configuring the new page by passing required information as a navigation // parameter if (!AppSetting.IsRegisterd) { rootFrame.Navigate(typeof(RegisterationPage), e.Arguments); } else { await ADPPushSDK.AdpPushClient.Instance.Register(AppSetting.UserId); if (!rootFrame.Navigate(typeof(MainPage), e.Arguments)) { throw new Exception("Failed to create initial page"); } } } // Ensure the current window is active Window.Current.Activate(); }
public void Create() { SatelliteAssemblyFinder satelliteAssemblyFinder = null; try { var opts = new ParallelOptions { CancellationToken = options.CancellationToken, MaxDegreeOfParallelism = options.NumberOfThreads <= 0 ? Environment.ProcessorCount : options.NumberOfThreads, }; var filenameCreator = new FilenameCreator(options.Directory); var ctx = new DecompileContext(options.CancellationToken, logger); satelliteAssemblyFinder = new SatelliteAssemblyFinder(); Parallel.ForEach(options.ProjectModules, opts, modOpts => { AppCulture.InitializeCulture(); options.CancellationToken.ThrowIfCancellationRequested(); string name; lock (filenameCreator) name = filenameCreator.Create(modOpts.Module); var p = new Project(modOpts, name, satelliteAssemblyFinder); lock (projects) projects.Add(p); p.CreateProjectFiles(ctx); }); var jobs = GetJobs().ToArray(); bool writeSolutionFile = !string.IsNullOrEmpty(options.SolutionFilename); int maxProgress = jobs.Length + projects.Count; if (writeSolutionFile) { maxProgress++; } progressListener.SetMaxProgress(maxProgress); Parallel.ForEach(GetJobs(), opts, job => { AppCulture.InitializeCulture(); options.CancellationToken.ThrowIfCancellationRequested(); try { job.Create(ctx); } catch (OperationCanceledException) { throw; } catch (Exception ex) { var fjob = job as IFileJob; if (fjob != null) { logger.Error(string.Format(Languages_Resources.MSBuild_FileCreationFailed3, fjob.Filename, job.Description, ex.Message)); } else { logger.Error(string.Format(Languages_Resources.MSBuild_FileCreationFailed2, job.Description, ex.Message)); } } progressListener.SetProgress(Interlocked.Increment(ref totalProgress)); }); Parallel.ForEach(projects, opts, p => { AppCulture.InitializeCulture(); options.CancellationToken.ThrowIfCancellationRequested(); try { var writer = new ProjectWriter(p, p.Options.ProjectVersion ?? options.ProjectVersion, projects, options.UserGACPaths); writer.Write(); } catch (OperationCanceledException) { throw; } catch (Exception ex) { logger.Error(string.Format(Languages_Resources.MSBuild_FailedToCreateProjectFile, p.Filename, ex.Message)); } progressListener.SetProgress(Interlocked.Increment(ref totalProgress)); }); if (writeSolutionFile) { options.CancellationToken.ThrowIfCancellationRequested(); try { var writer = new SolutionWriter(options.ProjectVersion, projects, SolutionFilename); writer.Write(); } catch (OperationCanceledException) { throw; } catch (Exception ex) { logger.Error(string.Format(Languages_Resources.MSBuild_FailedToCreateSolutionFile, SolutionFilename, ex.Message)); } progressListener.SetProgress(Interlocked.Increment(ref totalProgress)); } Debug.Assert(totalProgress == maxProgress); progressListener.SetProgress(maxProgress); } finally { if (satelliteAssemblyFinder != null) { satelliteAssemblyFinder.Dispose(); } } }
public void Execute(ExportToProjectVM vm) { vm.ProgressMinimum = 0; vm.ProgressMaximum = 1; vm.TotalProgress = 0; vm.IsIndeterminate = false; Task.Factory.StartNew(() => { AppCulture.InitializeCulture(); var decompilationContext = new DecompilationContext { CancellationToken = cancellationTokenSource.Token, GetDisableAssemblyLoad = () => owner.fileTreeView.FileManager.DisableAssemblyLoad(), }; var options = new ProjectCreatorOptions(vm.Directory, cancellationTokenSource.Token); options.ProjectVersion = vm.ProjectVersion; if (vm.CreateSolution) { options.SolutionFilename = vm.SolutionFilename; } options.Logger = this; options.ProgressListener = this; foreach (var module in modules) { var projOpts = new ProjectModuleOptions(module, vm.Language, decompilationContext) { DontReferenceStdLib = vm.DontReferenceStdLib, UnpackResources = vm.UnpackResources, CreateResX = vm.CreateResX, DecompileXaml = vm.DecompileXaml, }; if (owner.bamlDecompiler != null) { var o = BamlDecompilerOptions.Create(vm.Language); projOpts.DecompileBaml = (a, b, c, d) => owner.bamlDecompiler.Value.Decompile(a, b, c, o, d); } options.ProjectModules.Add(projOpts); } var creator = new MSBuildProjectCreator(options); creator.Create(); if (vm.CreateSolution) { fileToOpen = creator.SolutionFilename; } else { fileToOpen = creator.ProjectFilenames.FirstOrDefault(); } }, cancellationTokenSource.Token) .ContinueWith(t => { var ex = t.Exception; if (ex != null) { Error(string.Format(dnSpy_Resources.ErrorExceptionOccurred, ex)); } EmtpyErrorList(); vm.OnExportComplete(); if (!vm.ExportErrors) { dlg.Close(); if (vm.OpenProject) { OpenProject(); } } }, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.FromCurrentSynchronizationContext()); }