diff --git a/EasyCodeBuilder.Test/Csharp/TryCatchFinallyTests.cs b/EasyCodeBuilder.Test/Csharp/TryCatchFinallyTests.cs
new file mode 100644
index 0000000..dd25a1e
--- /dev/null
+++ b/EasyCodeBuilder.Test/Csharp/TryCatchFinallyTests.cs
@@ -0,0 +1,288 @@
+using System;
+using Fengb3.EasyCodeBuilder;
+using Fengb3.EasyCodeBuilder.Csharp;
+using Xunit.Abstractions;
+
+namespace EasyCodeBuilder.Test.Csharp;
+
+public class TryCatchFinallyTests(ITestOutputHelper output)
+{
+    private static string Norm(string text) => text.Replace("\r\n", "\n").Trim();
+
+    [Fact]
+    public void TryWithoutCatchOrFinallyThrows()
+    {
+        var tryOption = new TryOption();
+        tryOption.AppendLine("DoWork();");
+
+        Assert.Throws<InvalidOperationException>(() =>
+        {
+            var cb = new CodeBuilder(' ', 2, "\n{", "}", 1024);
+            tryOption.Build(cb);
+        });
+    }
+
+    [Fact]
+    public void CatchAfterFinallyThrows()
+    {
+        Assert.Throws<InvalidOperationException>(() =>
+        {
+            var tryOption = new TryOption();
+            tryOption.Finally(f => f.AppendLine("Cleanup();"));
+            tryOption.Catch(c => c.AppendLine("Handle();"));
+        });
+    }
+
+    [Fact]
+    public void MultipleFinallyThrows()
+    {
+        Assert.Throws<InvalidOperationException>(() =>
+        {
+            var tryOption = new TryOption();
+            tryOption.Finally(f => f.AppendLine("Cleanup1();"));
+            tryOption.Finally(f => f.AppendLine("Cleanup2();"));
+        });
+    }
+
+    [Fact]
+    public void NullCatchConfigureThrows()
+    {
+        var tryOption = new TryOption();
+        Assert.Throws<ArgumentNullException>(() => tryOption.Catch(null!));
+    }
+
+    [Fact]
+    public void NullFinallyConfigureThrows()
+    {
+        var tryOption = new TryOption();
+        Assert.Throws<ArgumentNullException>(() => tryOption.Finally(null!));
+    }
+
+    [Fact]
+    public void TryCatch()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Run")
+            .WithReturnType("void")
+            .Try(@try =>
+            {
+                @try.AppendLine("DoWork();");
+                @try.Catch(c =>
+                {
+                    c.ExceptionType = "Exception";
+                    c.VariableName  = "ex";
+                    c.AppendLine("Console.WriteLine(ex.Message);");
+                });
+            })
+            .Build();
+
+        var expected = """
+            public void Run()
+            {
+              try
+              {
+                DoWork();
+              }
+              catch (Exception ex)
+              {
+                Console.WriteLine(ex.Message);
+              }
+            }
+            """;
+
+        Assert.Equal(Norm(expected), Norm(code));
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void TryCatchFinally()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Run")
+            .WithReturnType("void")
+            .Try(@try =>
+            {
+                @try.AppendLine("DoWork();");
+                @try.Catch(c =>
+                {
+                    c.ExceptionType = "Exception";
+                    c.VariableName  = "ex";
+                    c.AppendLine("Log(ex);");
+                });
+                @try.Finally(f =>
+                {
+                    f.AppendLine("Cleanup();");
+                });
+            })
+            .Build();
+
+        var expected = """
+            public void Run()
+            {
+              try
+              {
+                DoWork();
+              }
+              catch (Exception ex)
+              {
+                Log(ex);
+              }
+              finally
+              {
+                Cleanup();
+              }
+            }
+            """;
+
+        Assert.Equal(Norm(expected), Norm(code));
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void TryMultipleCatch()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Run")
+            .WithReturnType("void")
+            .Try(@try =>
+            {
+                @try.AppendLine("DoWork();");
+                @try.Catch(c =>
+                {
+                    c.ExceptionType = "ArgumentNullException";
+                    c.VariableName  = "ex";
+                    c.AppendLine("HandleNull(ex);");
+                });
+                @try.Catch(c =>
+                {
+                    c.ExceptionType = "InvalidOperationException";
+                    c.VariableName  = "ex";
+                    c.AppendLine("HandleInvalid(ex);");
+                });
+                @try.Catch(c =>
+                {
+                    c.ExceptionType = "Exception";
+                    c.VariableName  = "ex";
+                    c.AppendLine("HandleGeneral(ex);");
+                });
+            })
+            .Build();
+
+        Assert.Contains("catch (ArgumentNullException ex)", code);
+        Assert.Contains("catch (InvalidOperationException ex)", code);
+        Assert.Contains("catch (Exception ex)", code);
+        Assert.Contains("HandleNull(ex);", code);
+        Assert.Contains("HandleInvalid(ex);", code);
+        Assert.Contains("HandleGeneral(ex);", code);
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void TryCatchWithoutVariableName()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Run")
+            .WithReturnType("void")
+            .Try(@try =>
+            {
+                @try.AppendLine("DoWork();");
+                @try.Catch(c =>
+                {
+                    c.ExceptionType = "Exception";
+                    c.AppendLine("HandleError();");
+                });
+            })
+            .Build();
+
+        Assert.Contains("catch (Exception)", code);
+        Assert.Contains("HandleError();", code);
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void BareCatch()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Run")
+            .WithReturnType("void")
+            .Try(@try =>
+            {
+                @try.AppendLine("DoWork();");
+                @try.Catch(c =>
+                {
+                    c.AppendLine("HandleError();");
+                });
+            })
+            .Build();
+
+        Assert.Contains("catch", code);
+        Assert.DoesNotContain("catch (", code);
+        Assert.Contains("HandleError();", code);
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void TryCatchWithWhenFilter()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Run")
+            .WithReturnType("void")
+            .Try(@try =>
+            {
+                @try.AppendLine("DoWork();");
+                @try.Catch(c =>
+                {
+                    c.WithExceptionType("Exception")
+                     .WithVariableName("ex")
+                     .WithWhenFilter("ex.Message.Contains(\"timeout\")")
+                     .AppendLine("HandleTimeout(ex);");
+                });
+            })
+            .Build();
+
+        Assert.Contains("catch (Exception ex) when (ex.Message.Contains(\"timeout\"))", code);
+        Assert.Contains("HandleTimeout(ex);", code);
+        output.WriteLine(code);
+    }
+
+    [Fact]
+    public void TryFinallyWithoutCatch()
+    {
+        var code = new MethodOption()
+            .WithKeyword("public")
+            .WithName("Run")
+            .WithReturnType("void")
+            .Try(@try =>
+            {
+                @try.AppendLine("DoWork();");
+                @try.Finally(f =>
+                {
+                    f.AppendLine("Cleanup();");
+                });
+            })
+            .Build();
+
+        var expected = """
+            public void Run()
+            {
+              try
+              {
+                DoWork();
+              }
+              finally
+              {
+                Cleanup();
+              }
+            }
+            """;
+
+        Assert.Equal(Norm(expected), Norm(code));
+        output.WriteLine(code);
+    }
+}
diff --git a/EasyCodeBuilder/Csharp/MethodOption.cs b/EasyCodeBuilder/Csharp/MethodOption.cs
index 3a8620a..e9546ed 100644
--- a/EasyCodeBuilder/Csharp/MethodOption.cs
+++ b/EasyCodeBuilder/Csharp/MethodOption.cs
@@ -169,4 +169,13 @@ public static MethodOption Foreach(this MethodOption method, Action<ForeachOptio
     /// <returns>方法选项</returns>
     public static MethodOption Switch(this MethodOption method, Action<SwitchOption> configure)
         => method.AddChild(configure);
+
+    /// <summary>
+    /// add try-catch-finally statement
+    /// </summary>
+    /// <param name="method">方法选项</param>
+    /// <param name="configure">try 语句配置委托</param>
+    /// <returns>方法选项</returns>
+    public static MethodOption Try(this MethodOption method, Action<TryOption> configure)
+        => method.AddChild(configure);
 }
