Roslyn 去除多余using

小鱼游戏开发2023-10-25 11:08

原因

当你添加新代码的时候VS会自动帮你添加对应的using，但是它只会帮你加不会帮你减

由于运行时并不能使用UnityEditor命名空间里面的东西。你就算加了也会在打包的时候给你报错，除非使用宏包裹起来

因为我们打包都是在打包机上操作的。一般情况下自己本地是不会打包也就不会知道在代码里面有多余using

经常出现打包到一半因为有多余的using导致的打包失败。然后再通知程序修改上传重新打包

解决方案

VS右键有个删除using和对其排序功能。但是说实话并没有什么卵用。每次保存前都右键执行一次比上面的流程更繁琐

基于以上流程过于繁琐。并且浪费时间。有了以下方案。

在git的pre-commit钩子加上cs后缀文件的using检测。如果有多余的using直接删除

编译动态链接库

编译需要设置是否开启

csharp 复制代码 
var options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, allowUnsafe: allowUnsafe);
var compilation = CSharpCompilation.Create(assemblyName, options: options);

添加动态库所引用的dll

csharp 复制代码 
portableExecutable = MetadataReference.CreateFromFile(dllPath);
compilation = compilation.AddReferences(portableExecutable);

添加动态库所包含的文件

csharp 复制代码 
var option = new CSharpParseOptions(LanguageVersion.CSharp8, DocumentationMode.Parse, SourceCodeKind.Regular, symbols);
var encoding = FileEncoding.GetType(path);
var content = File.ReadAllText(path, encoding);
var tree = CSharpSyntaxTree.ParseText(content, option);
compilation = compilation.AddSyntaxTrees(tree);

以上所有包含的信息在csproj里面都有记录。直接读取并设置即可

检测是否有多余using

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-messages/using-directive-errors

从文中可以看到 CS8019 是多余using警告。我们只需要根据这个移除对应的节点即可

csharp 复制代码 
CSharpCompilation compilation = CompilationHelper.GetCompilation(assemblyName);
var tree = CompilationHelper.GetSyntaxTree(assemblyName, path);
var root = tree.GetCompilationUnitRoot();
SemanticModel model = compilation.GetSemanticModel(tree);
var diagnostics = model.GetDiagnostics();
foreach (Diagnostic diagnostic in diagnostics)
{
    if (diagnostic.Id == "CS8019")
    {
        if (root.FindNode(diagnostic.Location.SourceSpan) is UsingDirectiveSyntax node)
        {
            // 需要过滤的节点
        }
    }
}

语法树修改

通过CSharpSyntaxRewriter对语法树节点的修改

我们需要的是重载 VisitUsingDirective 函数，只需要返回空即可删除对应节点

csharp 复制代码 
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using System.Collections.Generic;

namespace CSharpAnalyzer
{
    public class UsingSyntaxRewriter : CSharpSyntaxRewriter
    {
        private Dictionary<UsingDirectiveSyntax, bool> filters = new Dictionary<UsingDirectiveSyntax, bool>();

        public bool IsUpdate()
        {
            return filters.Count > 0;
        }

        public void Add(UsingDirectiveSyntax node)
        {
            if (node == null)
                return;

            filters[node] = true;
        }

        public override SyntaxNode VisitUsingDirective(UsingDirectiveSyntax node)
        {
            if (filters.ContainsKey(node))
                return null;

            return base.VisitUsingDirective(node);
        }
    }

}

完整代码

csharp 复制代码 
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Xml;

namespace CSharpAnalyzer
{
    public class CompilationHelper
    {
        static Dictionary<string,List<string>> pathDict = new Dictionary<string,List<string>>();
        static Dictionary<string, string[]> symbolDict = new Dictionary<string, string[]>();
        static Dictionary<string, CSharpCompilation> compilationDict = new Dictionary<string, CSharpCompilation>();

