From 5318f5a38f6d2547b9085c3413979b4163bb6c20 Mon Sep 17 00:00:00 2001
From: GeWuYou <95328647+GeWuYou@users.noreply.github.com>
Date: Sat, 31 Jan 2026 14:45:16 +0800
Subject: [PATCH] =?UTF-8?q?refactor(functional):=20=E9=87=8D=E6=9E=84?=
 =?UTF-8?q?=E5=87=BD=E6=95=B0=E5=BC=8F=E7=BC=96=E7=A8=8B=E6=89=A9=E5=B1=95?=
 =?UTF-8?q?=E6=96=B9=E6=B3=95=E7=BB=84=E7=BB=87=E7=BB=93=E6=9E=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 将原有的 PipeExtensions.cs 文件拆分为多个专门的功能模块
- 新增 ControlExtensions.cs 专门处理控制流扩展方法
- 新增 EnumerableExtensions.cs 专门处理集合相关扩展方法
- 新增 FunctionExtensions.cs 专门处理函数式编程核心功能
- 新增 TypeExtensions.cs 专门处理类型转换相关扩展方法
- 移除 PipeExtensions.cs 中的集合操作、函数式核心功能和控制流方法
- 保留 PipeExtensions.cs 中的管道操作相关核心方法
- 优化代码组织结构提升可维护性和可读性
---
 .../collections/EnumerableExtensions.cs       |  59 ++++
 .../functional/control/ControlExtensions.cs   | 118 ++++++++
 .../functions/FunctionExtensions.cs           | 125 ++++++++
 .../functional/pipe/PipeExtensions.cs         | 266 +-----------------
 .../functional/types/TypeExtensions.cs        |  44 +++
 5 files changed, 348 insertions(+), 264 deletions(-)
 create mode 100644 GFramework.Core/functional/collections/EnumerableExtensions.cs
 create mode 100644 GFramework.Core/functional/control/ControlExtensions.cs
 create mode 100644 GFramework.Core/functional/functions/FunctionExtensions.cs
 create mode 100644 GFramework.Core/functional/types/TypeExtensions.cs

