Hallå,

När det gäller att skicka med parametrar till metoder skrivna med c# (såklart eftersom det är i det forumet jag skriver) så kan man ju skicka argument som värde eller också så kan man skicka en variabels referens. Utöver detta så kan man dessutom deklarera en parameter som output.

<code>
public void aName (out string Name)
{
Name = "Thomas";
}
public void ShowName()
{
string Name;
aName(out Name);
Console.Writeline("Dagens namn är " + Name);
}
</code>

Jag tycker att man kan åstadkomma exakt samma möjligheter om man skickar en referensvariabel som parameter i stället.

<code>
public void aName (ref string Name)
{
Name = "Thomas";
}
public void ShowName()
{
// Den här variabeln måste initieras innan den kan skickas som parameter
string Name = "";
aName(ref Name);
Console.Writeline("Dagens namn är " + Name);
}
</code>

Är det någon som har en förklaring till varför man ibland skall behöva använda outputparametrar. Jag menar det måste finnas någon anledning till det eftersom man har implementerat denna möjlighet i c#. I VB.NET så finns inte denna möjlighet kan jag tillägga.

mvh /Thomas

Skillnaden är marginell och finns där av OOP anledningar.

En OUT parameter kan aldrig skicka in data till metoden, vilket ref kan.

Det vill säga du skulle kunna göra:

<code>
public void Inc(ref int number)
{
number++;
}
</code>

men följande skulle inte fungera:
<code>
public void Inc(out int number)
{
number++;
}
</code>

Det gör att JIT compilerna kan direkt anta att ingen data måsta marshalas in i metod anropet, utan bara ut för de argument som har OUT. Medans de som har REF måste använda marshaling båd in och ut i anropet.

Det underlättar anropet. Speciellt om det sträcker sig över process gränser eller ännu värre, maskingränser.

IL koden [1] i sig är ingen större skillnad (om man bortser från de metoder som ropar på out/ref metoderna, där en extra variablen instanciering krävs) Men nativ koden och CLR'ns beteende skiljer sig.



[1]

OUT:
<code>
.method public hidebysig instance void aName([out] string& Name) cil managed
{
// Code size 8 (0x8)
.maxstack 2
IL_0000: ldarg.1
IL_0001: ldstr "Thomas"
IL_0006: stind.ref
IL_0007: ret
}
</code>

REF:
<code>
.method public hidebysig instance void bName(string& Name) cil managed
{
// Code size 8 (0x8)
.maxstack 2
IL_0000: ldarg.1
IL_0001: ldstr "Thomas"
IL_0006: stind.ref
IL_0007: ret
}
</code>

Anropet av de respektive kan oxå se annorlunda ut. Är det en out parameter behöver inte variabeln vara initierad (eller som Patrik påpekar är det ingen poäng med det);

string s;
myFunctionOut(out s);

med ref:

string s = "";
myFunctionRef(ref s);

/peterbladh

Det var ett bra svar som jag skall ha i bakhuvudet. Jag hoppas att det är en teknik som jag någongång kommer att behöva använda, bara för att veta att just det anropet är optimerad till det yttersta :)

thx /Thomas