        public static void LoadCsproj(string csproj)
        {
            if (!File.Exists(csproj))
            {
                throw new Exception($"{csproj} not found");
            }

            var assemblyName = Path.GetFileNameWithoutExtension(csproj);
            if (compilationDict.ContainsKey(assemblyName))
                return;

            var dir = Path.GetDirectoryName(csproj);
            XmlDocument document = new XmlDocument();
            document.LoadXml(File.ReadAllText(csproj));
            var root = document.FirstChild;
            var project = root.NextSibling;

            bool allowUnsafe = false;
            string[] symbols = null;
            List<string> dllList = new List<string>();
            List<string> fileList = new List<string>();
            foreach (XmlNode node in project.ChildNodes)
            {
                switch (node.Name)
                {
                    case "PropertyGroup":
                        foreach (XmlNode n in node.ChildNodes)
                        {
                            if (n.Name == "DefineConstants")
                            {
                                var list = n.InnerText.Split(';').ToList();
                                list.Add("DEBUG");
                                list.Add("RELEASE");
                                list.Add("UNITY_EDITOR");
                                symbols = list.ToArray();
                            }
                            else if (n.Name == "AllowUnsafeBlocks")
                            {
                                bool.TryParse(n.InnerText, out allowUnsafe);
                            }
                        }
                        break;
                    case "ItemGroup":
                        foreach (XmlNode n in node.ChildNodes)
                        {
                            if (n.Name == "Compile")
                            {
                                fileList.Add(n.Attributes["Include"].Value);
                            }
                            else if (n.Name == "Reference")
                            {
                                dllList.Add(n.ChildNodes[0].InnerText);
                            }
                            else if (n.Name == "ProjectReference")
                            {
                                var name = Path.GetFileNameWithoutExtension(n.Attributes["Include"].Value);
                                var dll = Path.Combine(@"Library\ScriptAssemblies", name + ".dll");
                                dllList.Add(dll);
                            }
                        }
                        break;
                }
            }

            var options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, allowUnsafe: allowUnsafe);
            var compilation = CSharpCompilation.Create(assemblyName, options: options);

            foreach (var dll in dllList)
            {
                var dllPath = dll;
                if (!dll.Contains(":"))
                    dllPath = Path.Combine(dir, dll);
                var portableExecutable = PortableExecutableHelper.Get(dllPath);
                if (portableExecutable != null)
                {
                    compilation = compilation.AddReferences(portableExecutable);
                }
            }

            symbolDict[assemblyName] = symbols;

            List<string> files = new List<string>();    
            foreach (var file in fileList)
            {
                var path = Path.Combine(dir, file).Replace("\\", "/");
                var tree = GetSyntaxTree(assemblyName, path);
                compilation = compilation.AddSyntaxTrees(tree);
                files.Add(path);
            }

            pathDict[assemblyName] = files;
            compilationDict[assemblyName] = compilation;
        }

        public static CSharpCompilation GetCompilation(string assemblyName)
        {
            compilationDict.TryGetValue(assemblyName, out var compilation); 
            return compilation;
        }

        public static SyntaxTree GetSyntaxTree(string assemblyName, string path)
        {
            symbolDict.TryGetValue(assemblyName, out var symbol);
            return SyntaxTreeHelper.GetSyntaxTree(path, symbol);
        }

    }
}
csharp 复制代码 
using Microsoft.CodeAnalysis;
using System.Collections.Generic;
using System.IO;

namespace CSharpAnalyzer
{
    internal class PortableExecutableHelper
    {
        static Dictionary<string, PortableExecutableReference> dict = new Dictionary<string, PortableExecutableReference>();

        internal static PortableExecutableReference Get(string path)
        {
            if (dict.TryGetValue(path, out var dll))
            {
                return dll;
            }

            if (File.Exists(path))
            {
                dll = MetadataReference.CreateFromFile(path);
                if (dll != null)
                {
                    dict[path] = dll;
                    return dll;
                }
            }
            return null;
        }
    }
}
csharp 复制代码 
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using System.Collections.Generic;
using System.IO;