diff --git a/GFramework.Core/functional/collections/EnumerableExtensions.cs b/GFramework.Core/functional/collections/EnumerableExtensions.cs
new file mode 100644
index 0000000..1fb2e09
--- /dev/null
+++ b/GFramework.Core/functional/collections/EnumerableExtensions.cs
@@ -0,0 +1,59 @@
+// Copyright (c) 2025 GeWuYou
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+namespace GFramework.Core.functional.collections;
+
+/// <summary>
+/// 提供集合的函数式编程扩展方法
+/// </summary>
+public static class EnumerableExtensions
+{
+    /// <summary>
+    /// Map：对集合中的每个元素应用函数
+    /// </summary>
+    /// <typeparam name="TSource">源集合元素的类型</typeparam>
+    /// <typeparam name="TResult">映射后集合元素的类型</typeparam>
+    /// <param name="source">要映射的源集合</param>
+    /// <param name="selector">用于转换元素的函数</param>
+    /// <returns>映射后的元素序列</returns>
+    public static IEnumerable<TResult> Map<TSource, TResult>(
+        this IEnumerable<TSource> source,
+        Func<TSource, TResult> selector)
+        => source.Select(selector);
+
+    /// <summary>
+    /// Filter：过滤集合
+    /// </summary>
+    /// <typeparam name="TSource">集合元素的类型</typeparam>
+    /// <param name="source">要过滤的源集合</param>
+    /// <param name="predicate">用于确定是否包含元素的条件函数</param>
+    /// <returns>满足条件的元素序列</returns>
+    public static IEnumerable<TSource> Filter<TSource>(
+        this IEnumerable<TSource> source,
+        Func<TSource, bool> predicate)
+        => source.Where(predicate);
+
+    /// <summary>
+    /// Reduce：将集合归约为单个值
+    /// </summary>
+    /// <typeparam name="TSource">集合元素的类型</typeparam>
+    /// <typeparam name="TResult">归约结果的类型</typeparam>
+    /// <param name="source">要归约的源集合</param>
+    /// <param name="seed">初始累加值</param>
+    /// <param name="accumulator">累加器函数</param>
+    /// <returns>归约后的最终值</returns>
+    public static TResult Reduce<TSource, TResult>(
+        this IEnumerable<TSource> source,
+        TResult seed,
+        Func<TResult, TSource, TResult> accumulator)
+        => source.Aggregate(seed, accumulator);
+}
diff --git a/GFramework.Core/functional/control/ControlExtensions.cs b/GFramework.Core/functional/control/ControlExtensions.cs
new file mode 100644
index 0000000..2e0ab2d
--- /dev/null
+++ b/GFramework.Core/functional/control/ControlExtensions.cs
@@ -0,0 +1,118 @@
+// Copyright (c) 2025 GeWuYou
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+namespace GFramework.Core.functional.control;
+
+/// <summary>
+/// 控制流扩展方法类，提供函数式编程风格的控制结构
+/// </summary>
+public static class ControlExtensions
+{
+    /// <summary>
+    /// Match：模式匹配（类似switch表达式）
+    /// </summary>
+    /// <typeparam name="TSource">输入值的类型</typeparam>
+    /// <typeparam name="TResult">匹配结果的类型</typeparam>
+    /// <param name="value">要进行模式匹配的输入值</param>
+    /// <param name="cases">匹配案例数组，每个包含谓词和处理器</param>
+    /// <returns>匹配到的处理结果</returns>
+    /// <exception cref="InvalidOperationException">当没有匹配的案例时抛出</exception>
+    public static TResult Match<TSource, TResult>(
+        this TSource value,
+        params (Func<TSource, bool> predicate, Func<TSource, TResult> handler)[] cases)
+    {
+        foreach (var (predicate, handler) in cases)
+        {
+            if (predicate(value))
+                return handler(value);
+        }
+        throw new InvalidOperationException("No matching case found");
+    }
+
+    /// <summary>
+    /// MatchOrDefault：带默认值的模式匹配
+    /// </summary>
+    /// <typeparam name="TSource">输入值的类型</typeparam>
+    /// <typeparam name="TResult">匹配结果的类型</typeparam>
+    /// <param name="value">要进行模式匹配的输入值</param>
+    /// <param name="defaultValue">当没有匹配案例时的默认返回值</param>
+    /// <param name="cases">匹配案例数组，每个包含谓词和处理器</param>
+    /// <returns>匹配到的处理结果或默认值</returns>
+    public static TResult MatchOrDefault<TSource, TResult>(
+        this TSource value,
+        TResult defaultValue,
+        params (Func<TSource, bool> predicate, Func<TSource, TResult> handler)[] cases)
+    {
+        foreach (var (predicate, handler) in cases)
+        {
+            if (predicate(value))
+                return handler(value);
+        }
+        return defaultValue;
+    }
+
+    /// <summary>
+    /// If：条件执行
+    /// </summary>
+    /// <typeparam name="TSource">输入值的类型</typeparam>
+    /// <param name="value">要进行条件判断的输入值</param>
+    /// <param name="predicate">条件判断函数</param>
+    /// <param name="thenFunc">条件为真时执行的转换函数</param>
+    /// <returns>条件为真时返回转换后的值，否则返回原值</returns>
+    public static TSource If<TSource>(
+        this TSource value,
+        Func<TSource, bool> predicate,
+        Func<TSource, TSource> thenFunc)
+        => predicate(value) ? thenFunc(value) : value;
+
+    /// <summary>
+    /// IfElse：条件分支
+    /// </summary>
+    /// <typeparam name="TSource">输入值的类型</typeparam>
+    /// <param name="value">要进行条件判断的输入值</param>
+    /// <param name="predicate">条件判断函数</param>
+    /// <param name="thenFunc">条件为真时执行的转换函数</param>
+    /// <param name="elseFunc">条件为假时执行的转换函数</param>
+    /// <returns>根据条件返回相应的转换结果</returns>
+    public static TSource IfElse<TSource>(
+        this TSource value,
+        Func<TSource, bool> predicate,
+        Func<TSource, TSource> thenFunc,
+        Func<TSource, TSource> elseFunc)
+        => predicate(value) ? thenFunc(value) : elseFunc(value);
+    
+    /// <summary>
+    /// TakeIf：条件返回值或null
+    /// </summary>
+    /// <typeparam name="TSource">输入值的类型</typeparam>
+    /// <param name="value">要进行条件判断的输入值</param>
+    /// <param name="predicate">条件判断函数</param>
+    /// <returns>条件为真时返回原值，否则返回null</returns>
+    public static TSource? TakeIf<TSource>(
+        this TSource value,
+        Func<TSource, bool> predicate)
+        where TSource : class
+        => predicate(value) ? value : null;
+
+    /// <summary>
+    /// TakeUnless：条件相反的TakeIf
+    /// </summary>
+    /// <typeparam name="TSource">输入值的类型</typeparam>
+    /// <param name="value">要进行条件判断的输入值</param>
+    /// <param name="predicate">条件判断函数</param>
+    /// <returns>条件为假时返回原值，否则返回null</returns>
+    public static TSource? TakeUnless<TSource>(
+        this TSource value,
+        Func<TSource, bool> predicate)
+        where TSource : class
+        => !predicate(value) ? value : null;
+}
diff --git a/GFramework.Core/functional/functions/FunctionExtensions.cs b/GFramework.Core/functional/functions/FunctionExtensions.cs
new file mode 100644
index 0000000..b2c04e1
--- /dev/null
+++ b/GFramework.Core/functional/functions/FunctionExtensions.cs
@@ -0,0 +1,125 @@
+// Copyright (c) 2025 GeWuYou
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+namespace GFramework.Core.functional.functions;
+
+/// <summary>
+/// 函数式编程扩展方法集合，提供柯里化、偏函数应用、重复执行、安全执行和缓存等功能
+/// </summary>
+public static class FunctionExtensions
+{
+    /// <summary>
+    /// Curry：将二参数函数转换为柯里化形式
+    /// </summary>
+    /// <typeparam name="T1">第一个参数的类型</typeparam>
+    /// <typeparam name="T2">第二个参数的类型</typeparam>
+    /// <typeparam name="TResult">函数返回结果的类型</typeparam>
+    /// <param name="func">要柯里化的二参数函数</param>
+    /// <returns>柯里化后的函数，接受一个参数并返回另一个函数</returns>
+    public static Func<T1, Func<T2, TResult>> Curry<T1, T2, TResult>(
+        this Func<T1, T2, TResult> func)
+        => x => y => func(x, y);
+
+    /// <summary>
+    /// Uncurry：将柯里化函数转换回二参数函数
+    /// </summary>
+    /// <typeparam name="T1">第一个参数的类型</typeparam>
+    /// <typeparam name="T2">第二个参数的类型</typeparam>
+    /// <typeparam name="TResult">函数返回结果的类型</typeparam>
+    /// <param name="func">要取消柯里化的函数</param>
+    /// <returns>恢复为二参数的函数</returns>
+    public static Func<T1, T2, TResult> Uncurry<T1, T2, TResult>(
+        this Func<T1, Func<T2, TResult>> func)
+        => (x, y) => func(x)(y);
+
+    /// <summary>
+    /// Partial：部分应用函数（固定第一个参数）
+    /// </summary>
+    /// <typeparam name="T1">第一个参数的类型</typeparam>
+    /// <typeparam name="T2">第二个参数的类型</typeparam>
+    /// <typeparam name="TResult">函数返回结果的类型</typeparam>
+    /// <param name="func">要部分应用的二参数函数</param>
+    /// <param name="firstArg">要固定的第一个参数值</param>
+    /// <returns>部分应用后的函数，只接受第二个参数</returns>
+    public static Func<T2, TResult> Partial<T1, T2, TResult>(
+        this Func<T1, T2, TResult> func,
+        T1 firstArg)
+        => x => func(firstArg, x);
+    
+    /// <summary>
+    /// Repeat：重复执行函数n次
+    /// </summary>
+    /// <typeparam name="TSource">输入值的类型</typeparam>
+    /// <param name="value">初始输入值</param>
+    /// <param name="times">重复执行的次数</param>
+    /// <param name="func">要重复执行的函数</param>
+    /// <returns>经过多次变换后的最终值</returns>
+    public static TSource Repeat<TSource>(
+        this TSource value,
+        int times,
+        Func<TSource, TSource> func)
+    {
+        var result = value;
+        // 循环执行指定次数的函数调用
+        for (int i = 0; i < times; i++)
+        {
+            result = func(result);
+        }
+        return result;
+    }
+
+    /// <summary>
+    /// Try：安全执行，捕获异常
+    /// </summary>
+    /// <typeparam name="TSource">输入值的类型</typeparam>
+    /// <typeparam name="TResult">函数返回结果的类型</typeparam>
+    /// <param name="value">要传递给函数的输入值</param>
+    /// <param name="func">要安全执行的函数</param>
+    /// <returns>包含执行状态、结果和错误信息的元组</returns>
+    public static (bool success, TResult? result, Exception? error) Try<TSource, TResult>(
+        this TSource value,
+        Func<TSource, TResult> func)
+    {
+        try
+        {
+            return (true, func(value), null);
+        }
+        catch (Exception ex)
+        {
+            return (false, default, ex);
+        }
+    }
+
+    /// <summary>
+    /// Memoize：缓存函数结果
+    /// </summary>
+    /// <typeparam name="TSource">函数输入参数的类型</typeparam>
+    /// <typeparam name="TResult">函数返回结果的类型</typeparam>
+    /// <param name="func">要缓存结果的函数</param>
+    /// <returns>带有缓存功能的包装函数</returns>
+    public static Func<TSource, TResult> Memoize<TSource, TResult>(
+        this Func<TSource, TResult> func)
+        where TSource : notnull
+    {
+        var cache = new Dictionary<TSource, TResult>();
+        return x =>
+        {
+            // 尝试从缓存中获取结果
+            if (cache.TryGetValue(x, out var result))
+                return result;
+            // 缓存未命中时计算结果并存储
+            result = func(x);
+            cache[x] = result;
+            return result;
+        };
+    }
+}
diff --git a/GFramework.Core/functional/pipe/PipeExtensions.cs b/GFramework.Core/functional/pipe/PipeExtensions.cs
index 3ce37ad..595789e 100644
--- a/GFramework.Core/functional/pipe/PipeExtensions.cs
+++ b/GFramework.Core/functional/pipe/PipeExtensions.cs
@@ -73,46 +73,6 @@ public static class PipeExtensions
         return value;
     }
 
