update except usings

dotnetcore · Jul 9, 2024 · 9c465d9 · 9c465d9
1 parent 58d8b30
commit 9c465d9
Show file tree

Hide file tree

Showing 6 changed files with 206 additions and 69 deletions.
diff --git a/...tasha.CSharp/Extension/Natasha.CSharp.Extension.MethodCreator/NatashaSlimMethodBuilder.cs b/...tasha.CSharp/Extension/Natasha.CSharp.Extension.MethodCreator/NatashaSlimMethodBuilder.cs
@@ -7,7 +7,8 @@ public class NatashaSlimMethodBuilder
         public readonly AssemblyCSharpBuilder Builder;
         public readonly string Script;
         public readonly HashSet<string> Usings;
-        public object[]? PrivateObjects;
+        private HashSet<string>? _exceptUsings;
+        private object[]? _privateObjects;
         private Action<NatashaLoadContext>? _ctxConfig;
         private Action<AssemblyCSharpBuilder>? _builderConfig;
         public NatashaSlimMethodBuilder(string script)
@@ -18,10 +19,10 @@ public NatashaSlimMethodBuilder(string script)
         }
         public NatashaSlimMethodBuilder WithPrivateAccess(params object[] objs)
         {
-            PrivateObjects = objs;
+            _privateObjects = objs;
             return this;
         }
-        
+
         public NatashaSlimMethodBuilder ConfigBuilder(Action<AssemblyCSharpBuilder> config)
         {
             _builderConfig = config;
@@ -39,13 +40,23 @@ public NatashaSlimMethodBuilder WithSimpleBuilder()
             Builder.ConfigLoadContext(ctx => ctx.AddReferenceAndUsingCode<object>());
             return this;
         }
+        public NatashaSlimMethodBuilder WithSmartBuilder()
+        {
+            Builder.UseRandomLoadContext();
+            Builder.UseSmartMode();
+            return this;
+        }
 
         public NatashaSlimMethodBuilder WithUsings(params string[] usings)
         {
             Usings.UnionWith(usings);
             return this;
         }
-
+        public NatashaSlimMethodBuilder WithoutUsings(params string[] usings)
+        {
+            Builder.AppendExceptUsings(usings);
+            return this;
+        }
         public NatashaSlimMethodBuilder WithMetadata<T>()
         {
             Builder.ConfigLoadContext(ctx => ctx.AddReferenceAndUsingCode<T>());
@@ -95,10 +106,10 @@ public T ToDelegate<T>(string modifier = "") where T : Delegate
 
             }
             var fullScript = $"{usingCode} public static class {className} {{ public static {(modifier ?? string.Empty)} {returnTypeScript} Invoke({parameterScript}){{ {Script} }} }}";
-            if (PrivateObjects!=null)
+            if (_privateObjects != null)
             {
                 Builder.WithPrivateAccess();
-                Builder.Add(fullScript.ToAccessPrivateTree(PrivateObjects));
+                Builder.Add(fullScript.ToAccessPrivateTree(_privateObjects));
             }
             else
             {

diff --git a/src/Natasha.CSharp/Extension/Natasha.CSharp.Extension.MethodCreator/StringExtension.cs b/src/Natasha.CSharp/Extension/Natasha.CSharp.Extension.MethodCreator/StringExtension.cs
@@ -27,5 +27,19 @@ public static NatashaSlimMethodBuilder WithSlimMethodBuilder(this string script)
         builder.WithSimpleBuilder();
         return builder;
     }
+    public static NatashaSlimMethodBuilder WithSmartMethodBuilder(this string script)
+    {
+        var builder = new NatashaSlimMethodBuilder(script);
+        builder.WithSmartBuilder();
+        return builder;
+    }
+
+    public static NatashaSlimMethodBuilder WithoutUsings(this string script, params string[] usings)
+    {
+        var builder = new NatashaSlimMethodBuilder(script);
+        builder.WithSmartBuilder();
+        builder.WithoutUsings(usings);
+        return builder;
+    }
 }
 
