在c#中，我一直认为非基本变量是通过引用传递的，而基本值是通过值传递的。
因此，当向一个方法传递任何非基本对象时，在方法中对该对象所做的任何操作都会影响正在传递的对象。(c# 101的东西)
然而，我已经注意到，当我传递一个System.Drawing.Image对象，这似乎不是这样的情况?如果我将system。drawing。image对象传递给另一个方法，并将图像加载到该对象上，然后让该方法超出作用域并返回调用方法，图像没有加载到原始对象上?
为什么会这样?
当前回答
在Pass By Reference中，只在函数参数和一个参数中添加“ref” 更多的事情你应该声明函数“static”，因为main是静态的(#public void main(String[] args))!
namespace preparation
{
public class Program
{
public static void swap(ref int lhs,ref int rhs)
{
int temp = lhs;
lhs = rhs;
rhs = temp;
}
static void Main(string[] args)
{
int a = 10;
int b = 80;
Console.WriteLine("a is before sort " + a);
Console.WriteLine("b is before sort " + b);
swap(ref a, ref b);
Console.WriteLine("");
Console.WriteLine("a is after sort " + a);
Console.WriteLine("b is after sort " + b);
}
}
}
其他回答
当你将System.Drawing.Image类型对象传递给一个方法时，你实际上是在传递该对象引用的副本。
如果在这个方法中你要加载一个新图像你是在使用new/ replicated reference来加载。你没有改变原来的样子。
YourMethod(System.Drawing.Image image)
{
//now this image is a new reference
//if you load a new image
image = new Image()..
//you are not changing the original reference you are just changing the copy of original reference
}
我想当你这样做的时候会更清楚。我建议下载LinqPad来测试这样的事情。
void Main()
{
var Person = new Person(){FirstName = "Egli", LastName = "Becerra"};
//Will update egli
WontUpdate(Person);
Console.WriteLine("WontUpdate");
Console.WriteLine($"First name: {Person.FirstName}, Last name: {Person.LastName}\n");
UpdateImplicitly(Person);
Console.WriteLine("UpdateImplicitly");
Console.WriteLine($"First name: {Person.FirstName}, Last name: {Person.LastName}\n");
UpdateExplicitly(ref Person);
Console.WriteLine("UpdateExplicitly");
Console.WriteLine($"First name: {Person.FirstName}, Last name: {Person.LastName}\n");
}
//Class to test
public class Person{
public string FirstName {get; set;}
public string LastName {get; set;}
public string printName(){
return $"First name: {FirstName} Last name:{LastName}";
}
}
public static void WontUpdate(Person p)
{
//New instance does jack...
var newP = new Person(){FirstName = p.FirstName, LastName = p.LastName};
newP.FirstName = "Favio";
newP.LastName = "Becerra";
}
public static void UpdateImplicitly(Person p)
{
//Passing by reference implicitly
p.FirstName = "Favio";
p.LastName = "Becerra";
}
public static void UpdateExplicitly(ref Person p)
{
//Again passing by reference explicitly (reduntant)
p.FirstName = "Favio";
p.LastName = "Becerra";
}
然后输出
WontUpdate
名:Egli，姓:Becerra
更新隐式
名:法维奥，姓:贝塞拉
UpdateExplicitly
名:法维奥，姓:贝塞拉
还有一个代码示例可以展示这一点:
void Main()
{
int k = 0;
TestPlain(k);
Console.WriteLine("TestPlain:" + k);
TestRef(ref k);
Console.WriteLine("TestRef:" + k);
string t = "test";
TestObjPlain(t);
Console.WriteLine("TestObjPlain:" +t);
TestObjRef(ref t);
Console.WriteLine("TestObjRef:" + t);
}
public static void TestPlain(int i)
{
i = 5;
}
public static void TestRef(ref int i)
{
i = 5;
}
public static void TestObjPlain(string s)
{
s = "TestObjPlain";
}
public static void TestObjRef(ref string s)
{
s = "TestObjRef";
}
输出:
测试平原：0 测试参考：5 TestObjPlain：test TestObjRef：TestObjRef
在c#的最新版本，即编写本文时的c# 9中，对象默认通过ref传递。因此，对调用函数中的对象所做的任何更改都将持久化在被调用函数中的对象中。
在Pass By Reference中，只在函数参数和一个参数中添加“ref” 更多的事情你应该声明函数“static”，因为main是静态的(#public void main(String[] args))!
namespace preparation
{
public class Program
{
public static void swap(ref int lhs,ref int rhs)
{
int temp = lhs;
lhs = rhs;
rhs = temp;
}
static void Main(string[] args)
{
int a = 10;
int b = 80;
Console.WriteLine("a is before sort " + a);
Console.WriteLine("b is before sort " + b);
swap(ref a, ref b);
Console.WriteLine("");
Console.WriteLine("a is after sort " + a);
Console.WriteLine("b is after sort " + b);
}
}
}
