diff --git a/EasyCodeBuilder.Test/Csharp/ControlFlowTests.cs b/EasyCodeBuilder.Test/Csharp/ControlFlowTests.cs
index 899de2f..42023c8 100644
--- a/EasyCodeBuilder.Test/Csharp/ControlFlowTests.cs
+++ b/EasyCodeBuilder.Test/Csharp/ControlFlowTests.cs
@@ -1,282 +1,476 @@
-using Fengb3.EasyCodeBuilder.Csharp;
-using Xunit.Abstractions;
-
-namespace EasyCodeBuilder.Test.Csharp;
-
-public class ControlFlowTests(ITestOutputHelper output)
-{
-    private static string Norm(string text) => text.Replace("\r\n", "\n").Trim();
-
-    [Fact]
-    public void IfStatement()
-    {
-        var code = new MethodOption()
-            .WithKeyword("public")
-            .WithName("Check")
-            .WithReturnType("void")
-            .If(@if =>
-            {
-                @if.Condition = "x > 0";
-                @if.AppendLine("Console.WriteLine(x);");
-            })
-            .Build();
-
-        var expected = """
-            public void Check()
-            {
-              if (x > 0)
-              {
-                Console.WriteLine(x);
-              }
-            }
-            """;
-
-        Assert.Equal(Norm(expected), Norm(code));
-        output.WriteLine(code);
-    }
-
-    [Fact]
-    public void IfElseStatement()
-    {
-        var code = new MethodOption()
-            .WithKeyword("public")
-            .WithName("Check")
-            .WithReturnType("void")
-            .If(@if =>
-            {
-                @if.Condition = "x > 0";
-                @if.AppendLine("Console.WriteLine(\"positive\");");
-            })
-            .Else(@else =>
-            {
-                @else.AppendLine("Console.WriteLine(\"non-positive\");");
-            })
-            .Build();
-
-        var expected = """
-            public void Check()
-            {
-              if (x > 0)
-              {
-                Console.WriteLine("positive");
-              }
-              else
-              {
-                Console.WriteLine("non-positive");
-              }
-            }
-            """;
-
-        Assert.Equal(Norm(expected), Norm(code));
-        output.WriteLine(code);
-    }
-
-    [Fact]
-    public void IfElseIfElseStatement()
-    {
-        var code = new MethodOption()
-            .WithKeyword("public")
-            .WithName("Classify")
-            .WithReturnType("void")
-            .If(@if =>
-            {
-                @if.Condition = "x > 0";
-                @if.AppendLine("Console.WriteLine(\"positive\");");
-            })
-            .ElseIf(@elseIf =>
-            {
-                @elseIf.Condition = "x < 0";
-                @elseIf.AppendLine("Console.WriteLine(\"negative\");");
-            })
-            .Else(@else =>
-            {
-                @else.AppendLine("Console.WriteLine(\"zero\");");
-            })
-            .Build();
-
-        // Verify structural output contains all branches
-        Assert.Contains("if (x > 0)", code);
-        Assert.Contains("else if (x < 0)", code);
-        Assert.Contains("else", code);
-        Assert.Contains("Console.WriteLine(\"positive\");", code);
-        Assert.Contains("Console.WriteLine(\"negative\");", code);
-        Assert.Contains("Console.WriteLine(\"zero\");", code);
-        output.WriteLine(code);
-    }
-
-    [Fact]
-    public void NestedIfStatement()
-    {
-        var code = new MethodOption()
-            .WithKeyword("public")
-            .WithName("Check")
-            .WithReturnType("void")
-            .If(outer =>
-            {
-                outer.Condition = "x > 0";
-                outer.AddChild<IfOption, IfOption>(inner =>
-                {
-                    inner.Condition = "x > 100";
-                    inner.AppendLine("Console.WriteLine(\"large\");");
-                });
-            })
-            .Build();
-
-        Assert.Contains("if (x > 0)", code);
-        Assert.Contains("if (x > 100)", code);
-        Assert.Contains("Console.WriteLine(\"large\");", code);
-        // Verify nesting: inner if should be indented more
-        Assert.Contains("    if (x > 100)", code.Replace("\r\n", "\n"));
-        output.WriteLine(code);
-    }
-
-    [Fact]
-    public void WhileLoop()
-    {
-        var code = new MethodOption()
-            .WithKeyword("public")
-            .WithName("Loop")
-            .WithReturnType("void")
-            .While(@while =>
-            {
-                @while.Condition = "running";
-                @while.AppendLine("DoWork();");
-            })
-            .Build();
-
-        var expected = """
-            public void Loop()
-            {
-              while (running)
-              {
-                DoWork();
-              }
-            }
-            """;
-
-        Assert.Equal(Norm(expected), Norm(code));
-        output.WriteLine(code);
-    }
-
-    [Fact]
-    public void DoWhileLoop()
-    {
-        var code = new MethodOption()
-            .WithKeyword("public")
-            .WithName("Loop")
-            .WithReturnType("void")
-            .DoWhile(@do =>
-            {
-                @do.Condition = "running";
-                @do.AppendLine("DoWork();");
-            })
-            .Build();
-
-        var expected = """
-            public void Loop()
-            {
-              do
-              {
-                DoWork();
-              }while (running);
-            }
-            """;
-
-        Assert.Equal(Norm(expected), Norm(code));
-        output.WriteLine(code);
-    }
-
-    [Fact]
-    public void ForeachLoop()
-    {
-        var code = new MethodOption()
-            .WithKeyword("public")
-            .WithName("Iterate")
-            .WithReturnType("void")
-            .Foreach(@foreach =>
-            {
-                @foreach.WithVariable("var", "item", "items");
-                @foreach.AppendLine("Console.WriteLine(item);");
-            })
-            .Build();
-
-        var expected = """
-            public void Iterate()
-            {
-              foreach (var item in items)
-              {
-                Console.WriteLine(item);
-              }
-            }
-            """;
-
-        Assert.Equal(Norm(expected), Norm(code));
-        output.WriteLine(code);
-    }
-
-    [Fact]
-    public void ForLoopStandalone()
-    {
-        var code = new MethodOption()
-            .WithKeyword("private")
-            .WithName("Count")
-            .WithReturnType("void")
-            .For(@for =>
-            {
-                @for.WithInitializer("int i = 0");
-                @for.WithCondition("i < 5");
-                @for.WithIterator("i++");
-                @for.AppendLine("sum += i;");
-            })
-            .Build();
-
-        var expected = """
-            private void Count()
-            {
-              for (int i = 0; i < 5; i++)
-              {
-                sum += i;
-              }
-            }
-            """;
-
-        Assert.Equal(Norm(expected), Norm(code));
-        output.WriteLine(code);
-    }
-
-    [Fact]
-    public void SwitchWithExpressionBody()
-    {
-        var method = new MethodOption()
-            .WithKeyword("public")
-            .WithName("GetLabel")
-            .WithReturnType("string")
-            .WithParameters("int value");
-
-        method.Switch(@switch =>
-        {
-            @switch.Expression = "value";
-            @switch.Case(@case =>
-            {
-                @case.Value = "1";
-                @case.AppendLine("return \"One\";");
-            });
-            @switch.Case(@case =>
-            {
-                @case.Value = "2";
-                @case.AppendLine("return \"Two\";");
-            });
-            @switch.Default(@default => @default.AppendLine("return \"Unknown\";"));
-        });
-
-        var code = method.Build();
-
-        Assert.Contains("switch (value)", code);
-        Assert.Contains("case 1:", code);
-        Assert.Contains("case 2:", code);
-        Assert.Contains("default:", code);
-        Assert.Contains("return \"One\";", code);
-        Assert.Contains("return \"Unknown\";", code);
-        output.WriteLine(code);
-    }
-}
+using Fengb3.EasyCodeBuilder.Csharp;
+using Xunit.Abstractions;
+
+namespace EasyCodeBuilder.Test.Csharp;
+
+public class ControlFlowTests(ITestOutputHelper output)
+{
+    private static string Norm(string text) => text.Replace("\r\n", "\n").Trim();
+
+    [Fact]
+    public void IfStatement()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Check")
+            .WithReturnType("void")
+            .If(@if =>
+            {
+                @if.Condition = "x > 0";
+                @if.AppendLine("Console.WriteLine(x);");
+            })
+            .Build();
+
+        var expected = """
+            public void Check()
+            {
+              if (x > 0)
+              {
+                Console.WriteLine(x);
+              }
+            }
+            """;
+
+        Assert.Equal(Norm(expected), Norm(code));
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void IfElseStatement()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Check")
+            .WithReturnType("void")
+            .If(@if =>
+            {
+                @if.Condition = "x > 0";
+                @if.AppendLine("Console.WriteLine(\"positive\");");
+            })
+            .Else(@else =>
+            {
+                @else.AppendLine("Console.WriteLine(\"non-positive\");");
+            })
+            .Build();
+
+        var expected = """
+            public void Check()
+            {
+              if (x > 0)
+              {
+                Console.WriteLine("positive");
+              }
+              else
+              {
+                Console.WriteLine("non-positive");
+              }
+            }
+            """;
+
+        Assert.Equal(Norm(expected), Norm(code));
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void IfElseIfElseStatement()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Classify")
+            .WithReturnType("void")
+            .If(@if =>
+            {
+                @if.Condition = "x > 0";
+                @if.AppendLine("Console.WriteLine(\"positive\");");
+            })
+            .ElseIf(@elseIf =>
+            {
+                @elseIf.Condition = "x < 0";
+                @elseIf.AppendLine("Console.WriteLine(\"negative\");");
+            })
+            .Else(@else =>
+            {
+                @else.AppendLine("Console.WriteLine(\"zero\");");
+            })
+            .Build();
+
+        // Verify structural output contains all branches
+        Assert.Contains("if (x > 0)", code);
+        Assert.Contains("else if (x < 0)", code);
+        Assert.Contains("else", code);
+        Assert.Contains("Console.WriteLine(\"positive\");", code);
+        Assert.Contains("Console.WriteLine(\"negative\");", code);
+        Assert.Contains("Console.WriteLine(\"zero\");", code);
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void NestedIfStatement()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Check")
+            .WithReturnType("void")
+            .If(outer =>
+            {
+                outer.Condition = "x > 0";
+                outer.AddChild<IfOption, IfOption>(inner =>
+                {
+                    inner.Condition = "x > 100";
+                    inner.AppendLine("Console.WriteLine(\"large\");");
+                });
+            })
+            .Build();
+
+        Assert.Contains("if (x > 0)", code);
+        Assert.Contains("if (x > 100)", code);
+        Assert.Contains("Console.WriteLine(\"large\");", code);
+        // Verify nesting: inner if should be indented more
+        Assert.Contains("    if (x > 100)", code.Replace("\r\n", "\n"));
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void WhileLoop()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Loop")
+            .WithReturnType("void")
+            .While(@while =>
+            {
+                @while.Condition = "running";
+                @while.AppendLine("DoWork();");
+            })
+            .Build();
+
+        var expected = """
+            public void Loop()
+            {
+              while (running)
+              {
+                DoWork();
+              }
+            }
+            """;
+
+        Assert.Equal(Norm(expected), Norm(code));
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void DoWhileLoop()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Loop")
+            .WithReturnType("void")
+            .DoWhile(@do =>
+            {
+                @do.Condition = "running";
+                @do.AppendLine("DoWork();");
+            })
+            .Build();
+
+        var expected = """
+            public void Loop()
+            {
+              do
+              {
+                DoWork();
+              }while (running);
+            }
+            """;
+
+        Assert.Equal(Norm(expected), Norm(code));
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void ForeachLoop()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Iterate")
+            .WithReturnType("void")
+            .Foreach(@foreach =>
+            {
+                @foreach.WithVariable("var", "item", "items");
+                @foreach.AppendLine("Console.WriteLine(item);");
+            })
+            .Build();
+
+        var expected = """
+            public void Iterate()
+            {
+              foreach (var item in items)
+              {
+                Console.WriteLine(item);
+              }
+            }
+            """;
+
+        Assert.Equal(Norm(expected), Norm(code));
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void ForLoopStandalone()
+    {
+        var code = new MethodOption()
+            .WithKeyword("private")
+            .WithName("Count")
+            .WithReturnType("void")
+            .For(@for =>
+            {
+                @for.WithInitializer("int i = 0");
+                @for.WithCondition("i < 5");
+                @for.WithIterator("i++");
+                @for.AppendLine("sum += i;");
+            })
+            .Build();
+
+        var expected = """
+            private void Count()
+            {
+              for (int i = 0; i < 5; i++)
+              {
+                sum += i;
+              }
+            }
+            """;
+
+        Assert.Equal(Norm(expected), Norm(code));
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void SwitchWithExpressionBody()
+    {
+        var method = new MethodOption()
+            .WithKeyword("public")
+            .WithName("GetLabel")
+            .WithReturnType("string")
+            .WithParameters("int value");
+
+        method.Switch(@switch =>
+        {
+            @switch.Expression = "value";
+            @switch.Case(@case =>
+            {
+                @case.Value = "1";
+                @case.AppendLine("return \"One\";");
+            });
+            @switch.Case(@case =>
+            {
+                @case.Value = "2";
+                @case.AppendLine("return \"Two\";");
+            });
+            @switch.Default(@default => @default.AppendLine("return \"Unknown\";"));
+        });
+
+        var code = method.Build();
+
+        Assert.Contains("switch (value)", code);
+        Assert.Contains("case 1:", code);
+        Assert.Contains("case 2:", code);
+        Assert.Contains("default:", code);
+        Assert.Contains("return \"One\";", code);
+        Assert.Contains("return \"Unknown\";", code);
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void ForContainingSwitch_Issue11()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Parse")
+            .WithReturnType("void")
+            .WithParameters("string[] args")
+            .For(f =>
+            {
+                f.WithInitializer("int i = 0")
+                 .WithCondition("i < args.Length")
+                 .WithIterator("i++");
+
+                f.Switch(s =>
+                {
+                    s.WithExpression("args[i]");
+                    s.Case(c =>
+                    {
+                        c.Value = "\"--x\"";
+                        c.AppendLine("x = int.Parse(args[++i]);");
+                        c.AppendLine("break;");
+                    });
+                    s.Default(d =>
+                    {
+                        d.AppendLine("break;");
+                    });
+                });
+            })
+            .Build();
+
+        var expected = """
+            public void Parse(string[] args)
+            {
+              for (int i = 0; i < args.Length; i++)
+              {
+                switch (args[i])
+                {
+                  case "--x":
+                  {
+                    x = int.Parse(args[++i]);
+                    break;
+                  }
+                  default:
+                  {
+                    break;
+                  }
+                }
+              }
+            }
+            """;
+
+        Assert.Equal(Norm(expected), Norm(code));
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void DeepNesting_ForSwitchCaseIf()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Deep")
+            .WithReturnType("void")
+            .For(f =>
+            {
+                f.WithInitializer("int i = 0")
+                 .WithCondition("i < items.Count")
+                 .WithIterator("i++");
+
+                f.Switch(s =>
+                {
+                    s.WithExpression("items[i].Type");
+                    s.Case(c =>
+                    {
+                        c.Value = "\"A\"";
+                        c.If(@if =>
+                        {
+                            @if.Condition = "items[i].Value > 0";
+                            @if.AppendLine("Process(items[i]);");
+                        });
+                    });
+                });
+            })
+            .Build();
+
+        Assert.Contains("for (int i = 0; i < items.Count; i++)", code);
+        Assert.Contains("switch (items[i].Type)", code);
+        Assert.Contains("case \"A\":", code);
+        Assert.Contains("if (items[i].Value > 0)", code);
+        Assert.Contains("Process(items[i]);", code);
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void WhileContainingFor()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Retry")
+            .WithReturnType("void")
+            .While(w =>
+            {
+                w.Condition = "retry";
+                w.For(f =>
+                {
+                    f.WithInitializer("int i = 0")
+                     .WithCondition("i < retries")
+                     .WithIterator("i++");
+                    f.AppendLine("Attempt(i);");
+                });
+            })
+            .Build();
+
+        Assert.Contains("while (retry)", code);
+        Assert.Contains("for (int i = 0; i < retries; i++)", code);
+        Assert.Contains("Attempt(i);", code);
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void TryInsideFor()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("SafeIterate")
+            .WithReturnType("void")
+            .WithParameters("List<string> items")
+            .For(f =>
+            {
+                f.WithInitializer("int i = 0")
+                 .WithCondition("i < items.Count")
+                 .WithIterator("i++");
+
+                f.Try(t =>
+                {
+                    t.AppendLine("Process(items[i]);");
+                    t.Catch(c =>
+                    {
+                        c.WithExceptionType("Exception")
+                         .WithVariableName("ex");
+                        c.AppendLine("Log(ex);");
+                    });
+                });
+            })
+            .Build();
+
+        Assert.Contains("for (int i = 0; i < items.Count; i++)", code);
+        Assert.Contains("try", code);
+        Assert.Contains("Process(items[i]);", code);
+        Assert.Contains("catch (Exception ex)", code);
+        Assert.Contains("Log(ex);", code);
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void IfElseIfElseInsideFor()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Classify")
+            .WithReturnType("void")
+            .For(f =>
+            {
+                f.WithInitializer("int i = 0")
+                 .WithCondition("i < values.Length")
+                 .WithIterator("i++");
+
+                f.If(@if =>
+                {
+                    @if.Condition = "values[i] > 0";
+                    @if.AppendLine("Console.WriteLine(\"positive\");");
+                })
+                .ElseIf(elseIf =>
+                {
+                    elseIf.Condition = "values[i] < 0";
+                    elseIf.AppendLine("Console.WriteLine(\"negative\");");
+                })
+                .Else(@else =>
+                {
+                    @else.AppendLine("Console.WriteLine(\"zero\");");
+                });
+            })
+            .Build();
+
+        Assert.Contains("for (int i = 0; i < values.Length; i++)", code);
+        Assert.Contains("if (values[i] > 0)", code);
+        Assert.Contains("else if (values[i] < 0)", code);
+        Assert.Contains("else", code);
+        Assert.Contains("Console.WriteLine(\"positive\");", code);
+        Assert.Contains("Console.WriteLine(\"negative\");", code);
+        Assert.Contains("Console.WriteLine(\"zero\");", code);
+        output.WriteLine(code);
+    }
+}
diff --git a/EasyCodeBuilder/Csharp/Code.cs b/EasyCodeBuilder/Csharp/Code.cs
index e432128..dfa1741 100644
--- a/EasyCodeBuilder/Csharp/Code.cs
+++ b/EasyCodeBuilder/Csharp/Code.cs
@@ -1,203 +1,284 @@
-using System;
-using System.Linq;
-
-namespace Fengb3.EasyCodeBuilder.Csharp;
-
-/// <summary>
-/// Provides the entry point and extension methods for building C# code using a configuration-based API.
-/// </summary>
-public static partial class Code
-{
-    /// <summary>
-    /// Creates a new root <see cref="CodeOption"/> to begin building code.
-    /// </summary>
-    /// <returns>A new <see cref="CodeOption"/> instance.</returns>
-    public static CodeOption Create()
-    {
-        return new CodeOption();
-    }
-
-    /// <summary>
-    /// Backward-compatible API: add using directives by namespace names.
-    /// </summary>
-    public static CodeOption Using(this CodeOption option, params string[] usings)
-    {
-        foreach (var u in usings)
-        {
-            option.AddChild<CodeOption, UsingOption>(uo => { uo.Name = u; });
-        }
-
-        return option;
-    }
-
-    /// <summary>
-    /// Add a single using directive with full configuration.
-    /// </summary>
-    public static CodeOption Using(this CodeOption option, Action<UsingOption> configure)
-        => option.AddChild(configure);
-
-    /// <summary>
-    /// using static {typeOrNamespace};
-    /// </summary>
-    public static CodeOption UsingStatic(this CodeOption option, string typeOrNamespace)
-        => option.AddChild<CodeOption, UsingOption>(uo =>
-        {
-            uo.Name = typeOrNamespace;
-            uo.IsStatic = true;
-        });
-
-    /// <summary>
-    /// using {alias} = {typeOrNamespace};
-    /// </summary>
-    public static CodeOption UsingAlias(this CodeOption option, string alias, string typeOrNamespace)
-        => option.AddChild<CodeOption, UsingOption>(uo =>
-        {
-            uo.Alias = alias;
-            uo.Name = typeOrNamespace;
-        });
-
-    /// <summary>
-    /// global using {typeOrNamespace};
-    /// </summary>
-    public static CodeOption GlobalUsing(this CodeOption option, string typeOrNamespace)
-        => option.AddChild<CodeOption, UsingOption>(uo =>
-        {
-            uo.Keywords.Add("global");
-            uo.Name = typeOrNamespace;
-        });
-
-    /// <summary>
-    /// global using static {typeOrNamespace};
-    /// </summary>
-    public static CodeOption GlobalUsingStatic(this CodeOption option, string typeOrNamespace)
-        => option.AddChild<CodeOption, UsingOption>(uo =>
-        {
-            uo.Keywords.Add("global");
-            uo.Name = typeOrNamespace;
-            uo.IsStatic = true;
-        });
-
-    /// <summary>
-    /// Creates a new child option, configures it via <paramref name="configureChild"/>,
-    /// and attaches its <see cref="CodeOption.Build"/> to the parent's <see cref="CodeOption.OnChildren"/>.
-    /// </summary>
-    /// <param name="parent">The parent code option.</param>
-    /// <param name="configureChild">Action to configure the new child.</param>
-    /// <typeparam name="TParent">Parent option type.</typeparam>
-    /// <typeparam name="TChild">Child option type.</typeparam>
-    /// <returns>The parent option, for fluent chaining.</returns>
-    public static TParent AddChild<TParent, TChild>(this TParent parent, Action<TChild> configureChild)
-        where TParent : CodeOption where TChild : CodeOption, new()
-    {
-        var child = new TChild();
-        configureChild?.Invoke(child);
-        return parent.AddChild(child);
-    }
-
-    /// <summary>
-    /// Attaches an existing child option's <see cref="CodeOption.Build"/> to the parent's <see cref="CodeOption.OnChildren"/>.
-    /// </summary>
-    /// <param name="parent">The parent code option.</param>
-    /// <param name="child">The child code option to attach.</param>
-    /// <typeparam name="TParent">Parent option type.</typeparam>
-    /// <typeparam name="TChild">Child option type.</typeparam>
-    /// <returns>The parent option, for fluent chaining.</returns>
-    public static TParent AddChild<TParent, TChild>(this TParent parent, TChild child)
-        where TParent : CodeOption where TChild : CodeOption
-    {
-        parent.OnChildren += child.Build;
-        return parent;
-    }
-
-    /// <summary>
-    /// 添加一行或多行代码
-    /// </summary>
-    /// <param name="option">代码选项</param>
-    /// <param name="lines">代码行</param>
-    /// <returns>代码选项</returns>
-    public static CodeOption AppendLine(this CodeOption option, params string[] lines)
-    {
-        option.OnChildren += cb => cb.AppendLines(lines);
-        return option;
-    }
-
-    /// <summary>
-    /// Add a namespace to the code.
-    /// </summary>
-    /// <param name="option">The root code option.</param>
-    /// <param name="configure">Action to configure the namespace.</param>
-    /// <returns>The root code option, for fluent chaining.</returns>
-    public static CodeOption Namespace(this CodeOption option, Action<NamespaceOption> configure)
-        => option.AddChild(configure);
-
-    /// <summary>
-    /// Add a class to the code.
-    /// </summary>
-    /// <param name="option">The root code option.</param>
-    /// <param name="configure">Action to configure the class.</param>
-    /// <returns>The root code option, for fluent chaining.</returns>
-    public static CodeOption Class(this CodeOption option, Action<TypeOption> configure)
-        => option.AddChild(configure);
-
-
-    /// <summary>
-    /// add attribute to an element
-    /// </summary>
-    /// <param name="option">The code option to add attributes to.</param>
-    /// <param name="attributes">Attribute declarations (e.g. "Serializable", "Obsolete").</param>
-    /// <typeparam name="T">The option type.</typeparam>
-    /// <returns>The option, for fluent chaining.</returns>
-    public static T WithAttributes<T>(this T option, params string[] attributes) where T : CodeOption
-    {
-        option.BeforeChildren += cb => cb.AppendLines(attributes.Select(attr => $"[{attr}]"));
-        return option;
-    }
-    
-    /// <summary>
-    /// add XML doc to an element
-    /// </summary>
-    /// <param name="option">The code option to add XML documentation to.</param>
-    /// <param name="configure">Action to configure the XML doc.</param>
-    /// <typeparam name="T">The option type.</typeparam>
-    /// <returns>The option, for fluent chaining.</returns>
-    public static T WithXmlDoc<T>(this T option, Action<XmlDocOption> configure) where T : CodeOption
-    {
-        option.BeforeChildren += cb =>
-        {
-            var xmlDocOption = new XmlDocOption();
-            configure(xmlDocOption);
-            xmlDocOption.Build(cb);
-            return cb;
-        };
-        return option;
-    }
-
-
-    /// <summary>
-    /// Add single or multiple lines to a code block
-    /// </summary>
-    /// <param name="option">The code option.</param>
-    /// <param name="lines">The lines of code to add.</param>
-    /// <typeparam name="T">The option type.</typeparam>
-    /// <returns>The option, for fluent chaining.</returns>
-    public static T AppendLines<T>(this T option, params string[] lines) where T : CodeOption
-    {
-        foreach (var line in lines)
-            option.AppendLine(line);
-
-        return option;
-    }
-
-    /// <summary>
-    /// 构建代码
-    /// </summary>
-    /// <param name="root">根选项</param>
-    /// <param name="cb">代码构建器</param>
-    /// <returns>生成的代码字符串</returns>
-    public static string Build(this CodeOption root, CodeBuilder? cb = null)
-    {
-        cb ??= new CodeBuilder(' ', 2, "\n{", "}", 1024);
-        root.Build(cb);
-        return cb.ToString();
-    }
+using System;
+using System.Linq;
+
+namespace Fengb3.EasyCodeBuilder.Csharp;
+
+/// <summary>
+/// Provides the entry point and extension methods for building C# code using a configuration-based API.
+/// </summary>
+public static partial class Code
+{
+    /// <summary>
+    /// Creates a new root <see cref="CodeOption"/> to begin building code.
+    /// </summary>
+    /// <returns>A new <see cref="CodeOption"/> instance.</returns>
+    public static CodeOption Create()
+    {
+        return new CodeOption();
+    }
+
+    /// <summary>
+    /// Backward-compatible API: add using directives by namespace names.
+    /// </summary>
+    public static CodeOption Using(this CodeOption option, params string[] usings)
+    {
+        foreach (var u in usings)
+        {
+            option.AddChild<CodeOption, UsingOption>(uo => { uo.Name = u; });
+        }
+
+        return option;
+    }
+
+    /// <summary>
+    /// Add a single using directive with full configuration.
+    /// </summary>
+    public static CodeOption Using(this CodeOption option, Action<UsingOption> configure)
+        => option.AddChild(configure);
+
+    /// <summary>
+    /// using static {typeOrNamespace};
+    /// </summary>
+    public static CodeOption UsingStatic(this CodeOption option, string typeOrNamespace)
+        => option.AddChild<CodeOption, UsingOption>(uo =>
+        {
+            uo.Name = typeOrNamespace;
+            uo.IsStatic = true;
+        });
+
+    /// <summary>
+    /// using {alias} = {typeOrNamespace};
+    /// </summary>
+    public static CodeOption UsingAlias(this CodeOption option, string alias, string typeOrNamespace)
+        => option.AddChild<CodeOption, UsingOption>(uo =>
+        {
+            uo.Alias = alias;
+            uo.Name = typeOrNamespace;
+        });
+
+    /// <summary>
+    /// global using {typeOrNamespace};
+    /// </summary>
+    public static CodeOption GlobalUsing(this CodeOption option, string typeOrNamespace)
+        => option.AddChild<CodeOption, UsingOption>(uo =>
+        {
+            uo.Keywords.Add("global");
+            uo.Name = typeOrNamespace;
+        });
+
+    /// <summary>
+    /// global using static {typeOrNamespace};
+    /// </summary>
+    public static CodeOption GlobalUsingStatic(this CodeOption option, string typeOrNamespace)
+        => option.AddChild<CodeOption, UsingOption>(uo =>
+        {
+            uo.Keywords.Add("global");
+            uo.Name = typeOrNamespace;
+            uo.IsStatic = true;
+        });
+
+    /// <summary>
+    /// Creates a new child option, configures it via <paramref name="configureChild"/>,
+    /// and attaches its <see cref="CodeOption.Build"/> to the parent's <see cref="CodeOption.OnChildren"/>.
+    /// </summary>
+    /// <param name="parent">The parent code option.</param>
+    /// <param name="configureChild">Action to configure the new child.</param>
+    /// <typeparam name="TParent">Parent option type.</typeparam>
+    /// <typeparam name="TChild">Child option type.</typeparam>
+    /// <returns>The parent option, for fluent chaining.</returns>
+    public static TParent AddChild<TParent, TChild>(this TParent parent, Action<TChild> configureChild)
+        where TParent : CodeOption where TChild : CodeOption, new()
+    {
+        var child = new TChild();
+        configureChild?.Invoke(child);
+        return parent.AddChild(child);
+    }
+
+    /// <summary>
+    /// Attaches an existing child option's <see cref="CodeOption.Build"/> to the parent's <see cref="CodeOption.OnChildren"/>.
+    /// </summary>
+    /// <param name="parent">The parent code option.</param>
+    /// <param name="child">The child code option to attach.</param>
+    /// <typeparam name="TParent">Parent option type.</typeparam>
+    /// <typeparam name="TChild">Child option type.</typeparam>
+    /// <returns>The parent option, for fluent chaining.</returns>
+    public static TParent AddChild<TParent, TChild>(this TParent parent, TChild child)
+        where TParent : CodeOption where TChild : CodeOption
+    {
+        parent.OnChildren += child.Build;
+        return parent;
+    }
+
+    /// <summary>
+    /// 添加一行或多行代码
+    /// </summary>
+    /// <param name="option">代码选项</param>
+    /// <param name="lines">代码行</param>
+    /// <returns>代码选项</returns>
+    public static CodeOption AppendLine(this CodeOption option, params string[] lines)
+    {
+        option.OnChildren += cb => cb.AppendLines(lines);
+        return option;
+    }
+
+    /// <summary>
+    /// Add an if statement to the code block.
+    /// </summary>
+    /// <param name="option">The code option.</param>
+    /// <param name="configure">Action to configure the if statement.</param>
+    /// <returns>The code option, for fluent chaining.</returns>
+    public static CodeOption If(this CodeOption option, Action<IfOption> configure)
+        => option.AddChild(configure);
+
+    /// <summary>
+    /// Add an else statement to the code block.
+    /// </summary>
+    /// <param name="option">The code option.</param>
+    /// <param name="configure">Action to configure the else statement.</param>
+    /// <returns>The code option, for fluent chaining.</returns>
+    public static CodeOption Else(this CodeOption option, Action<ElseOption> configure)
+        => option.AddChild(configure);
+
+    /// <summary>
+    /// Add an else-if statement to the code block.
+    /// </summary>
+    /// <param name="option">The code option.</param>
+    /// <param name="configure">Action to configure the else-if statement.</param>
+    /// <returns>The code option, for fluent chaining.</returns>
+    public static CodeOption ElseIf(this CodeOption option, Action<ElseIfOption> configure)
+        => option.AddChild(configure);
+
+    /// <summary>
+    /// Add a for loop to the code block.
+    /// </summary>
+    /// <param name="option">The code option.</param>
+    /// <param name="configure">Action to configure the for loop.</param>
+    /// <returns>The code option, for fluent chaining.</returns>
+    public static CodeOption For(this CodeOption option, Action<ForOption> configure)
+        => option.AddChild(configure);
+
+    /// <summary>
+    /// Add a while loop to the code block.
+    /// </summary>
+    /// <param name="option">The code option.</param>
+    /// <param name="configure">Action to configure the while loop.</param>
+    /// <returns>The code option, for fluent chaining.</returns>
+    public static CodeOption While(this CodeOption option, Action<WhileOption> configure)
+        => option.AddChild(configure);
+
+    /// <summary>
+    /// Add a do-while loop to the code block.
+    /// </summary>
+    /// <param name="option">The code option.</param>
+    /// <param name="configure">Action to configure the do-while loop.</param>
+    /// <returns>The code option, for fluent chaining.</returns>
+    public static CodeOption DoWhile(this CodeOption option, Action<DoWhileOption> configure)
+        => option.AddChild(configure);
+
+    /// <summary>
+    /// Add a foreach loop to the code block.
+    /// </summary>
+    /// <param name="option">The code option.</param>
+    /// <param name="configure">Action to configure the foreach loop.</param>
+    /// <returns>The code option, for fluent chaining.</returns>
+    public static CodeOption Foreach(this CodeOption option, Action<ForeachOption> configure)
+        => option.AddChild(configure);
+
+    /// <summary>
+    /// Add a switch statement to the code block.
+    /// </summary>
+    /// <param name="option">The code option.</param>
+    /// <param name="configure">Action to configure the switch statement.</param>
+    /// <returns>The code option, for fluent chaining.</returns>
+    public static CodeOption Switch(this CodeOption option, Action<SwitchOption> configure)
+        => option.AddChild(configure);
+
+    /// <summary>
+    /// Add a try-catch-finally statement to the code block.
+    /// </summary>
+    /// <param name="option">The code option.</param>
+    /// <param name="configure">Action to configure the try statement.</param>
+    /// <returns>The code option, for fluent chaining.</returns>
+    public static CodeOption Try(this CodeOption option, Action<TryOption> configure)
+        => option.AddChild(configure);
+
+    /// <summary>
+    /// Add a namespace to the code.
+    /// </summary>
+    /// <param name="option">The root code option.</param>
+    /// <param name="configure">Action to configure the namespace.</param>
+    /// <returns>The root code option, for fluent chaining.</returns>
+    public static CodeOption Namespace(this CodeOption option, Action<NamespaceOption> configure)
+        => option.AddChild(configure);
+
+    /// <summary>
+    /// Add a class to the code.
+    /// </summary>
+    /// <param name="option">The root code option.</param>
+    /// <param name="configure">Action to configure the class.</param>
+    /// <returns>The root code option, for fluent chaining.</returns>
+    public static CodeOption Class(this CodeOption option, Action<TypeOption> configure)
+        => option.AddChild(configure);
+
+
+    /// <summary>
+    /// add attribute to an element
+    /// </summary>
+    /// <param name="option">The code option to add attributes to.</param>
+    /// <param name="attributes">Attribute declarations (e.g. "Serializable", "Obsolete").</param>
+    /// <typeparam name="T">The option type.</typeparam>
+    /// <returns>The option, for fluent chaining.</returns>
+    public static T WithAttributes<T>(this T option, params string[] attributes) where T : CodeOption
+    {
+        option.BeforeChildren += cb => cb.AppendLines(attributes.Select(attr => $"[{attr}]"));
+        return option;
+    }
+    
+    /// <summary>
+    /// add XML doc to an element
+    /// </summary>
+    /// <param name="option">The code option to add XML documentation to.</param>
+    /// <param name="configure">Action to configure the XML doc.</param>
+    /// <typeparam name="T">The option type.</typeparam>
+    /// <returns>The option, for fluent chaining.</returns>
+    public static T WithXmlDoc<T>(this T option, Action<XmlDocOption> configure) where T : CodeOption
+    {
+        option.BeforeChildren += cb =>
+        {
+            var xmlDocOption = new XmlDocOption();
+            configure(xmlDocOption);
+            xmlDocOption.Build(cb);
+            return cb;
+        };
+        return option;
+    }
+
+
+    /// <summary>
+    /// Add single or multiple lines to a code block
+    /// </summary>
+    /// <param name="option">The code option.</param>
+    /// <param name="lines">The lines of code to add.</param>
+    /// <typeparam name="T">The option type.</typeparam>
+    /// <returns>The option, for fluent chaining.</returns>
+    public static T AppendLines<T>(this T option, params string[] lines) where T : CodeOption
+    {
+        foreach (var line in lines)
+            option.AppendLine(line);
+
+        return option;
+    }
+
+    /// <summary>
+    /// 构建代码
+    /// </summary>
+    /// <param name="root">根选项</param>
+    /// <param name="cb">代码构建器</param>
+    /// <returns>生成的代码字符串</returns>
+    public static string Build(this CodeOption root, CodeBuilder? cb = null)
+    {
+        cb ??= new CodeBuilder(' ', 2, "\n{", "}", 1024);
+        root.Build(cb);
+        return cb.ToString();
+    }
 }
\ No newline at end of file