namespace CSharpAnalyzer
{
    public class SyntaxTreeHelper
    {
        static Dictionary<string, SyntaxTree> syntaxTreeDict = new Dictionary<string, SyntaxTree>();
        public static SyntaxTree GetSyntaxTree(string path, string[] symbols, bool reload = false)
        {
            SyntaxTree result = null;
            if (!reload)
            {
                if (syntaxTreeDict.TryGetValue(path, out result))
                {
                    return result;
                }
            }
            if (!File.Exists(path))
                return result;

            CSharpParseOptions option = null;
            if (symbols != null && symbols.Length > 0)
            {
                option = new CSharpParseOptions(LanguageVersion.CSharp8, DocumentationMode.Parse, SourceCodeKind.Regular, symbols);
            }
            var encoding = FileEncoding.GetType(path);
            var content = File.ReadAllText(path, encoding);
            result = CSharpSyntaxTree.ParseText(content, option);
            syntaxTreeDict[path] = result;

            return result;
        }
    }
}
csharp 复制代码 
// https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-messages/using-directive-errors
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using System;
using System.Collections.Generic;
using System.IO;

namespace CSharpAnalyzer
{
    public class UnnecessaryImportsAnalyzer
    {
        public static bool Run(string path, string assemblyName)
        {
            if (!File.Exists(path))
                return false;
            
            CSharpCompilation compilation = CompilationHelper.GetCompilation(assemblyName);
            if (compilation == null)
                return false;

            var tree = CompilationHelper.GetSyntaxTree(assemblyName, path.Replace(@"\","/"));
            var root = tree.GetCompilationUnitRoot();

            SemanticModel model = compilation.GetSemanticModel(tree);
            
            var diagnostics = model.GetDiagnostics();
            if (diagnostics.IsEmpty)
            {
                var encoding = FileEncoding.GetType(path);
                if (encoding != System.Text.Encoding.UTF8)
                {
                    var context = File.ReadAllText(path, encoding);
                    File.WriteAllText(path, context, System.Text.Encoding.UTF8);
                    return true;
                }
                return false;
            }

            {
                //var usingSyntaxRewriter = new UsingSyntaxRewriter();
                List<string> usings = new List<string>();
                foreach (Diagnostic diagnostic in diagnostics)
                {
                    if(diagnostic.Severity == DiagnosticSeverity.Error) 
                    {
                        Console.WriteLine($"{path} {diagnostic.GetMessage()}");
                        return false;
                    }
                    if (diagnostic.Id == "CS8019")
                    {
                        if (root.FindNode(diagnostic.Location.SourceSpan) is UsingDirectiveSyntax node)
                        {
                            //usingSyntaxRewriter.Add(node);
                            usings.Add(node.ToString());
                        }
                    }
                }

                if (usings.Count > 0)
                {
                    //var newRoot = usingSyntaxRewriter.Visit(root);
                    //var context = newRoot.GetText().ToString();
                    var context = root.GetText().ToString();
                    foreach (var _using in usings)
                    {
                        context = context.Replace(_using,string.Empty);
                    }
                    File.WriteAllText(path, context, System.Text.Encoding.UTF8);
                    return true;
                }
                else
                {
                    var encoding = FileEncoding.GetType(path);
                    if (encoding != System.Text.Encoding.UTF8)
                    {
                        var context = File.ReadAllText(path, encoding);
                        File.WriteAllText(path, context, System.Text.Encoding.UTF8);
                        return true;
                    }
                }
            }
            return false;
        }
    }

}
csharp 复制代码 
// https://blog.csdn.net/qq_43024228/article/details/122719840
using System;
using System.IO;
using System.Text;

namespace CSharpAnalyzer
{
    public class FileEncoding
    {
        /// <summary> 
        /// 给定文件的路径，读取文件的二进制数据，判断文件的编码类型 
        /// </summary> 
        /// <param name="FILE_NAME">文件路径</param> 
        /// <returns>文件的编码类型</returns> 
        public static System.Text.Encoding GetType(string FILE_NAME)
        {
            FileStream fs = new FileStream(FILE_NAME, FileMode.Open, FileAccess.Read);
            Encoding r = GetType(fs);
            fs.Close();
            return r;
        }