-    /// <summary>
-    /// Map：对集合中的每个元素应用函数
-    /// </summary>
-    /// <typeparam name="TSource">源集合元素的类型</typeparam>
-    /// <typeparam name="TResult">映射后集合元素的类型</typeparam>
-    /// <param name="source">要映射的源集合</param>
-    /// <param name="selector">用于转换元素的函数</param>
-    /// <returns>映射后的元素序列</returns>
-    public static IEnumerable<TResult> Map<TSource, TResult>(
-        this IEnumerable<TSource> source,
-        Func<TSource, TResult> selector)
-        => source.Select(selector);
-
-    /// <summary>
-    /// Filter：过滤集合
-    /// </summary>
-    /// <typeparam name="TSource">集合元素的类型</typeparam>
-    /// <param name="source">要过滤的源集合</param>
-    /// <param name="predicate">用于确定是否包含元素的条件函数</param>
-    /// <returns>满足条件的元素序列</returns>
-    public static IEnumerable<TSource> Filter<TSource>(
-        this IEnumerable<TSource> source,
-        Func<TSource, bool> predicate)
-        => source.Where(predicate);
-
-    /// <summary>
-    /// Reduce：将集合归约为单个值
-    /// </summary>
-    /// <typeparam name="TSource">集合元素的类型</typeparam>
-    /// <typeparam name="TResult">归约结果的类型</typeparam>
-    /// <param name="source">要归约的源集合</param>
-    /// <param name="seed">初始累加值</param>
-    /// <param name="accumulator">累加器函数</param>
-    /// <returns>归约后的最终值</returns>
-    public static TResult Reduce<TSource, TResult>(
-        this IEnumerable<TSource> source,
-        TResult seed,
-        Func<TResult, TSource, TResult> accumulator)
-        => source.Aggregate(seed, accumulator);
-
     /// <summary>
     /// Apply：将函数应用于值（柯里化辅助）
     /// </summary>
