淺談C#可變引數params

前言

    前幾天在群裡看到群友寫了一個基礎框架，其中設計到關於同一個詞語可以新增多個近義詞的一個場景。當時群友的設計是類似字典的設計，直接新增k-v的操作，本人看到後思考了一下覺得使用c#中的params可以更優雅的實現一個key同時新增一個集合的操作，看起來會更優雅一點，這期間還有群友說道params和陣列有啥區別的問題。本篇文章就來大致的說一下。

示例

params是c#的一個關鍵字，用用漢語來說的話叫可變引數，這裡的可變，不是說的型別可變，而是指的個數可變，這是c#的一個基礎關鍵字，相信大家都有一定的瞭解，今天我們們就來進一步看一下c#的可變引數params。首先來看一下簡單的自定義使用，隨便定義一個方法

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

定義可變引數型別的時候需要有幾個注意點

• params修飾在引數的前面且引數型別得是一維陣列型別
• params修飾的引數預設是可以不傳遞的
• params引數不能用ref或out修飾且不能手動給預設值

呼叫的時候更簡單了，如下所示

ParamtesDemo("小四班", "jordan", "kobe", "james", "curry");
// 如果不傳遞值也不會報錯
// ParamtesDemo("小四班");

由上面的示例可知，使用可變引數最大的優勢就是你可以傳遞一個不確定個數的集合型別並且不用宣告單獨的型別去包裝，這種場景特別適合傳遞引數不確定的場景，比如我們經常使用到的string.Format就是使用的可變引數型別。

探究本質

通過上面我們瞭解到的params的遍歷性，當集合引數個數不確定的時候是使用可變引數的最佳場景，看著很神奇很便捷，本質到底是什麼呢？之前樓主也沒有在意這個問題，直到前幾天懷揣著好奇的心情看了一下。廢話不多說，我們直接藉助ILSpy工具看一下反編譯之後的原始碼

[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));
		}
	}
}

通過ILSpy反編譯的原始碼我們可以看到params是一個語法糖，其實就是增加了程式設計效率，本質在編譯的時候會被具體的宣告的陣列型別替代，不參與到執行時。這個時候如果你懷疑反編譯的程式碼有問題，可以直接通過ILSpy看生成的IL程式碼，由於IL程式碼比較長，首先看一下Main方法

// 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>$'	

通過上面的IL程式碼可以看到確實是一個語法糖，編譯完之後一切塵歸塵土歸土還是一個陣列型別，型別是和params修飾的那個陣列型別是一致的。接下來我們再來看一下ParamtesDemo這個方法的IL程式碼是啥樣的

//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'

一切瞭然，本質就是那個陣列。我們上面還提到了params修飾的引數預設不傳遞的話也不會報錯，這究竟是為什麼呢，我們就用IL程式碼來看一下究竟進行了何等操作吧

// 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>$'

原來這得感謝編譯器，如果預設不傳遞params修飾的引數的話，預設它會幫我們生成一個這個型別的空陣列，這裡需要注意的不是null,所以程式碼不會報錯，只是沒有資料。

擴充套件知識

我們上面提到了string.Format也是基於params實現的，畢竟Format具體的引數依賴於前面宣告的字串的佔位符個數。在翻看相關程式碼的時候還發現了一個ParamsArray這個類，用來包裝params可變引數，簡單的來說就是便於快速操作params，這個我是在Format方法中發現的，原始碼如下

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));
}

params引數也可以為null值，預設不會報錯，但是需要進行判斷，否則程式處理null可能會報錯。在這裡我們可以看到把params引數傳遞給ParamsArray進行包裝，我們可以看一下ParamsArray類本身的定義，這個類是一個struct型別的

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)
    {
        _arg0 = arg0;
        _arg1 = arg1;
        _arg2 = null;

        _args = s_twoArgArray;
    }

    //params值為3個的時候
    public ParamsArray(object? arg0, object? arg1, object? arg2)
    {
        _arg0 = arg0;
        _arg1 = arg1;
        _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];
    }
}

ParamsArray是一個值型別，目的就是為了把params引數的值給包裝起來提供讀相關的操作。根據二八法則來看，params大部分場景的引數個數或者高頻訪問可能是存在於陣列的前幾位元素上，所以使用ParamsArray針對熱點元素提供了快速訪問的方式，略微有一點像Java中的IntegerCache的設計。這個結構體是internal型別的，預設程式集之外是沒辦法訪問的，我當時看到的時候比較好奇，就多看了一眼，感覺設計思路還是考慮的比較周到的。

總結

    本文主要簡單的聊一下c#可變引數params的本質，瞭解到了其實就是一個語法糖，編譯完成之後本質還是一個陣列。它的好處就是當我們不確定集合個數的時候，可以靈活的使用params進行引數傳遞，不用自行定義一個集合型別。然後微軟針對params在內部實現了一個ParamsArray結構體進行對params包裝，提升params型別的訪問。
    新年伊始，聊一點個人針對學習的看法。學習最理想的結果就是把接觸到的知識進行一定的抽象，轉換為概念或者一種思維方式，然後細化這種思維，讓它成為細顆粒度的知識點，然後我們通過不斷的接觸不斷的積累，後者不同領域的接觸等，不斷吸收壯大這個思維庫。然後當看到一個新的問題的時候，或者需要思考的時候，能達到快速的多角度的整合這些思維碎片，得到一個更好的思路或解決問題的辦法，這也許是一種更行之有效的狀態。類比到我們架構設計上來說，以前的思維方式是一種類似單體應用的方式，靈活性差擴充套件性更差，後來微服務概念大行其道，更多獨立的服務相互協調工作，形成一種更強大的聚合力。

?歡迎掃碼關注我的公眾號?