src/VisualStudio/VisualStudioDiagnosticsToolWindow/Panels/TelemetryPanel.xaml.cs - main - githubmirror/roslyn

src/VisualStudio/VisualStudioDiagnosticsToolWindow/Panels/TelemetryPanel.xaml.cs
153 строки4 KB
Tomáš Matoušek
Add Enum static extensions (#79546)
23 июл 2025, 21:30
23 июл 2025, 21:3050d2e33
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

#nullable disable

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using Microsoft.CodeAnalysis.CodeActions;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.Shared.Extensions;

namespace Roslyn.VisualStudio.DiagnosticsWindow;

/// <summary>
/// Interaction logic for TelemetryPanel.xaml
/// </summary>
public partial class TelemetryPanel : UserControl
{
    public TelemetryPanel()
    {
        InitializeComponent();
    }

    private void OnDump(object sender, RoutedEventArgs e)
    {
        _ = OnDumpImplAsync();

        async Task OnDumpImplAsync()
        {
            using (Disable(DumpButton))
            using (Disable(CopyButton))
            {
                GenerationProgresBar.IsIndeterminate = true;

                var text = await Task.Run(GetTelemetryString).ConfigureAwait(true);

                this.Result.Text = text;

                GenerationProgresBar.IsIndeterminate = false;
            }
        }
    }

    private void OnCopy(object sender, RoutedEventArgs e)
    {
        Clipboard.SetText(this.Result.Text);
    }

    private static string GetTelemetryString()
    {
        var sb = new StringBuilder();
        var seenType = new HashSet<Type>();

        foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
        {
            var result = ScanAssembly(assembly);
            if (result.Length > 0)
            {
                sb.AppendLine($"Searching: {assembly.FullName}");
                sb.AppendLine(result);
            }
        }

        return sb.ToString();

        string ScanAssembly(Assembly assembly)
        {
            var typeDiscovered = new StringBuilder();
            try
            {
                foreach (var module in assembly.GetModules())
                {
                    foreach (var type in module.GetTypes())
                    {
                        ScanType(type, typeDiscovered);
                    }
                }
            }
            catch
            {
                // ignore
            }

            return typeDiscovered.ToString();
        }

        void ScanType(Type type, StringBuilder typeDiscovered)
        {
            type = type.GetTypeForTelemetry();

            if (!seenType.Add(type))
            {
                return;
            }

            RecordIfCodeAction(type, typeDiscovered);

            foreach (var nestedTypeInfo in type.GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic))
            {
                ScanType(nestedTypeInfo, typeDiscovered);
            }
        }

        void RecordIfCodeAction(Type type, StringBuilder typeDiscovered)
        {
            if (!IsCodeAction(type))
            {
                return;
            }

            var telemetryId = type.GetTelemetryId();

            typeDiscovered.AppendLine($"Found: {type.FullName}: {telemetryId.ToString()}");
        }

        bool IsCodeAction(Type type)
        {
            if (type == null)
            {
                return false;
            }

            var codeActionType = typeof(CodeAction);
            return codeActionType.IsAssignableFrom(type);
        }
    }

    private static IDisposable Disable(UIElement control)
    {
        control.IsEnabled = false;
        return new RAII(() => control.IsEnabled = true);
    }

    private sealed class RAII : IDisposable
    {
        private readonly Action _action;

        public RAII(Action disposeAction)
        {
            _action = disposeAction;
        }
        public void Dispose()
        {
            _action?.Invoke();
        }
    }
}