\ No newline at end of file
diff --git a/EasyCodeBuilder/Csharp/TryCatchFinallyOption.cs b/EasyCodeBuilder/Csharp/TryCatchFinallyOption.cs
new file mode 100644
index 0000000..601d517
--- /dev/null
+++ b/EasyCodeBuilder/Csharp/TryCatchFinallyOption.cs
@@ -0,0 +1,189 @@
+using System;
+using System.Collections.Generic;
+
+namespace Fengb3.EasyCodeBuilder.Csharp;
+
+/// <summary>
+/// try 语句选项
+/// </summary>
+public class TryOption : CodeOption
+{
+    private readonly List<CatchOption> _catches = new List<CatchOption>();
+    private FinallyOption? _finally;
+
+    /// <summary>
+    /// 构建代码
+    /// </summary>
+    /// <param name="cb">代码构建器</param>
+    /// <returns>代码构建器</returns>
+    public override CodeBuilder Build(CodeBuilder cb)
+    {
+        if (_catches.Count == 0 && _finally is null)
+        {
+            throw new InvalidOperationException("A try statement must include at least one catch or finally clause.");
+        }
+
+        BeforeChildren?.Invoke(cb);
+        cb.CodeBlock(OnChildren, "try");
+        foreach (var catchOption in _catches)
+        {
+            catchOption.Build(cb);
+        }
+        _finally?.Build(cb);
+        return cb;
+    }
+
+    internal void AddCatch(CatchOption catchOption)
+    {
+        if (_finally is not null)
+        {
+            throw new InvalidOperationException("A catch clause cannot appear after a finally clause.");
+        }
+        _catches.Add(catchOption);
+    }
+
+    internal void SetFinally(FinallyOption finallyOption)
+    {
+        if (_finally is not null)
+        {
+            throw new InvalidOperationException("A try statement cannot have more than one finally clause.");
+        }
+        _finally = finallyOption;
+    }
+}
+
+/// <summary>
+/// catch 语句选项
+/// </summary>
+public class CatchOption : CodeOption
+{
+    /// <summary>
+    /// 捕获的异常类型（为空时表示裸 catch）
+    /// </summary>
+    public string ExceptionType { get; set; } = "";
+
+    /// <summary>
+    /// 异常变量名（可为空）
+    /// </summary>
+    public string VariableName { get; set; } = "";
+
+    /// <summary>
+    /// when 过滤条件（可为空）
+    /// </summary>
+    public string WhenFilter { get; set; } = "";
+
+    /// <summary>
+    /// 构建代码
+    /// </summary>
+    /// <param name="cb">代码构建器</param>
+    /// <returns>代码构建器</returns>
+    public override CodeBuilder Build(CodeBuilder cb)
+    {
+        string header;
+        if (string.IsNullOrEmpty(ExceptionType))
+        {
+            header = "catch";
+        }
+        else if (string.IsNullOrEmpty(VariableName))
+        {
+            header = $"catch ({ExceptionType})";
+        }
+        else
+        {
+            header = $"catch ({ExceptionType} {VariableName})";
+        }
+
+        if (!string.IsNullOrEmpty(WhenFilter))
+        {
+            header += $" when ({WhenFilter})";
+        }
+
+        return cb.CodeBlock(OnChildren, header);
+    }
+}
+
+/// <summary>
+/// finally 语句选项
+/// </summary>
+public class FinallyOption : CodeOption
+{
+    /// <summary>
+    /// 构建代码
+    /// </summary>
+    /// <param name="cb">代码构建器</param>
+    /// <returns>代码构建器</returns>
+    public override CodeBuilder Build(CodeBuilder cb)
+        => cb.CodeBlock(OnChildren, "finally");
+}
+
+/// <summary>
+/// try-catch-finally 选项扩展方法
+/// </summary>
+public static class TryCatchFinallyOptionExtensions
+{
+    /// <summary>
+    /// add a catch clause to the try block
+    /// </summary>
+    /// <param name="tryOption">try 语句选项</param>
+    /// <param name="configure">catch 语句配置委托</param>
+    /// <returns>try 语句选项</returns>
+    public static TryOption Catch(this TryOption tryOption, Action<CatchOption> configure)
+    {
+        if (configure is null) throw new ArgumentNullException(nameof(configure));
+        var catchOption = new CatchOption();
+        configure(catchOption);
+        tryOption.AddCatch(catchOption);
+        return tryOption;
+    }
+
+    /// <summary>
+    /// add a finally clause to the try block
+    /// </summary>
+    /// <param name="tryOption">try 语句选项</param>
+    /// <param name="configure">finally 语句配置委托</param>
+    /// <returns>try 语句选项</returns>
+    public static TryOption Finally(this TryOption tryOption, Action<FinallyOption> configure)
+    {
+        if (configure is null) throw new ArgumentNullException(nameof(configure));
+        var finallyOption = new FinallyOption();
+        configure(finallyOption);
+        tryOption.SetFinally(finallyOption);
+        return tryOption;
+    }
+
+    /// <summary>
+    /// set exception type of catch clause
+    /// </summary>
+    /// <param name="catchOption">catch 语句选项</param>
+    /// <param name="exceptionType">异常类型</param>
+    /// <returns>catch 语句选项</returns>
+    public static CatchOption WithExceptionType(this CatchOption catchOption, string exceptionType)
+    {
+        catchOption.ExceptionType = exceptionType;
+        return catchOption;
+    }
+
+    /// <summary>
+    /// set variable name of catch clause
+    /// </summary>
+    /// <param name="catchOption">catch 语句选项</param>
+    /// <param name="variableName">异常变量名</param>
+    /// <returns>catch 语句选项</returns>
+    public static CatchOption WithVariableName(this CatchOption catchOption, string variableName)
+    {
+        catchOption.VariableName = variableName;
+        return catchOption;
+    }
+
+    /// <summary>
+    /// set when filter of catch clause
+    /// </summary>
+    /// <param name="catchOption">catch 语句选项</param>
+    /// <param name="whenFilter">过滤条件表达式</param>
+    /// <returns>catch 语句选项</returns>
+    public static CatchOption WithWhenFilter(this CatchOption catchOption, string whenFilter)
+    {
+        catchOption.WhenFilter = whenFilter;
+        return catchOption;
+    }
+}