如何改进泛型数组Append扩展方法，支持null数组直接调用无需赋值？

首先得明确核心原因：C#的数组是固定长度的引用类型，你没法直接修改原数组的长度——任何“追加”操作本质上都是创建一个新数组，然后把原数组和新元素复制进去。这也是为什么你原有的Append方法必须返回新数组，并且需要重新赋值给原变量。

要实现你想要的objArray.Append(new Object())直接调用（不用赋值），有几个可行的方向，我按实用性排序给你讲：

1. 改用List<T>替代数组（最推荐） #

如果业务场景允许，直接使用List<T>是最简单的方案——它本身就是为可变长度的集合设计的，原生支持Add/AddRange方法，调用时不需要赋值：

// 初始化时可以直接处理null情况
List<Object> objList = objList ?? new List<Object>();
objList.Add(new Object());

// 或者写个扩展方法自动处理null（注意：如果要自动初始化空列表，需要用ref参数）
public static void AddSafe<T>(this List<T> source, T item)
{
    if (source == null)
        throw new ArgumentNullException(nameof(source), "List cannot be null. Consider initializing it first.");
    source.Add(item);
}

如果需要自动初始化null的列表，可搭配ref参数的辅助方法：

public static void AddToRefList<T>(ref List<T> source, T item)
{
    if (source == null)
        source = new List<T>();
    source.Add(item);
}

// 调用方式：
List<Object> objList = null;
AddToRefList(ref objList, new Object());

2. 使用带ref参数的方法（兼容数组场景） #

如果你必须坚持使用数组，可以通过ref参数让方法直接修改原变量的引用——这样就不需要手动赋值了。注意C#的扩展方法不支持this ref语法（存在编译限制），所以推荐写一个普通的静态方法：

public static void AppendToArray<T>(ref T[] source, params T[] toAdd)
{
    if (source == null)
        source = new T[0];
    
    var list = new List<T>(source);
    list.AddRange(toAdd);
    source = list.ToArray();
}

// 调用方式：
Object[] objArray = null;
AppendToArray(ref objArray, new Object());

这个方法会直接修改objArray变量的引用，把它指向新创建的数组，完美实现你想要的“直接调用”效果。

3. 自定义可变数组容器（灵活但略复杂） #

如果需要更封装的解决方案，可以自己写一个MutableArray<T>类，内部封装数组并提供修改方法：

public class MutableArray<T>
{
    private T[] _internalArray;

    public MutableArray()
    {
        _internalArray = new T[0];
    }

    public MutableArray(T[] initialArray)
    {
        _internalArray = initialArray ?? new T[0];
    }

    // 你的追加方法
    public void Append(params T[] toAdd)
    {
        var tempList = new List<T>(_internalArray);
        tempList.AddRange(toAdd);
        _internalArray = tempList.ToArray();
    }

    // 转换回普通数组的方法
    public T[] ToArray() => (T[])_internalArray.Clone();

    // 隐式转换，方便兼容原有代码
    public static implicit operator T[](MutableArray<T> mutableArray)
    {
        return mutableArray.ToArray();
    }
}

// 调用方式：
var objArray = new MutableArray<Object>();
objArray.Append(new Object());

// 需要普通数组时直接转换：
Object[] regularArray = objArray;

总结 #

如果你能改用List<T>，这是最省心的方案；如果必须用数组，带ref参数的静态方法是最直接的解决方式；自定义容器则适合需要更复杂封装的场景。

本质上，数组的固定长度特性决定了“追加”必然要创建新数组，所以要么接受原方法的赋值操作，要么通过上述方式绕过手动赋值的步骤。

内容的提问来源于stack exchange，提问作者5tar-Kaster