A. ref介面是什麼功能
ref介面功能是為React提供的用來操縱React組件實例或者DOM元素的介面，可以在DOM中的某些元素被增加或刪除的時候幫助React識別哪些元素發生了變化，因此應當給數組中的每一個元素賦予一個確定的標識。
React是用於構建用戶界面的JavaScript庫，起源於Facebook的內部項目，該公司對市場上所有 JavaScript MVC框架都不滿意，決定自行開發一套，用於架設Instagram的網站，於2013年5月開源。
產生背景
由於 React的設計思想極其獨特，屬於革命性創新，性能出眾，代碼邏輯卻非常簡單。所以，越來越多的人開始關注和使用，認為它可能是將來 Web 開發的主流工具。
這個項目本身也越滾越大，從最早的UI引擎變成了一整套前後端通吃的 Web App 解決方案。衍生的 React Native 項目，目標更是宏偉，希望用寫 Web App 的方式去寫 Native App。
以上內容參考網路-react
B. c語言中out和ref的區別是什麼
ref：相當於c語言的引用參數 實參和形參一起變。
out：多用於輸出參數 就是在return之前必須給out標示的參數賦值。
C. REF是什麼意思
REF是Reference的縮寫，為參考尺寸的意思。
參考尺寸依ASME Y14.5上的定義是:在別處已有標示的尺寸,為了看圖人的方便,在其他位置重復標示的尺寸。可以由現有尺寸計算出來的尺寸,但也是為了看圖人的方便,而標示的尺寸。參考尺寸是不可量測的。
(3)c語言中ref功能擴展閱讀：
尺寸標注基本規則：
1、機件的真實大小應以圖樣上所注的尺寸數值為依據，與圖形的大小及繪圖的准確度無關。
2、尺寸，以毫米為單位時，不需標注計量單位的代號或名稱，如採用其他單位，則必須註明相應的計量單位的代號或名稱。
3、機件的每一尺寸，一般只標注一次，並應標注在反映該結構最清晰的圖形上。
D. c#中Swap方法是干什麼用的ref關鍵字的特點是什麼
ref是引用傳遞的意思，有點類似於C語言中使用指針來進行變數地址傳遞的形勢。
Swap是交換的意思，我估計樓主是不是看錯了，這個方法應該是在講ref的時候自己寫的一個方法，不是C#的庫方法
E. c# 程序中關於ref 和out 參數問題
out 關鍵字會導致參數通過引用來傳遞。這與 ref 關鍵字類似，不同之處在於 ref 要求變數必須在傳遞之前進行初始化。若要使用 out 參數，方法定義和調用方法都必須顯式使用 out 關鍵字。例如：class OutExample
{
static void Method(out int i)
{
i = 44;
}
static void Main()
{
int value;
Method(out value);
// value is now 44
}
盡管作為 out 參數傳遞的變數不需要在傳遞之前進行初始化，但需要調用方法以便在方法返回之前賦值。
ref 和 out 關鍵字在運行時的處理方式不同，但在編譯時的處理方式相同。因此，如果一個方法採用 ref 參數，而另一個方法採用 out 參數，則無法重載這兩個方法。但是，如果一個方法採用 ref 或 out 參數，而另一個方法不採用這兩類參數，則可以進行重載。
示例：
當希望方法返回多個值時，聲明 out 方法很有用。使用 out 參數的方法仍然可以將變數用作返回類型（請參見 return），但它還可以將一個或多個對象作為 out 參數返回給調用方法。此示例使用 out 在一個方法調用中返回三個變數。請注意，第三個參數所賦的值為 Null。這樣便允許方法有選擇地返回值。
class OutReturnExample
{
static void Method(out int i, out string s1, out string s2)
{
i = 44;
s1 = "I''ve been returned";
s2 = null;
}
static void Main()
{
int value;
string str1, str2;
Method(out value, out str1, out str2);
// value is now 44
// str1 is now "I''ve been returned"
// str2 is (still) null;
}
}
如果在函數體內不對參數開辟新的內存（即重新實例化），那麼用不用out或ref是一樣的（string類除外，好像string類的操作更像值類型）；如果在函數內部要對參數重新實例化，就需要用ref或out了，因為如果不用ref或out的時候，參數實際上傳的是對象引用的一個拷貝（就像c語言里船隻真參數實際上也是傳的指針的拷貝一樣），對原來對象的操作就能對對象進行修改，如果要new一個實例的話，只是這個拷貝指向這塊內存，而原來的對象引用還是指向原來的內存空間。況且參數的生存期只在函數體內，出了函數對他分配的內存也應該被回收。
C# 中，既可以通過值也可以通過引用傳遞參數。通過引用傳遞參數允許函數成員更改參數的值，並保持該更改。若要通過引用傳遞參數， 可使用ref或out關鍵字。ref和out這兩個關鍵字都能夠提供相似的功效，其作用也很像C中的指針變數。它們的區別是：
1、使用ref型參數時，傳入的參數必須先被初始化。對out而言，必須在方法中對其完成初始化。
2、使用ref和out時，在方法的參數和執行方法時，都要加Ref或Out關鍵字。以滿足匹配。
3、out適合用在需要retrun多個返回值的地方，而ref則用在需要被調用的方法修改調用者的引用的時候。
註：在C#中，方法的參數傳遞有四種類型：傳值（by value），傳址（by reference），輸出參數（by output），數組參數（by array）。傳值參數無需額外的修飾符，傳址參數需要修飾符ref，輸出參數需要修飾符out，數組參數需要修飾符params。傳值參數在方法調用過程中如果改變了參數的值，那麼傳入方法的參數在方法調用完成以後並不因此而改變，而是保留原來傳入時的值。傳址參數恰恰相反，如果方法調用過程改變了參數的值，那麼傳入方法的參數在調用完成以後也隨之改變。實際上從名稱上我們可以清楚地看出兩者的含義--傳值參數傳遞的是調用參數的一份拷貝，而傳址參數傳遞的是調用參數的內存地址，該參數在方法內外指向的是同一個存儲位置。
方法參數上的 ref 方法參數關鍵字使方法引用傳遞到方法的同一個變數。當控制傳遞回調用方法時，在方法中對參數所做的任何更改都將反映在該變數中。
若要使用 ref 參數，必須將參數作為 ref 參數顯式傳遞到方法。ref 參數的值被傳遞到 ref 參數。
傳遞到 ref 參數的參數必須最先初始化。將此方法與 out 參數相比，後者的參數在傳遞到 out 參數之前不必顯式初始化。
屬性不是變數，不能作為 ref 參數傳遞。
如果兩種方法的聲明僅在它們對 ref 的使用方面不同，則將出現重載。但是，無法定義僅在 ref 和 out 方面不同的重載。
out
方法參數上的 out 方法參數關鍵字使方法引用傳遞到方法的同一個變數。當控制傳遞回調用方法時，在方法中對參數所做的任何更改都將反映在該變數中。
當希望方法返回多個值時，聲明 out 方法非常有用。使用 out 參數的方法仍然可以返回一個值。一個方法可以有一個以上的 out 參數。
若要使用 out 參數，必須將參數作為 out 參數顯式傳遞到方法。out 參數的值不會傳遞到 out 參數。
不必初始化作為 out 參數傳遞的變數。然而，必須在方法返回之前為 out 參數賦值。
屬性不是變數，不能作為 out 參數傳遞。
http://msdn.microsoft.com/zh-cn/library/szasx730.aspx
F. 這個ref要怎麼理解
使用了Ref和Out的效果就幾乎和C中使用了指針變數一樣。它能夠讓你直接對原數進行操作，而不是對那個原數的Copy進行操作。舉個小例子：
using System;
namespace ConsoleApplication4
{
///
/// Class1 的摘要說明。
///
class Class1
{
///
/// 應用程序的主入口點。
///
[STAThread]
static void Main(string[] args)
{
int a = 5;
int b;
squareRef(ref a);
squareOut(out b);
Console.WriteLine("The a in the Main is: " + a);
Console.WriteLine("The b in the Main is: " + b);
}
static void squareRef(ref int x)
{
x = x * x;
Console.WriteLine("The x in the squareRef is: " + x);
}
static void squareOut(out int y)
{
y = 10;
y = y * y;
Console.WriteLine("The y in the squareOut is: " + y);
}
}
}
顯示的結果就是——25 100 25 100。
這樣的話，就達到了和C中的指針變數一樣的作用。
顯示的結果就是——25 100 25 100。
這樣的話，就達到了和C中的指針變數一樣的作用。
對於引用類型。
對於引用類型就比較難理解了。
先要了解到這一層——就是當一個方法接收到一個引用類型的變數的時候，它將獲得這個引用（Reference）的一個Copy。由於Ref關鍵字可以用來向方法傳遞引用。所以，如果這個功能被誤用了——比如：當一個如數組類型的引用對象用關鍵字Ref傳遞的時候，被調用的方法實際上已經控制了傳遞過來的引用本身。這樣將使得被調用方法能用不同的對象甚至NULL來代替調用者的原始引用！
如圖。內存地址為2000的變數arrayA中其實存放著數組{1，2，3，4，……}的內存起始地址10000。如果一個方法fun()使用fun( arrayA[] )的話，它將順利的獲得數據10000，但這個10000將放在一個Copy中，不會放到內存的2000位置。而這個時候我們如果使用fun( ref arrayA[] )的話，我們得到的值就是2000啦（也就是說，被調用方法能夠修改掉arrayA中的那個引用，使之不再指向10000，甚至可以用NULL來代替10000，這樣的話，那個10000地址中的數據可能就要被垃圾回收機制清理了。）
有個例子：
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
namespace RefOut
{
///
/// Form1 的摘要說明。
///
public class Form1 : System.Windows.Forms.Form
{
private System.Windows.Forms.Button button1;
private System.Windows.Forms.Label label1;
///
/// 必需的設計器變數。
///
private System.ComponentModel.Container components = null;
public Form1()
{
//
// Windows 窗體設計器支持所必需的
//
InitializeComponent();
//
// TODO: 在 InitializeComponent 調用後添加任何構造函數代碼
//
}
///
/// 清理所有正在使用的資源。
///
protected override void Dispose( bool disposing )
{
if( disposing )
{
if (components != null)
{
components.Dispose();
}
}
base.Dispose( disposing );
}
#region Windows 窗體設計器生成的代碼
///
/// 設計器支持所需的方法 - 不要使用代碼編輯器修改
/// 此方法的內容。
///
private void InitializeComponent()
{
this.button1 = new System.Windows.Forms.Button();
this.label1 = new System.Windows.Forms.Label();
this.SuspendLayout();
//
// button1
//
this.button1.Dock = System.Windows.Forms.DockStyle.Top;
this.button1.Location = new System.Drawing.Point(0, 0);
this.button1.Name = "button1";
this.button1.Size = new System.Drawing.Size(480, 32);
this.button1.TabIndex = 0;
this.button1.Text = "顯示輸出";
this.button1.Click += new System.EventHandler(this.button1_Click);
//
// label1
//
this.label1.Location = new System.Drawing.Point(8, 48);
this.label1.Name = "label1";
this.label1.Size = new System.Drawing.Size(456, 336);
this.label1.TabIndex = 1;
this.label1.Text = "label1";
//
// Form1
//
this.AutoScaleBaseSize = new System.Drawing.Size(6, 14);
this.ClientSize = new System.Drawing.Size(480, 405);
this.Controls.Add(this.label1);
this.Controls.Add(this.button1);
this.MaximizeBox = false;
this.MinimizeBox = false;
this.Name = "Form1";
this.Text = "Ref & Out";
this.ResumeLayout(false);
}
#endregion
///
/// 應用程序的主入口點。
///
[STAThread]
static void Main()
{
Application.Run(new Form1());
}
private void button1_Click(object sender, System.EventArgs e)
{
int[] firstArray = {1, 2, 3};
int[] firstArrayCopy = firstArray;
this.label1.Text = "Test Passing firstArray reference by value";
this.label1.Text += "\n\nContents of firstArray before calling FirstDouble:\n\t";
for(int i = 0;i < firstArray.Length; i++)
{
this.label1.Text += firstArray[i] + " ";
}
FirstDouble(firstArray);
this.label1.Text += "\n\nContents of firstArray after calling FirstDouble.\n\t";
for(int i=0;i {
this.label1.Text += firstArray[i] + " ";
}
if(firstArray == firstArrayCopy)
this.label1.Text +="\n\nThe references refer to the same array.\n";
else
this.label1.Text +="\n\nThe reference refer to different arrays.\n";
int[] secondArray = {1, 2, 3};
int[] secondArrayCopy = secondArray;
this.label1.Text += "\nTest passing secondArray reference by reference.";
this.label1.Text += "\n\nContents of secondArray before calling SecondDouble:\n\t";
for(int i=0;i {
this.label1.Text += secondArray[i] + " ";
}
SecondDouble(ref secondArray);
this.label1.Text +="\n\nContents of secondArray after calling SecondDouble:\n\t";
for(int i=0; i {
this.label1.Text += secondArray[i] + " ";
}
if(secondArray== secondArrayCopy)
this.label1.Text += "\n\nThe reference refer to the same array.";
else
this.label1.Text += "\n\nThe reference refer to different arrays.";
this.label1.Text += "\n___________________heshi_________________\nsecondarray\n";
for(int i = 0;i {
this.label1.Text += secondArray[i] + " ";
}
this.label1.Text +="\nsecondarray\n";
for(int i=0;i {
this.label1.Text += secondArrayCopy[i] + " ";
}
}
void FirstDouble(int[] array)
{
for(int i = 0;i array[i] *= 2;
array = new int[] {11, 12, 13};
}
void SecondDouble(ref int[] array)
{
for(int i=0;i {
array[i] *= 2;
}
array = new int[] {11, 12, 13};
}
}
}運行後的結果是：
這個就說明了被調用的程序已經改變了原有的Reference。
總結
總的說來，Ref和Out這兩個關鍵字都能夠提供相似的功效，其作用也很像C中的指針變數。稍有不同之處是：
使用Ref型參數時，傳入的參數必須先被初始化。而Out則不需要，對Out而言，就必須在方法中對其完成初始化。
使用Ref和Out時都必須注意，在方法的參數和執行方法時，都要加Ref或Out關鍵字。以滿足匹配。
Out更適合用在需要Return多個返回值的地方，而Ref則用在需要被調用的方法修改調用者的引用的時候。
G. C#中ref，out類型參數的區別和params類型參數的用法
ref，out類型參數的區別:
ref用法等價於引用類型參數，它可以把值類型的參數通過地址引用的方式傳入函數里，在函數內進行運算後會改變函數外的該值類型實參的值。ref和out的主要區別在於非out參數在使用之前必須賦值，而out參數則是在方法結束之前必須對其經行賦值。
params類型參數的用法
這里的params類型其實只的就是一個參數數組，這個數組按該方法中規定的一定排序規則排序，然後方法中對應參數數組的對應項來決定如何執行，其主要的功能就是不限制方法的參數個數。
H. C#中out和ref之間的區別
ref和out都是C#中的關鍵字，所實現的功能也差不多，都是指定一個參數按照引用傳遞。
對於編譯後的程序而言，它們之間沒有任何區別，也就是說它們只有語法區別。
總結起來，他們有如下語法區別：
1、ref傳進去的參數必須在調用前初始化，out不必，即：
int i;
SomeMethod( ref i );//語法錯誤
SomeMethod( out i );//通過
2、ref傳進去的參數在函數內部可以直接使用，而out不可：
public void SomeMethod(ref int i)
{
int j=i;//通過
//...
}
public void SomeMethod(out int i)
{
int j=i;//語法錯誤
}
3、ref傳進去的參數在函數內部可以不被修改，但out必須在離開函數體前進行賦值。
ref在參數傳遞之前必須初始化；而out則在傳遞前不必初始化，且在 ... 值類型與引用類型之間的轉換過程稱為裝箱與拆箱。
總結：
應該說，系統對ref的限制是更少一些的。out雖然不要求在調用前一定要初始化，但是其值在函數內部是不可見的，也就是不能使用通過out傳進來的值，並且一定要在函數內賦一個值。或者說函數承擔初始化這個變數的責任。
下面談談ref和out到底有什麼區別：
1 關於重載
原則：有out|ref關鍵字的方法可以與無out和ref關鍵字的方法構成重載；但如想在out和ref間重載，編譯器將提示：不能定義僅在ref和out的上的方法重載
2 關於調用前初始值
原則：ref作為參數的函數在調用前，實參必須賦初始值。否則編譯器將提示：使用了未賦值的局部變數；
out作為參數的函數在調用前，實參可以不賦初始值。
3 關於在函數內，引入的參數初始值問題
原則：在被調用函數內，out引入的參數在返回前至少賦值一次，否則編譯器將提示：使用了未賦值的out參數;
在被調用函數內，ref引入的參數在返回前不必為其賦初值。
總結：C#中的ref和out提供了值類型按引用進行傳遞的解決方案，當然引用類型也可以用ref和out修飾,但這樣已經失去了意義。因為引用數據類型本來就是傳遞的引用本身而非值的拷貝。ref和out關鍵字將告訴編譯器，現在傳遞的是參數的地址而不是參數本身，這和引用類型默認的傳遞方式是一樣的。同時，編譯器不允許out和ref之間構成重載，又充分說明out和ref的區別僅是編譯器角度的，他們生成的IL代碼是一樣的。有人或許疑問，和我剛開始學習的時候一樣的疑惑：值類型在託管堆中不會分配內存，為什麼可以按地址進行傳遞呢？值類型雖然活在線程的堆棧中，它本身代表的就是數據本身(而區別於引用數據類型本身不代表數據而是指向一個內存引用),但是值類型也有它自己的地址，即指針，現在用ref和out修飾後，傳遞的就是這個指針，所以可以實現修改後a，b的值真正的交換。這就是ref和out給我們帶來的好處。
首先：兩者都是按地址傳遞的，使用後都將改變原來參數的數值。
其次：rel可以把參數的數值傳遞進函數，但是out是要把參數清空，就是說你無法把一個數值從out傳遞進去的，out進去後，參數的數值為空，所以你必須初始化一次。這個就是兩個的區別，或者說就像有的網友說的，rel是有進有出，out是只出不進。
ref（C# 參考）
ref 關鍵字使參數按引用傳遞。其效果是，當控制權傳遞回調用方法時，在方法中對參數的任何更改都將反映在該變數中。若要使用 ref 參數，則方法定義和調用方法都必須顯式使用 ref 關鍵字。
例如：
class RefExample
{
static void Method(ref int i)
{
i = 44;
}
static void Main()
{
int val = 0;
Method(ref val);
// val is now 44
}
}
傳遞到 ref 參數的參數必須最先初始化。這與 out 不同，後者的參數在傳遞之前不需要顯式初始化。
盡管 ref 和 out 在運行時的處理方式不同，但在編譯時的處理方式相同。因此，如果一個方法採用 ref 參數，而另一個方法採用 out 參數，則無法重載這兩個方法。例如，從編譯的角度來看，以下代碼中的兩個方法是完全相同的，因此將不會編譯以下代碼：
class CS0663_Example
{
// Compiler error CS0663: "cannot define overloaded
// methods that differ only on ref and out".
public void SampleMethod(ref int i) { }
public void SampleMethod(out int i) { }
}
但是，如果一個方法採用 ref 或 out 參數，而另一個方法不採用這兩個參數，則可以進行重載，如下例所示：
class RefOutOverloadExample
{
public void SampleMethod(int i) { }
public void SampleMethod(ref int i) { }
}
out（C# 參考）
out 關鍵字會導致參數通過引用來傳遞。這與 ref 關鍵字類似，不同之處在於 ref 要求變數必須在傳遞之前進行初始化。若要使用 out 參數，方法定義和調用方法都必須顯式使用 out 關鍵字。
例如：
class OutExample
{
static void Method(out int i)
{
i = 44;
}
static void Main()
{
int value;
Method(out value);
// value is now 44
}
}
盡管作為 out 參數傳遞的變數不必在傳遞之前進行初始化，但需要調用方法以便在方法返回之前賦值。
ref 和 out 關鍵字在運行時的處理方式不同，但在編譯時的處理方式相同。因此，如果一個方法採用 ref 參數，而另一個方法採用 out 參數，則無法重載這兩個方法。例如，從編譯的角度來看，以下代碼中的兩個方法是完全相同的，因此將不會編譯以下代碼：
class CS0663_Example
{
// Compiler error CS0663: "Cannot define overloaded
// methods that differ only on ref and out".
public void SampleMethod(out int i) { }
public void SampleMethod(ref int i) { }
}
但是，如果一個方法採用 ref 或 out 參數，而另一個方法不採用這兩類參數，則可以進行重載，如下所示：
class RefOutOverloadExample
{
public void SampleMethod(int i) { }
public void SampleMethod(out int i) { }
}