下面是一个同时使用Ref和out的例子。现在，你们都可以离开裁判了。

在下面提到的例子中，当我注释//myRefObj = new myClass {Name = "ref outside called!! ""}; 行，将得到一个错误说“使用未分配的局部变量'myRefObj'”，但没有这样的错误在out。

在哪里使用Ref:当我们调用带有in形参的过程时，该形参将用于存储该过程的输出。

在哪里使用Out:当我们调用一个没有in形参的过程时，相同的参数将用于返回该过程的值。 还要注意输出

public partial class refAndOutUse : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        myClass myRefObj;
        myRefObj = new myClass { Name = "ref outside called!!  <br/>" };
        myRefFunction(ref myRefObj);
        Response.Write(myRefObj.Name); //ref inside function

        myClass myOutObj;
        myOutFunction(out myOutObj);
        Response.Write(myOutObj.Name); //out inside function
    }

    void myRefFunction(ref myClass refObj)
    {
        refObj.Name = "ref inside function <br/>";
        Response.Write(refObj.Name); //ref inside function
    }
    void myOutFunction(out myClass outObj)
    {
        outObj = new myClass { Name = "out inside function <br/>" }; 
        Response.Write(outObj.Name); //out inside function
    }
}

public class myClass
{
    public string Name { get; set; }
} 

注意，在函数内部传递的引用参数是直接处理的。

例如,

    public class MyClass
    {
        public string Name { get; set; }
    }

    public void Foo()
    {
        MyClass myObject = new MyClass();
        myObject.Name = "Dog";
        Bar(myObject);
        Console.WriteLine(myObject.Name); // Writes "Dog".
    }

    public void Bar(MyClass someObject)
    {
        MyClass myTempObject = new MyClass();
        myTempObject.Name = "Cat";
        someObject = myTempObject;
    }

这会写狗，而不是猫。因此，您应该直接在someObject上工作。

下面是一个同时使用Ref和out的例子。现在，你们都可以离开裁判了。

在下面提到的例子中，当我注释//myRefObj = new myClass {Name = "ref outside called!! ""}; 行，将得到一个错误说“使用未分配的局部变量'myRefObj'”，但没有这样的错误在out。

在哪里使用Ref:当我们调用带有in形参的过程时，该形参将用于存储该过程的输出。

在哪里使用Out:当我们调用一个没有in形参的过程时，相同的参数将用于返回该过程的值。 还要注意输出

public partial class refAndOutUse : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        myClass myRefObj;
        myRefObj = new myClass { Name = "ref outside called!!  <br/>" };
        myRefFunction(ref myRefObj);
        Response.Write(myRefObj.Name); //ref inside function

        myClass myOutObj;
        myOutFunction(out myOutObj);
        Response.Write(myOutObj.Name); //out inside function
    }

    void myRefFunction(ref myClass refObj)
    {
        refObj.Name = "ref inside function <br/>";
        Response.Write(refObj.Name); //ref inside function
    }
    void myOutFunction(out myClass outObj)
    {
        outObj = new myClass { Name = "out inside function <br/>" }; 
        Response.Write(outObj.Name); //out inside function
    }
}

public class myClass
{
    public string Name { get; set; }
} 

out:

在c#中，一个方法只能返回一个值。如果希望返回多个值，可以使用out关键字。out修饰符返回为return-by-reference。最简单的答案是使用关键字“out”从方法中获取值。

您不需要在调用函数中初始化该值。 必须在被调用的函数中赋值，否则编译器将报错。

ref:

在c#中，当你将一个值类型，如int, float, double等作为参数传递给方法参数时，它是按值传递的。因此，如果修改形参值，它不会影响方法调用中的实参。但是，如果您用“ref”关键字标记参数，它将反映在实际的变量中。

在调用函数之前，需要初始化变量。 为方法中的ref参数赋值不是强制的。如果不更改值，为什么需要将其标记为“ref”?

 public static void Main(string[] args)
    {
        //int a=10;
        //change(ref a);
        //Console.WriteLine(a);
        // Console.Read();

        int b;
        change2(out b);
        Console.WriteLine(b);
        Console.Read();
    }
    // static void change(ref int a)
    //{
    //    a = 20;
    //}

     static void change2(out int b)
     {
         b = 20;
     }

你可以检查这段代码，它会向你描述它的完全不同 当你使用“ref”时，这意味着你已经初始化了int/string

但 当你使用out的时候 无论你是否初始化int/string，它都适用于这两种情况 但是u必须在函数中初始化int/string

Ref和out的行为类似，只是有一些不同。

引用变量必须在使用前初始化。Out变量无需赋值即可使用 Out形参必须被使用它的函数视为未赋值。因此，我们可以在调用代码中使用初始化的out形参，但该值将在函数执行时丢失。