diff --git a/src/Natasha.CSharp/Natasha.CSharp.Compiler/CompileUnit/AssemblyCSharpBuilder.Syntax.cs b/src/Natasha.CSharp/Natasha.CSharp.Compiler/CompileUnit/AssemblyCSharpBuilder.Syntax.cs
@@ -220,81 +220,163 @@ public AssemblyCSharpBuilder ClearScript()
     public AssemblyCSharpBuilder Add(string script, UsingLoadBehavior usingLoadBehavior, Encoding? encoding = null, string filePath = "")
     {
         var usingScript = string.Empty;
-        switch (usingLoadBehavior)
+        if (ExceptUsings.Count == 0)
         {
-            case UsingLoadBehavior.WithDefault:
-                usingScript = NatashaLoadContext.DefaultContext.UsingRecorder.ToString();
-                break;
-            case UsingLoadBehavior.WithCurrent:
-                if (Domain!.Name == NatashaLoadContext.DefaultName)
-                {
-                    usingScript = NatashaLoadContext.DefaultContext.UsingRecorder.ToString();
-                }
-                else
-                {
-                    usingScript = LoadContext!.UsingRecorder.ToString();
-                }
-                break;
-            case UsingLoadBehavior.WithAll:
-                if (Domain!.Name == NatashaLoadContext.DefaultName)
-                {
+            switch (usingLoadBehavior)
+            {
+                case UsingLoadBehavior.WithDefault:
                     usingScript = NatashaLoadContext.DefaultContext.UsingRecorder.ToString();
-                }
-                else
-                {
-                    StringBuilder usingBuilder = new();
-                    foreach (var item in LoadContext!.UsingRecorder._usings)
+                    break;
+                case UsingLoadBehavior.WithCurrent:
+                    if (Domain!.Name == NatashaLoadContext.DefaultName)
+                    {
+                        usingScript = NatashaLoadContext.DefaultContext.UsingRecorder.ToString();
+                    }
+                    else
+                    {
+                        usingScript = LoadContext!.UsingRecorder.ToString();
+                    }
+                    break;
+                case UsingLoadBehavior.WithAll:
+                    if (Domain!.Name == NatashaLoadContext.DefaultName)
+                    {
+                        usingScript = NatashaLoadContext.DefaultContext.UsingRecorder.ToString();
+                    }
+                    else
+                    {
+                        StringBuilder usingBuilder = new();
+                        foreach (var item in LoadContext!.UsingRecorder._usings)
+                        {
+                            if (!NatashaLoadContext.DefaultContext.UsingRecorder.HasUsing(item))
+                            {
+                                usingBuilder.AppendLine($"using {item};");
+                            }
+                        }
+                        usingScript = NatashaLoadContext.DefaultContext.UsingRecorder.ToString() + usingBuilder;
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+        else
+        {
+            switch (usingLoadBehavior)
+            {
+                case UsingLoadBehavior.WithDefault:
+                    usingScript = NatashaLoadContext.DefaultContext.UsingRecorder.WithExceptUsing(ExceptUsings).ToString();
+                    break;
+                case UsingLoadBehavior.WithCurrent:
+                    if (Domain!.Name == NatashaLoadContext.DefaultName)
                     {
-                        if (!NatashaLoadContext.DefaultContext.UsingRecorder.HasUsing(item))
+                        usingScript = NatashaLoadContext.DefaultContext.UsingRecorder.WithExceptUsing(ExceptUsings).ToString();
+                    }
+                    else
+                    {
+                        usingScript = LoadContext!.UsingRecorder.WithExceptUsing(ExceptUsings).ToString();
+                    }
+                    break;
+                case UsingLoadBehavior.WithAll:
+                    if (Domain!.Name == NatashaLoadContext.DefaultName)
+                    {
+                        usingScript = NatashaLoadContext.DefaultContext.UsingRecorder.WithExceptUsing(ExceptUsings).ToString();
+                    }
+                    else
+                    {
+                        var defaultUsings = NatashaLoadContext.DefaultContext.UsingRecorder.WithExceptUsing(ExceptUsings);
+                        var currentUsings = LoadContext!.UsingRecorder.WithExceptUsing(ExceptUsings)._usings;
+                        StringBuilder usingBuilder = new();
+                        foreach (var item in currentUsings)
                         {
-                            usingBuilder.AppendLine($"using {item};");
+                            if (!defaultUsings.HasUsing(item))
+                            {
+                                usingBuilder.AppendLine($"using {item};");
+                            }
                         }
+                        usingScript = defaultUsings.ToString() + usingBuilder;
                     }
-                    usingScript = NatashaLoadContext.DefaultContext.UsingRecorder.ToString() + usingBuilder;
-                }
-                break;
-            default:
-                break;
+                    break;
+                default:
+                    break;
+            }
         }
+
         return InternalAddScript(usingScript + script, encoding, filePath);
     }
 
     public AssemblyCSharpBuilder Add(CompilationUnitSyntax root, UsingLoadBehavior usingLoadBehavior, Encoding? encoding = null, string filePath = "")
     {
         IEnumerable<UsingDirectiveSyntax> usingNodes = [];
-        switch (usingLoadBehavior)
+        if (ExceptUsings.Count == 0)
         {
-            case UsingLoadBehavior.WithDefault:
-                usingNodes = NatashaLoadContext.DefaultContext.UsingRecorder.GetUsingNodes();
-                break;
-            case UsingLoadBehavior.WithCurrent:
-                if (Domain!.Name == NatashaLoadContext.DefaultName)
-                {
-                    usingNodes = NatashaLoadContext.DefaultContext.UsingRecorder.GetUsingNodes();
-                }
-                else
-                {
-                    usingNodes = LoadContext!.UsingRecorder.GetUsingNodes();
-                }
-                break;
-            case UsingLoadBehavior.WithAll:
-                if (Domain!.Name == NatashaLoadContext.DefaultName)
-                {
+            switch (usingLoadBehavior)
+            {
+                case UsingLoadBehavior.WithDefault:
                     usingNodes = NatashaLoadContext.DefaultContext.UsingRecorder.GetUsingNodes();
-                }
-                else
-                {
-                    HashSet<UsingDirectiveSyntax> tempUsings = [];
-                    StringBuilder usingBuilder = new();
-                    tempUsings.UnionWith(LoadContext!.UsingRecorder.GetUsingNodes());
-                    tempUsings.UnionWith(NatashaLoadContext.DefaultContext.UsingRecorder.GetUsingNodes());
-                    usingNodes = tempUsings;
-                }
-                break;
-            default:
-                break;
+                    break;
+                case UsingLoadBehavior.WithCurrent:
+                    if (Domain!.Name == NatashaLoadContext.DefaultName)
+                    {
+                        usingNodes = NatashaLoadContext.DefaultContext.UsingRecorder.GetUsingNodes();
+                    }
+                    else
+                    {
+                        usingNodes = LoadContext!.UsingRecorder.GetUsingNodes();
+                    }
+                    break;
+                case UsingLoadBehavior.WithAll:
+                    if (Domain!.Name == NatashaLoadContext.DefaultName)
+                    {
+                        usingNodes = NatashaLoadContext.DefaultContext.UsingRecorder.GetUsingNodes();
+                    }
+                    else
+                    {
+                        HashSet<UsingDirectiveSyntax> tempUsings = [];
+                        tempUsings.UnionWith(LoadContext!.UsingRecorder.GetUsingNodes());
+                        tempUsings.UnionWith(NatashaLoadContext.DefaultContext.UsingRecorder.GetUsingNodes());
+                        usingNodes = tempUsings;
+                    }
+                    break;
+                default:
+                    break;
+            }
+
         }
-
+        else
+        {
+            switch (usingLoadBehavior)
+            {
+                case UsingLoadBehavior.WithDefault:
+                    usingNodes = NatashaLoadContext.DefaultContext.UsingRecorder.WithExceptUsing(ExceptUsings).GetUsingNodes();
+                    break;
+                case UsingLoadBehavior.WithCurrent:
+                    if (Domain!.Name == NatashaLoadContext.DefaultName)
+                    {
+                        usingNodes = NatashaLoadContext.DefaultContext.UsingRecorder.WithExceptUsing(ExceptUsings).GetUsingNodes();
+                    }
+                    else
+                    {
+                        usingNodes = LoadContext!.UsingRecorder.WithExceptUsing(ExceptUsings).GetUsingNodes();
+                    }
+                    break;
+                case UsingLoadBehavior.WithAll:
+                    if (Domain!.Name == NatashaLoadContext.DefaultName)
+                    {
+                        usingNodes = NatashaLoadContext.DefaultContext.UsingRecorder.WithExceptUsing(ExceptUsings).GetUsingNodes();
+                    }
+                    else
+                    {
+                        HashSet<UsingDirectiveSyntax> tempUsings = [];
+                        tempUsings.UnionWith(LoadContext!.UsingRecorder.WithExceptUsing(ExceptUsings).GetUsingNodes());
+                        tempUsings.UnionWith(NatashaLoadContext.DefaultContext.UsingRecorder.WithExceptUsing(ExceptUsings).GetUsingNodes());
+                        usingNodes = tempUsings;
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+
         return InternalAddRootSyntax(root.AddUsings(usingNodes.ToArray()), encoding, filePath);
     }
 

diff --git a/src/Natasha.CSharp/Natasha.CSharp.Compiler/CompileUnit/AssemblyCSharpBuilder.Usings.cs b/src/Natasha.CSharp/Natasha.CSharp.Compiler/CompileUnit/AssemblyCSharpBuilder.Usings.cs
@@ -0,0 +1,29 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Natasha.CSharp.Compiler.Component;
+using Natasha.CSharp.Compiler.Component.Exception;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+/// <summary>
+/// 程序集编译构建器 - UsingCode
+/// </summary>
+public sealed partial class AssemblyCSharpBuilder
+{
+    public readonly HashSet<string> ExceptUsings = [];
+    public AssemblyCSharpBuilder AppendExceptUsings(params string[] usings)
+    {
+        if (usings!=null && usings.Length >0)
+        {
+            ExceptUsings.UnionWith(usings);
+        }
+        return this;
+    }
+
+}
+
+
+
diff --git a/src/Natasha.CSharp/Natasha.CSharp.Compiler/Component/Cache/NatashaUsingCache.cs b/src/Natasha.CSharp/Natasha.CSharp.Compiler/Component/Cache/NatashaUsingCache.cs
@@ -199,9 +199,10 @@ public IEnumerable<UsingDirectiveSyntax> GetUsingNodes()
         /// </summary>
         /// <param name="exceptUsings">从当前 using 中排除的 Using Code</param>
         /// <returns></returns>
-        public NatashaUsingCache WithExpectedUsing(HashSet<string> exceptUsings)
+        public NatashaUsingCache WithExceptUsing(HashSet<string> exceptUsings)
         {
             NatashaUsingCache newCache = new();
+            _usings.Except(exceptUsings);
             foreach (var item in _usings)
             {
                 if (!exceptUsings.Contains(item))
@@ -212,9 +213,9 @@ public NatashaUsingCache WithExpectedUsing(HashSet<string> exceptUsings)
             newCache._changed = true;
             return newCache;
         }
-        public NatashaUsingCache WithExpectedUsing(IEnumerable<string> exceptUsings)
+        public NatashaUsingCache WithExceptUsing(IEnumerable<string> exceptUsings)
         {
-            return WithExpectedUsing(new HashSet<string>(exceptUsings));
+            return WithExceptUsing(new HashSet<string>(exceptUsings));
         }
 
 

diff --git a/src/Natasha.CSharp/Natasha.CSharp.Compiler/Extension/NatashaStringExtension.cs b/src/Natasha.CSharp/Natasha.CSharp.Compiler/Extension/NatashaStringExtension.cs
@@ -45,7 +45,7 @@ public static string WithAllUsingCode(this string script, params string[] except
     /// <returns></returns>
     public static string WithAllUsingCode(this string script, IEnumerable<string> exceptUsings)
     {
-        var newCache = NatashaLoadContext.DefaultContext.UsingRecorder.WithExpectedUsing(exceptUsings);
+        var newCache = NatashaLoadContext.DefaultContext.UsingRecorder.WithExceptUsing(exceptUsings);
         return newCache.WrapperScript(script);
     }
 }