в 15:31, 26 мая 2010

2010-05-26T15:31:53Z

Admin: 1 версия

2010-05-26T12:19:18Z

1 версия

Новая страница

==Change string using ref keyword==

<source lang="csharp">using System;
class MainClass
{
public static void UpperCaseThisString(ref string s)
{
s = s.ToUpper();
}
public static void Main()
{
string s = "str";
Console.WriteLine("-> Before: {0}", s);
UpperCaseThisString(ref s);
Console.WriteLine("-> After: {0}\n", s);
}
}</source>
<pre class=codeResult>-> Before: str
-> After: STR</pre>

==Passing Parameters by Value==

<source lang="csharp">public class Swapper {
public void Swap(int x, int y) {
System.Console.WriteLine("In Swap(): initial x = " + x + ", y = " + y);
int temp = x;
x = y;
y = temp;
System.Console.WriteLine("In Swap(): final x = " + x + ", y = " + y);
}
}

class MainClass {
public static void Main() {
int x = 2;
int y = 5;
System.Console.WriteLine("In Main(): initial x = " + x + ", y = " + y);
Swapper mySwapper = new Swapper();
mySwapper.Swap(x, y);
System.Console.WriteLine("In Main(): final x = " + x + ", y = " + y);
}
}</source>

==Swap two references.==

<source lang="csharp">using System;

class RefSwap {
int a, b;

public RefSwap(int i, int j) {
a = i;
b = j;
}

public void show() {
Console.WriteLine("a: {0}, b: {1}", a, b);
}

// This method changes its arguments.
public void swap(ref RefSwap ob1, ref RefSwap ob2) {
RefSwap t;

t = ob1;
ob1 = ob2;
ob2 = t;
}
}

class MainClass {
public static void Main() {
RefSwap x = new RefSwap(1, 2);
RefSwap y = new RefSwap(3, 4);

Console.Write("x before call: ");
x.show();

Console.Write("y before call: ");
y.show();

Console.WriteLine();

// exchange the objects to which x and y refer
x.swap(ref x, ref y);

Console.Write("x after call: ");
x.show();

Console.Write("y after call: ");
y.show();

}
}</source>
<pre class=codeResult>x before call: a: 1, b: 2
y before call: a: 3, b: 4
x after call: a: 3, b: 4
y after call: a: 1, b: 2</pre>

==Swap two values==

<source lang="csharp">using System;

class Swap {
// This method now changes its arguments.
public void swap(ref int a, ref int b) {
int t;

t = a;
a = b;
b = t;
}
}

class MainClass {
public static void Main() {
Swap ob = new Swap();

int x = 10, y = 20;

Console.WriteLine("x and y before call: " + x + " " + y);

ob.swap(ref x, ref y);

Console.WriteLine("x and y after call: " + x + " " + y);
}
}</source>
<pre class=codeResult>x and y before call: 10 20
x and y after call: 20 10</pre>

==Use out for reference type==

<source lang="csharp">using System;
class MyClass
{
public int Val = 20;
}
class MainClass
{
static void MyMethod(out MyClass f1, out int f2)
{
f1 = new MyClass();
f1.Val = 25;
f2 = 15;
}
static void Main()
{
MyClass myObject = null;
int intValue;
MyMethod(out myObject, out intValue);
Console.WriteLine("After -- myObject.Val: {0}, intValue: {1}", myObject.Val, intValue);
}
}</source>
<pre class=codeResult>After -- myObject.Val: 25, intValue: 15</pre>

==Use ref for int value==

<source lang="csharp">using System;

class MyClass
{
public int Val = 20;
}
class MainClass
{
static void MyMethod(ref MyClass myObject, ref int intValue)
{
myObject.Val = myObject.Val + 5;
intValue = intValue + 5;
}
static void Main()
{
MyClass myObject = new MyClass();
int intValue = 10;
Console.WriteLine("Before -- myObject.Val: {0}, intValue: {1}", myObject.Val, intValue);
MyMethod(ref myObject, ref intValue);
Console.WriteLine("After -- myObject.Val: {0}, intValue: {1}", myObject.Val, intValue);
}
}</source>
<pre class=codeResult>Before -- myObject.Val: 20, intValue: 10
After -- myObject.Val: 25, intValue: 15</pre>

==Use ref for reference type==

<source lang="csharp">using System;

class MyClass
{
public int Val = 20;
}
class MainClass
{
static void MyMethod(ref MyClass myObject, ref int intValue)
{
myObject.Val = myObject.Val + 5;
intValue = intValue + 5;
}
static void Main()
{
MyClass myObject = new MyClass();
int intValue = 10;
Console.WriteLine("Before -- myObject.Val: {0}, intValue: {1}", myObject.Val, intValue);
MyMethod(ref myObject, ref intValue);
Console.WriteLine("After -- myObject.Val: {0}, intValue: {1}", myObject.Val, intValue);
}
}</source>
<pre class=codeResult>Before -- myObject.Val: 20, intValue: 10
After -- myObject.Val: 25, intValue: 15</pre>

==Use ref to pass a value type by reference==

<p>The ref parameter modifier causes C# to create a call-by-reference, rather than a call-by-value.</p>

<source lang="csharp">using System;

class RefTest {
/* This method changes its argument.
Notice the use of ref. */
public void sqr(ref int i) {
i = i * i;
}
}

class MainClass {
public static void Main() {
RefTest ob = new RefTest();

int a = 10;

Console.WriteLine("a before call: " + a);

ob.sqr(ref a); // notice the use of ref

Console.WriteLine("a after call: " + a);
}
}</source>
<pre class=codeResult>a before call: 10
a after call: 100</pre>

← Предыдущая	Версия 15:31, 26 мая 2010
(нет различий)

Csharp/CSharp Tutorial/Language Basics/ref - История изменений

в 15:31, 26 мая 2010

Admin: 1 версия