C#可变参数params示例详解

static void ParamtesDemo(string className, params string[] names)
{
    Console.WriteLine($"{className}的学生有:{string.Join(",", names)}");
}

ParamtesDemo("小四班", "jordan", "kobe", "james", "curry");
// 如果不传递值也不会报错
// ParamtesDemo("小四班");

[CompilerGenerated]
internal class Program
{
	private static void <Main>$(string[] args)
	{
        //声明了一个数组
		ParamtesDemo("小四班", new string[4] { "jordan", "kobe", "james", "curry" });
        Console.ReadKey();

        //已经没有params关键字了，就是一个数组
		static void ParamtesDemo(string className, string[] names)
		{
			Console.WriteLine(className + "的学生有:" + string.Join(",", names));
		}
	}
}

// Methods
.method private hidebysig static 
		void '<Main>$' (
			string[] args
		) cil managed 
{
	// Method begins at RVA 0x2092
	// Header size: 1
	// Code size: 57 (0x39)
	.maxstack 8
	.entrypoint

	// ParamtesDemo("小四班", new string[4] { "jordan", "kobe", "james", "curry" });
	IL_0000: ldstr "小四班"
	IL_0005: ldc.i4.4
        //通过newarr可知确实是声明了一个数组类型
	IL_0006: newarr [System.Runtime]System.String
	IL_000b: dup
	IL_000c: ldc.i4.0
	IL_000d: ldstr "jordan"
	IL_0012: stelem.ref
	IL_0013: dup
	IL_0014: ldc.i4.1
	IL_0015: ldstr "kobe"
	IL_001a: stelem.ref
	IL_001b: dup
	IL_001c: ldc.i4.2
	IL_001d: ldstr "james"
	IL_0022: stelem.ref
	IL_0023: dup
	IL_0024: ldc.i4.3
	IL_0025: ldstr "curry"
	IL_002a: stelem.ref
	// 这个地方调用了ParamtesDemo，第二个参数确实是一个数组类型
	IL_002b: call void Program::'<<Main>$>g__ParamtesDemo|0_0'(string, string[])
	// Console.ReadKey();
	IL_0030: nop
	IL_0031: call valuetype [System.Console]System.ConsoleKeyInfo [System.Console]System.Console::ReadKey()
	IL_0036: pop
	// }
	IL_0037: nop
	IL_0038: ret
} // end of method Program::'<Main>$'	

//names也是一个数组
.method assembly hidebysig static 
	void '<<Main>$>g__ParamtesDemo|0_0' (
		string className,
		string[] names
	) cil managed 
{
	.custom instance void System.Runtime.CompilerServices.NullableContextAttribute::.ctor(uint8) = (
		01 00 01 00 00
	)
	.custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = (
		01 00 00 00
	// Method begins at RVA 0x20d5
	// Header size: 1
	// Code size: 30 (0x1e)
	.maxstack 8

	// {
	IL_0000: nop
	// Console.WriteLine(className + "的学生有:" + string.Join(",", names));
	IL_0001: ldarg.0
	IL_0002: ldstr "的学生有:"
	IL_0007: ldstr ","
	IL_000c: ldarg.1
	IL_000d: call string [System.Runtime]System.String::Join(string, string[])
	IL_0012: call string [System.Runtime]System.String::Concat(string, string, string)
	IL_0017: call void [System.Console]System.Console::WriteLine(string)
	// }
	IL_001c: nop
	IL_001d: ret
} // end of method Program::'<<Main>$>g__ParamtesDemo|0_0'

// Methods
.method private hidebysig static 
	void '<Main>$' (
		string[] args
	) cil managed 
{
	// Method begins at RVA 0x2092
	// Header size: 1
	// Code size: 24 (0x18)
	.maxstack 8
	.entrypoint

	// ParamtesDemo("小四班", Array.Empty<string>());
	IL_0000: ldstr "小四班"
        // 本质是编译的时候帮我们声明了一个空数组Array::Empty<string>
	IL_0005: call !!0[] [System.Runtime]System.Array::Empty<string>()
	IL_000a: call void Program::'<<Main>$>g__ParamtesDemo|0_0'(string, string[])
	// Console.ReadKey();
	IL_000f: nop
	IL_0010: call valuetype [System.Console]System.ConsoleKeyInfo [System.Console]System.Console::ReadKey()
	IL_0015: pop
	// }
	IL_0016: nop
	IL_0017: ret
} // end of method Program::'<Main>$'

public static string Format(string format, params object?[] args)
{
    if (args == null)
    {
        throw new ArgumentNullException((format == null) ? nameof(format) : nameof(args));
    }
    return FormatHelper(null, format, new ParamsArray(args));
}

internal readonly struct ParamsArray
{
    //定义是三个数组分别去承载当传递进来的params不同个数时的数据
    private static readonly object?[] s_oneArgArray = new object?[1];
    private static readonly object?[] s_twoArgArray = new object?[2];
    private static readonly object?[] s_threeArgArray = new object?[3];

    //定义三个值分别存储params的第0、1、2个参数的值
    private readonly object? _arg0;
    private readonly object? _arg1;
    private readonly object? _arg2;
    //承载最原始的params值
    private readonly object?[] _args;
    //params值为1个的时候
    public ParamsArray(object? arg0)
    {
        _arg0 = arg0;
        _arg1 = null;
        _arg2 = null;
        _args = s_oneArgArray;
    }
    //params值为2个的时候
    public ParamsArray(object? arg0, object? arg1)
        _arg1 = arg1;
        _args = s_twoArgArray;
    //params值为3个的时候
    public ParamsArray(object? arg0, object? arg1, object? arg2)
        _arg2 = arg2;
        _args = s_threeArgArray;
    //直接包装整个params的值
    public ParamsArray(object?[] args)
        //直接取出来值缓存
        int len = args.Length;
        _arg0 = len > 0 ? args[0] : null;
        _arg1 = len > 1 ? args[1] : null;
        _arg2 = len > 2 ? args[2] : null;
        _args = args;
    public int Length => _args.Length;
    public object? this[int index] => index == 0 ? _arg0 : GetAtSlow(index);
    //判断是否从承载的缓存中取值
    private object? GetAtSlow(int index)
        if (index == 1)
            return _arg1;
        if (index == 2)
            return _arg2;
        return _args[index];
}