@@ -125,140 +85,7 @@ public static class PipeExtensions
         this Func<TSource, TResult> func,
         TSource value)
         => func(value);
-
-    /// <summary>
-    /// Curry：将二参数函数转换为柯里化形式
-    /// </summary>
-    /// <typeparam name="T1">第一个参数的类型</typeparam>
-    /// <typeparam name="T2">第二个参数的类型</typeparam>
-    /// <typeparam name="TResult">函数返回结果的类型</typeparam>
-    /// <param name="func">要柯里化的二参数函数</param>
-    /// <returns>柯里化后的函数，接受一个参数并返回另一个函数</returns>
-    public static Func<T1, Func<T2, TResult>> Curry<T1, T2, TResult>(
-        this Func<T1, T2, TResult> func)
-        => x => y => func(x, y);
-
-    /// <summary>
-    /// Uncurry：将柯里化函数转换回二参数函数
-    /// </summary>
-    /// <typeparam name="T1">第一个参数的类型</typeparam>
-    /// <typeparam name="T2">第二个参数的类型</typeparam>
-    /// <typeparam name="TResult">函数返回结果的类型</typeparam>
-    /// <param name="func">要取消柯里化的函数</param>
-    /// <returns>恢复为二参数的函数</returns>
-    public static Func<T1, T2, TResult> Uncurry<T1, T2, TResult>(
-        this Func<T1, Func<T2, TResult>> func)
-        => (x, y) => func(x)(y);
-
-    /// <summary>
-    /// Partial：部分应用函数（固定第一个参数）
-    /// </summary>
-    /// <typeparam name="T1">第一个参数的类型</typeparam>
-    /// <typeparam name="T2">第二个参数的类型</typeparam>
-    /// <typeparam name="TResult">函数返回结果的类型</typeparam>
-    /// <param name="func">要部分应用的二参数函数</param>
-    /// <param name="firstArg">要固定的第一个参数值</param>
-    /// <returns>部分应用后的函数，只接受第二个参数</returns>
-    public static Func<T2, TResult> Partial<T1, T2, TResult>(
-        this Func<T1, T2, TResult> func,
-        T1 firstArg)
-        => x => func(firstArg, x);
-
-    /// <summary>
-    /// Match：模式匹配（类似switch表达式）
-    /// </summary>
-    /// <typeparam name="TSource">输入值的类型</typeparam>
-    /// <typeparam name="TResult">匹配结果的类型</typeparam>
-    /// <param name="value">要进行模式匹配的输入值</param>
-    /// <param name="cases">匹配案例数组，每个包含谓词和处理器</param>
-    /// <returns>匹配到的处理结果</returns>
-    /// <exception cref="InvalidOperationException">当没有匹配的案例时抛出</exception>
-    public static TResult Match<TSource, TResult>(
-        this TSource value,
-        params (Func<TSource, bool> predicate, Func<TSource, TResult> handler)[] cases)
-    {
-        foreach (var (predicate, handler) in cases)
-        {
-            if (predicate(value))
-                return handler(value);
-        }
-        throw new InvalidOperationException("No matching case found");
-    }
-
-    /// <summary>
-    /// MatchOrDefault：带默认值的模式匹配
-    /// </summary>
-    /// <typeparam name="TSource">输入值的类型</typeparam>
-    /// <typeparam name="TResult">匹配结果的类型</typeparam>
-    /// <param name="value">要进行模式匹配的输入值</param>
-    /// <param name="defaultValue">当没有匹配案例时的默认返回值</param>
-    /// <param name="cases">匹配案例数组，每个包含谓词和处理器</param>
-    /// <returns>匹配到的处理结果或默认值</returns>
-    public static TResult MatchOrDefault<TSource, TResult>(
-        this TSource value,
-        TResult defaultValue,
-        params (Func<TSource, bool> predicate, Func<TSource, TResult> handler)[] cases)
-    {
-        foreach (var (predicate, handler) in cases)
-        {
-            if (predicate(value))
-                return handler(value);
-        }
-        return defaultValue;
-    }
-
-    /// <summary>
-    /// If：条件执行
-    /// </summary>
-    /// <typeparam name="TSource">输入值的类型</typeparam>
-    /// <param name="value">要进行条件判断的输入值</param>
-    /// <param name="predicate">条件判断函数</param>
-    /// <param name="thenFunc">条件为真时执行的转换函数</param>
-    /// <returns>条件为真时返回转换后的值，否则返回原值</returns>
-    public static TSource If<TSource>(
-        this TSource value,
-        Func<TSource, bool> predicate,
-        Func<TSource, TSource> thenFunc)
-        => predicate(value) ? thenFunc(value) : value;
-
-    /// <summary>
-    /// IfElse：条件分支
-    /// </summary>
-    /// <typeparam name="TSource">输入值的类型</typeparam>
-    /// <param name="value">要进行条件判断的输入值</param>
-    /// <param name="predicate">条件判断函数</param>
-    /// <param name="thenFunc">条件为真时执行的转换函数</param>
-    /// <param name="elseFunc">条件为假时执行的转换函数</param>
-    /// <returns>根据条件返回相应的转换结果</returns>
-    public static TSource IfElse<TSource>(
-        this TSource value,
-        Func<TSource, bool> predicate,
-        Func<TSource, TSource> thenFunc,
-        Func<TSource, TSource> elseFunc)
-        => predicate(value) ? thenFunc(value) : elseFunc(value);
-
-    /// <summary>
-    /// As：类型转换（安全转换）
-    /// </summary>
-    /// <typeparam name="TSource">源类型的泛型参数</typeparam>
-    /// <typeparam name="TResult">目标类型的泛型参数</typeparam>
-    /// <param name="value">要进行类型转换的值</param>
-    /// <returns>转换后的值，如果转换失败则返回null</returns>
-    public static TResult? As<TSource, TResult>(
-        this TSource value)
-        where TResult : class
-        => value as TResult;
-
-    /// <summary>
-    /// Cast：强制类型转换
-    /// </summary>
-    /// <typeparam name="TResult">目标类型的泛型参数</typeparam>
-    /// <param name="value">要进行类型转换的对象</param>
-    /// <returns>强制转换后的值</returns>
-    public static TResult Cast<TResult>(
-        this object value)
-        => (TResult)value;
-
+    
     /// <summary>
     /// Also：执行操作并返回原值
     /// </summary>
