private async Task <string> GetConversionSummaryAsync(IReadOnlyCollection <string> files, IReadOnlyCollection <string> errors)
{
var oneLine = "Code conversion failed";
var successSummary = "";
if (files.Any())
{
oneLine = "Code conversion completed";
successSummary = $"{files.Count} files have been written to disk.";
}
if (errors.Any())
{
oneLine += $" with {errors.Count} error" + (errors.Count == 1 ? "" : "s");
}
if (files.Count > errors.Count * 2)
{
successSummary += Environment.NewLine + "Please report issues at https://github.com/icsharpcode/CodeConverter/issues and consider rating at https://marketplace.visualstudio.com/items?itemName=SharpDevelopTeam.CodeConverter#review-details";
}
else
{
successSummary += Environment.NewLine + "Please report issues at https://github.com/icsharpcode/CodeConverter/issues";
}
await VisualStudioInteraction.WriteStatusBarTextAsync(_serviceProvider, oneLine + " - see output window");
return(Environment.NewLine + Environment.NewLine
+ oneLine
+ Environment.NewLine + successSummary
+ Environment.NewLine);
}
private async Task ProjectItemMenuItemCallbackAsync(object sender, EventArgs e)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
string itemPath = (await VisualStudioInteraction.GetSingleSelectedItemOrDefaultAsync())?.ItemPath;
await ConvertDocumentAsync(itemPath, new Span(0, 0));
}
private async Task CodeEditorMenuItemCallbackAsync(CancellationToken cancellationToken)
{
var(filePath, selection) = await VisualStudioInteraction.GetCurrentFilenameAndSelectionAsync(ServiceProvider, CodeConversion.IsVBFileName, false);
if (filePath != null && selection != null)
{
await ConvertDocumentAsync(filePath, selection.Value, cancellationToken);
}
}
private async Task CodeEditorMenuItem_BeforeQueryStatusAsync(object sender, EventArgs e)
{
if (sender is OleMenuCommand menuItem)
{
var selectionInCurrentViewAsync = await VisualStudioInteraction.GetFirstSelectedSpanInCurrentViewAsync(ServiceProvider, CodeConversion.IsCSFileName, true);
menuItem.Visible = selectionInCurrentViewAsync != null;
}
}
private async Task CodeEditorMenuItemCallbackAsync(object sender, EventArgs e)
{
var(filePath, selection) = await VisualStudioInteraction.GetCurrentFilenameAndSelectionAsync(ServiceProvider, CodeConversion.IsCSFileName, false);
if (filePath != null && selection != null)
{
await ConvertDocumentAsync(filePath, selection.Value);
}
}
private void SolutionOrProjectMenuItem_BeforeQueryStatus(object sender, EventArgs e)
{
var menuItem = sender as OleMenuCommand;
if (menuItem != null)
{
menuItem.Visible = menuItem.Enabled = VisualStudioInteraction.GetSelectedProjects(ProjectExtension).Any();
}
}
private async void SolutionOrProjectMenuItemCallback(object sender, EventArgs e)
{
try {
var projects = VisualStudioInteraction.GetSelectedProjects(ProjectExtension);
await _codeConversion.PerformProjectConversion <VBToCSConversion>(projects);
} catch (Exception ex) {
VisualStudioInteraction.ShowException(ServiceProvider, CodeConversion.ConverterTitle, ex);
}
}
private async Task SolutionOrProjectMenuItem_BeforeQueryStatusAsync(object sender, EventArgs e)
{
if (sender is OleMenuCommand menuItem)
{
var selectedProjectsAsync = await VisualStudioInteraction.GetSelectedProjectsAsync(ProjectExtension);
menuItem.Visible = menuItem.Enabled = selectedProjectsAsync.Any();
}
}
private async Task SolutionOrProjectMenuItemCallbackAsync(CancellationToken cancellationToken)
{
try {
var projects = VisualStudioInteraction.GetSelectedProjectsAsync(ProjectExtension);
await _codeConversion.ConvertProjectsAsync <VBToCSConversion>(await projects, cancellationToken);
} catch (Exception ex) {
await VisualStudioInteraction.ShowExceptionAsync(ServiceProvider, CodeConversion.ConverterTitle, ex);
}
}
private async Task SolutionOrProjectMenuItemCallbackAsync(object sender, EventArgs e)
{
try {
var projects = VisualStudioInteraction.GetSelectedProjectsAsync(ProjectExtension);
await _codeConversion.PerformProjectConversionAsync <CSToVBConversion>(await projects);
} catch (Exception ex) {
await VisualStudioInteraction.ShowExceptionAsync(ServiceProvider, CodeConversion.ConverterTitle, ex);
}
}
private bool UserHasConfirmedOverwrite(List <string> files, List <string> errors, string pathsToOverwrite)
{
return(VisualStudioInteraction.ShowMessageBox(_serviceProvider,
"Overwrite solution and referencing projects?",
$@"The current solution file and any referencing projects will be overwritten to reference the new project(s):
* {pathsToOverwrite}
The old contents will be copied to 'currentFilename.bak'.
Please 'Reload All' when Visual Studio prompts you.", true, files.Count > errors.Count));
}
private Task <bool> UserHasConfirmedOverwriteAsync(List <string> files, List <string> errors, IReadOnlyCollection <string> pathsToOverwrite)
{
var maxExamples = 30; // Avoid a huge unreadable dialog going off the screen
var exampleText = pathsToOverwrite.Count > maxExamples ? $". First {maxExamples} examples" : "";
return(VisualStudioInteraction.ShowMessageBoxAsync(_serviceProvider,
"Overwrite solution and referencing projects?",
$@"The current solution file and any referencing projects will be overwritten to reference the new project(s){exampleText}:
* {string.Join(Environment.NewLine + "* ", pathsToOverwrite.Take(maxExamples))}
The old contents will be copied to 'currentFilename.bak'.
Please 'Reload All' when Visual Studio prompts you.", true, files.Count > errors.Count));
}
private async Task ConvertDocumentAsync(string documentPath, Span selected, CancellationToken cancellationToken)
{
if (documentPath == null || !CodeConversion.IsVBFileName(documentPath))
{
return;
}
try {
await _codeConversion.ConvertDocumentAsync <VBToCSConversion>(documentPath, selected, cancellationToken);
} catch (Exception ex) {
await VisualStudioInteraction.ShowExceptionAsync(ServiceProvider, CodeConversion.ConverterTitle, ex);
}
}
private async Task ConvertDocumentAsync(string documentPath, Span selected)
{
if (documentPath == null || !CodeConversion.IsCSFileName(documentPath))
{
return;
}
try {
await _codeConversion.PerformDocumentConversionAsync <CSToVBConversion>(documentPath, selected);
} catch (Exception ex) {
await VisualStudioInteraction.ShowExceptionAsync(ServiceProvider, CodeConversion.ConverterTitle, ex);
}
}
public async Task PerformDocumentConversion <TLanguageConversion>(string documentFilePath, Span selected) where TLanguageConversion : ILanguageConversion, new()
{
var conversionResult = await Task.Run(async() => {
var result = await ConvertDocumentUnhandled <TLanguageConversion>(documentFilePath, selected);
WriteConvertedFilesAndShowSummary(new[] { result });
return(result);
});
if (GetOptions().CopyResultToClipboardForSingleDocument)
{
Clipboard.SetText(conversionResult.ConvertedCode ?? conversionResult.GetExceptionsAsString());
_outputWindow.WriteToOutputWindow("Conversion result copied to clipboard.");
VisualStudioInteraction.ShowMessageBox(_serviceProvider, "Conversion result copied to clipboard.", conversionResult.GetExceptionsAsString(), false);
}
}
public async Task PerformDocumentConversionAsync <TLanguageConversion>(string documentFilePath, Span selected) where TLanguageConversion : ILanguageConversion, new()
{
var conversionResult = await _joinableTaskFactory.RunAsync(async() => {
var result = await ConvertDocumentUnhandledAsync <TLanguageConversion>(documentFilePath, selected);
await WriteConvertedFilesAndShowSummaryAsync(new[] { result });
return(result);
});
if ((await GetOptions()).CopyResultToClipboardForSingleDocument)
{
Clipboard.SetText(conversionResult.ConvertedCode ?? conversionResult.GetExceptionsAsString());
await _outputWindow.WriteToOutputWindowAsync(Environment.NewLine + "Conversion result copied to clipboard.");
await VisualStudioInteraction.ShowMessageBoxAsync(_serviceProvider, "Conversion result copied to clipboard.", conversionResult.GetExceptionsAsString(), false);
}
}
private async Task ProjectItemMenuItem_BeforeQueryStatusAsync(object sender, EventArgs e)
{
if (sender is OleMenuCommand menuItem)
{
menuItem.Visible = false;
menuItem.Enabled = false;
string itemPath = (await VisualStudioInteraction.GetSingleSelectedItemOrDefaultAsync())?.ItemPath;
if (itemPath == null || !CodeConversion.IsCSFileName(itemPath))
{
return;
}
menuItem.Visible = true;
menuItem.Enabled = true;
}
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
var oleMenuCommandService = await this.GetServiceAsync <IMenuCommandService, OleMenuCommandService>();
var componentModel = await this.GetServiceAsync <SComponentModel, IComponentModel>();
await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
var visualStudioWorkspace = componentModel.GetService <VisualStudioWorkspace>();
var codeConversion = await CodeConversion.CreateAsync(this, visualStudioWorkspace, this.GetDialogPageAsync <ConverterOptionsPage>);
ConvertCSToVBCommand.Initialize(this, oleMenuCommandService, codeConversion);
ConvertVBToCSCommand.Initialize(this, oleMenuCommandService, codeConversion);
VisualStudioInteraction.Initialize(PackageCancellation);
await TaskScheduler.Default;
await base.InitializeAsync(cancellationToken, progress);
}
public IWpfTextViewHost GetCurrentViewHost(Func <string, bool> predicate)
{
IWpfTextViewHost viewHost = VisualStudioInteraction.GetCurrentViewHost(_serviceProvider);
if (viewHost == null)
{
return(null);
}
ITextDocument textDocument = viewHost.GetTextDocument();
if (textDocument == null || !predicate(textDocument.FilePath))
{
return(null);
}
return(viewHost);
}
private void WriteConvertedFilesAndShowSummary(IEnumerable <ConversionResult> convertedFiles)
{
var files = new List <string>();
var errors = new List <string>();
string longestFilePath = null;
var longestFileLength = -1;
var solutionDir = Path.GetDirectoryName(_visualStudioWorkspace.CurrentSolution.FilePath);
VisualStudioInteraction.OutputWindow.WriteToOutputWindow(Intro);
VisualStudioInteraction.OutputWindow.ForceShowOutputPane();
foreach (var convertedFile in convertedFiles)
{
var sourcePath = convertedFile.SourcePathOrNull ?? "";
var sourcePathRelativeToSolutionDir = PathRelativeToSolutionDir(solutionDir, sourcePath);
if (sourcePath != "")
{
if (!string.IsNullOrWhiteSpace(convertedFile.ConvertedCode))
{
var path = ToggleExtension(sourcePath);
if (convertedFile.ConvertedCode.Length > longestFileLength)
{
longestFileLength = convertedFile.ConvertedCode.Length;
longestFilePath = path;
}
files.Add(path);
File.WriteAllText(path, convertedFile.ConvertedCode);
}
LogProgress(convertedFile, errors, sourcePathRelativeToSolutionDir);
}
}
VisualStudioInteraction.OutputWindow.WriteToOutputWindow(GetConversionSummary(files, errors));
VisualStudioInteraction.OutputWindow.ForceShowOutputPane();
if (longestFilePath != null)
{
VisualStudioInteraction.OpenFile(new FileInfo(longestFilePath)).SelectAll();
}
}
void ProjectItemMenuItem_BeforeQueryStatus(object sender, EventArgs e)
{
var menuItem = sender as OleMenuCommand;
if (menuItem != null)
{
menuItem.Visible = false;
menuItem.Enabled = false;
string itemPath = VisualStudioInteraction.GetSingleSelectedItemOrDefault()?.ItemPath;
if (itemPath == null || !CodeConversion.IsVBFileName(itemPath))
{
return;
}
menuItem.Visible = true;
menuItem.Enabled = true;
}
}
private void WriteConvertedFilesAndShowSummary(IEnumerable <ConversionResult> convertedFiles)
{
var files = new List <string>();
var errors = new List <string>();
string longestFilePath = null;
var longestFileLength = -1;
var solutionDir = Path.GetDirectoryName(_visualStudioWorkspace.CurrentSolution.FilePath);
VisualStudioInteraction.OutputWindow.WriteToOutputWindow(Intro);
VisualStudioInteraction.OutputWindow.ForceShowOutputPane();
foreach (var convertedFile in convertedFiles)
{
var sourcePath = convertedFile.SourcePathOrNull;
if (convertedFile.Success && sourcePath != null)
{
var path = ToggleExtension(sourcePath);
if (convertedFile.ConvertedCode.Length > longestFileLength)
{
longestFileLength = convertedFile.ConvertedCode.Length;
longestFilePath = path;
}
files.Add(path);
File.WriteAllText(path, convertedFile.ConvertedCode);
LogCompleted(solutionDir, path);
}
else
{
errors.Add(convertedFile.GetExceptionsAsString());
LogError(solutionDir, convertedFile);
}
}
VisualStudioInteraction.OutputWindow.WriteToOutputWindow(GetConversionSummary(files, errors));
VisualStudioInteraction.OutputWindow.ForceShowOutputPane();
if (longestFilePath != null)
{
VisualStudioInteraction.OpenFile(new FileInfo(longestFilePath)).SelectAll();
}
}
private async Task FinalizeConversionAsync(List <string> files, List <string> errors, string longestFilePath, List <ConversionResult> filesToOverwrite)
{
var options = await GetOptions();
var pathsToOverwrite = filesToOverwrite.Select(f => PathRelativeToSolutionDir(f.SourcePathOrNull));
var shouldOverwriteSolutionAndProjectFiles =
filesToOverwrite.Any() &&
(options.AlwaysOverwriteFiles || await UserHasConfirmedOverwriteAsync(files, errors, pathsToOverwrite.ToList()));
if (shouldOverwriteSolutionAndProjectFiles)
{
var titleMessage = options.CreateBackups ? "Creating backups and overwriting files:" : "Overwriting files:" + "";
await _outputWindow.WriteToOutputWindowAsync(Environment.NewLine + titleMessage);
foreach (var fileToOverwrite in filesToOverwrite)
{
if (options.CreateBackups)
{
File.Copy(fileToOverwrite.SourcePathOrNull, fileToOverwrite.SourcePathOrNull + ".bak", true);
}
fileToOverwrite.WriteToFile();
var targetPathRelativeToSolutionDir = PathRelativeToSolutionDir(fileToOverwrite.TargetPathOrNull);
await _outputWindow.WriteToOutputWindowAsync($"* {targetPathRelativeToSolutionDir}");
}
files = files.Concat(filesToOverwrite.Select(f => f.SourcePathOrNull)).ToList();
}
else if (longestFilePath != null)
{
await(await VisualStudioInteraction.OpenFileAsync(new FileInfo(longestFilePath))).SelectAllAsync();
}
var conversionSummary = await GetConversionSummaryAsync(files, errors);
await _outputWindow.WriteToOutputWindowAsync(conversionSummary);
await _outputWindow.ForceShowOutputPaneAsync();
}
public async Task ConvertDocumentAsync <TLanguageConversion>(string documentFilePath, Span selected, CancellationToken cancellationToken) where TLanguageConversion : ILanguageConversion, new()
{
try {
var conversionResult = await _joinableTaskFactory.RunAsync(async() => {
var result = await ConvertDocumentUnhandledAsync <TLanguageConversion>(documentFilePath, selected, cancellationToken);
await WriteConvertedFilesAndShowSummaryAsync(new[] { result }.ToAsyncEnumerable());
return(result);
});
if ((await GetOptions()).CopyResultToClipboardForSingleDocument)
{
await SetClipboardTextOnUiThreadAsync(conversionResult.ConvertedCode ?? conversionResult.GetExceptionsAsString());
await _outputWindow.WriteToOutputWindowAsync(Environment.NewLine + "Conversion result copied to clipboard.");
await VisualStudioInteraction.ShowMessageBoxAsync(_serviceProvider, "Conversion result copied to clipboard.", $"Conversion result copied to clipboard. {conversionResult.GetExceptionsAsString()}", false);
}
} catch (OperationCanceledException) {
if (!_packageCancellation.CancelAll.IsCancellationRequested)
{
await _outputWindow.WriteToOutputWindowAsync(Environment.NewLine + "Previous conversion cancelled", forceShow : true);
}
}
}
private void FinalizeConversion(List <string> files, List <string> errors, string longestFilePath, List <ConversionResult> filesToOverwrite)
{
var options = GetOptions();
var conversionSummary = GetConversionSummary(files, errors);
_outputWindow.WriteToOutputWindow(conversionSummary);
_outputWindow.ForceShowOutputPane();
if (longestFilePath != null)
{
VisualStudioInteraction.OpenFile(new FileInfo(longestFilePath)).SelectAll();
}
var pathsToOverwrite = string.Join(Environment.NewLine + "* ",
filesToOverwrite.Select(f => PathRelativeToSolutionDir(f.SourcePathOrNull)));
var shouldOverwriteSolutionAndProjectFiles =
filesToOverwrite.Any() &&
(options.AlwaysOverwriteFiles || UserHasConfirmedOverwrite(files, errors, pathsToOverwrite));
if (shouldOverwriteSolutionAndProjectFiles)
{
var titleMessage = options.CreateBackups ? "Creating backups and overwriting files:" : "Overwriting files:" + "";
_outputWindow.WriteToOutputWindow(titleMessage);
foreach (var fileToOverwrite in filesToOverwrite)
{
if (options.CreateBackups)
{
File.Copy(fileToOverwrite.SourcePathOrNull, fileToOverwrite.SourcePathOrNull + ".bak", true);
}
File.WriteAllText(fileToOverwrite.TargetPathOrNull, fileToOverwrite.ConvertedCode);
var targetPathRelativeToSolutionDir = PathRelativeToSolutionDir(fileToOverwrite.TargetPathOrNull);
_outputWindow.WriteToOutputWindow(Environment.NewLine + $"* {targetPathRelativeToSolutionDir}");
}
}
}
private async Task ProjectItemMenuItemCallbackAsync(CancellationToken cancellationToken)
{
string itemPath = await VisualStudioInteraction.GetSingleSelectedItemPathOrDefaultAsync();
await ConvertDocumentAsync(itemPath, new Span(0, 0), cancellationToken);
}
async void ProjectItemMenuItemCallback(object sender, EventArgs e)
{
string itemPath = VisualStudioInteraction.GetSingleSelectedItemOrDefault()?.ItemPath;
await ConvertDocument(itemPath, new Span(0, 0));
}
private async Task ProjectItemMenuItemCallbackAsync(object sender, EventArgs e)
{
string itemPath = await VisualStudioInteraction.GetSingleSelectedItemPathOrDefaultAsync();
await ConvertDocumentAsync(itemPath, new Span(0, 0));
}