        /// <summary> 
        /// 通过给定的文件流，判断文件的编码类型 
        /// </summary> 
        /// <param name="fs">文件流</param> 
        /// <returns>文件的编码类型</returns> 
        public static System.Text.Encoding GetType(FileStream fs)
        {
            Encoding reVal = Encoding.Default;

            BinaryReader r = new BinaryReader(fs, System.Text.Encoding.Default);
            int i;
            int.TryParse(fs.Length.ToString(), out i);
            byte[] ss = r.ReadBytes(i);
            if (IsUTF8Bytes(ss) || (ss[0] == 0xEF && ss[1] == 0xBB && ss[2] == 0xBF))
            {
                reVal = Encoding.UTF8;
            }
            else if (ss[0] == 0xFE && ss[1] == 0xFF && ss[2] == 0x00)
            {
                reVal = Encoding.BigEndianUnicode;
            }
            else if (ss[0] == 0xFF && ss[1] == 0xFE && ss[2] == 0x41)
            {
                reVal = Encoding.Unicode;
            }
            r.Close();
            return reVal;

        }

        /// <summary> 
        /// 判断是否是不带 BOM 的 UTF8 格式 
        /// </summary> 
        /// <param name="data"></param> 
        /// <returns></returns> 
        private static bool IsUTF8Bytes(byte[] data)
        {
            int charByteCounter = 1; //计算当前正分析的字符应还有的字节数 
            byte curByte; //当前分析的字节. 
            for (int i = 0; i < data.Length; i++)
            {
                curByte = data[i];
                if (charByteCounter == 1)
                {
                    if (curByte >= 0x80)
                    {
                        //判断当前 
                        while (((curByte <<= 1) & 0x80) != 0)
                        {
                            charByteCounter++;
                        }
                        //标记位首位若为非0 则至少以2个1开始 如:110XXXXX...........1111110X 
                        if (charByteCounter == 1 || charByteCounter > 6)
                        {
                            return false;
                        }
                    }
                }
                else
                {
                    //若是UTF-8 此时第一位必须为1 
                    if ((curByte & 0xC0) != 0x80)
                    {
                        return false;
                    }
                    charByteCounter--;
                }
            }
            if (charByteCounter > 1)
            {
                throw new Exception("非预期的byte格式");
            }
            return true;
        }


    }
}
相关推荐
牙膏上的小苏打233310 小时前
Unity Surround开关后导致获取主显示器分辨率错误
unity·主屏幕
Unity大海12 小时前
诠视科技Unity SDK开发环境配置、项目设置、apk打包。
科技·unity·游戏引擎
浅陌sss18 小时前
Unity中 粒子系统使用整理（一）
unity·游戏引擎
维度攻城狮1 天前
实现在Unity3D中仿真汽车，而且还能使用ros2控制
python·unity·docker·汽车·ros2·rviz2
为你写首诗ge1 天前
【Unity网络编程知识】FTP学习
网络·unity
神码编程1 天前
【Unity】 HTFramework框架（六十四）SaveDataRuntime运行时保存组件参数、预制体
unity·编辑器·游戏引擎
菲fay1 天前
Unity 单例模式写法
unity·单例模式
火一线1 天前
【Framework-Client系列】UIGenerate介绍
游戏·unity
ZKY_241 天前
【工具】Json在线解析工具
unity·json
ZKY_242 天前
【Unity】处理文字显示不全的问题
unity·游戏引擎
热门推荐
01我决定放弃搞 Java 了02DeepSeek各版本说明与优缺点分析03如何在WPS和Word/Excel中直接使用DeepSeek功能04RAG 实践- Ollama+RagFlow 部署本地知识库05本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程06从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑07如何本地部署AI智能体平台，带你手搓一个AI Agent08苍穹外卖面试总结09DeepSeek RAGFlow构建本地知识库系统10【芯片封测学习专栏 -- D2D 和 C2C 之间的区别】