@@ -287,94 +114,5 @@ public static class PipeExtensions
         Func<TSource, TResult> transform)
         => transform(value);
 
-    /// <summary>
-    /// TakeIf：条件返回值或null
-    /// </summary>
-    /// <typeparam name="TSource">输入值的类型</typeparam>
-    /// <param name="value">要进行条件判断的输入值</param>
-    /// <param name="predicate">条件判断函数</param>
-    /// <returns>条件为真时返回原值，否则返回null</returns>
-    public static TSource? TakeIf<TSource>(
-        this TSource value,
-        Func<TSource, bool> predicate)
-        where TSource : class
-        => predicate(value) ? value : null;
-
-    /// <summary>
-    /// TakeUnless：条件相反的TakeIf
-    /// </summary>
-    /// <typeparam name="TSource">输入值的类型</typeparam>
-    /// <param name="value">要进行条件判断的输入值</param>
-    /// <param name="predicate">条件判断函数</param>
-    /// <returns>条件为假时返回原值，否则返回null</returns>
-    public static TSource? TakeUnless<TSource>(
-        this TSource value,
-        Func<TSource, bool> predicate)
-        where TSource : class
-        => !predicate(value) ? value : null;
-
-    /// <summary>
-    /// Repeat：重复执行函数n次
-    /// </summary>
-    /// <typeparam name="TSource">输入值的类型</typeparam>
-    /// <param name="value">初始输入值</param>
-    /// <param name="times">重复执行的次数</param>
-    /// <param name="func">要重复执行的函数</param>
-    /// <returns>经过多次变换后的最终值</returns>
-    public static TSource Repeat<TSource>(
-        this TSource value,
-        int times,
-        Func<TSource, TSource> func)
-    {
-        var result = value;
-        for (int i = 0; i < times; i++)
-        {
-            result = func(result);
-        }
-        return result;
-    }
-
-    /// <summary>
-    /// Try：安全执行，捕获异常
-    /// </summary>
-    /// <typeparam name="TSource">输入值的类型</typeparam>
-    /// <typeparam name="TResult">函数返回结果的类型</typeparam>
-    /// <param name="value">要传递给函数的输入值</param>
-    /// <param name="func">要安全执行的函数</param>
-    /// <returns>包含执行状态、结果和错误信息的元组</returns>
-    public static (bool success, TResult? result, Exception? error) Try<TSource, TResult>(
-        this TSource value,
-        Func<TSource, TResult> func)
-    {
-        try
-        {
-            return (true, func(value), null);
-        }
-        catch (Exception ex)
-        {
-            return (false, default, ex);
-        }
-    }
-
-    /// <summary>
-    /// Memoize：缓存函数结果
-    /// </summary>
-    /// <typeparam name="TSource">函数输入参数的类型</typeparam>
-    /// <typeparam name="TResult">函数返回结果的类型</typeparam>
-    /// <param name="func">要缓存结果的函数</param>
-    /// <returns>带有缓存功能的包装函数</returns>
-    public static Func<TSource, TResult> Memoize<TSource, TResult>(
-        this Func<TSource, TResult> func)
-        where TSource : notnull
-    {
-        var cache = new Dictionary<TSource, TResult>();
-        return x =>
-        {
-            if (cache.TryGetValue(x, out var result))
-                return result;
-            result = func(x);
-            cache[x] = result;
-            return result;
-        };
-    }
+    
 }
diff --git a/GFramework.Core/functional/types/TypeExtensions.cs b/GFramework.Core/functional/types/TypeExtensions.cs
new file mode 100644
index 0000000..937998f
--- /dev/null
+++ b/GFramework.Core/functional/types/TypeExtensions.cs
@@ -0,0 +1,44 @@
+// Copyright (c) 2025 GeWuYou
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+namespace GFramework.Core.functional.types;
+
+/// <summary>
+/// 提供类型转换相关的扩展方法
+/// </summary>
+public static class TypeExtensions
+{
+    /// <summary>
+    /// 安全类型转换方法，将源类型转换为目标类型
+    /// 如果转换失败或值为null，则返回null而不抛出异常
+    /// </summary>
+    /// <typeparam name="TSource">源类型参数</typeparam>
+    /// <typeparam name="TResult">目标类型参数，必须为引用类型</typeparam>
+    /// <param name="value">需要进行类型转换的源值</param>
+    /// <returns>转换成功时返回目标类型实例，失败时返回null</returns>
+    public static TResult? As<TSource, TResult>(
+        this TSource value)
+        where TResult : class
+        => value as TResult;
+
+    /// <summary>
+    /// 强制类型转换方法，将对象转换为指定的目标类型
+    /// 转换失败时会抛出InvalidCastException异常
+    /// </summary>
+    /// <typeparam name="TResult">目标类型参数</typeparam>
+    /// <param name="value">需要进行强制类型转换的对象</param>
+    /// <returns>转换后的目标类型实例</returns>
+    /// <exception cref="InvalidCastException">当转换失败时抛出此异常</exception>
+    public static TResult Cast<TResult>(
+        this object value)
+        => (TResult)value;
+}