>>>On an afterthought
>>>
>>>>>And if you use 'ref' you are forced to instantiate the objects before the call otherwise it won't compile ; 'out' avoids that....
>>>
>>>Nowhere is it written that you have to instantiate the objects before the call - only that they have to be initialized
>>>
>>>A null value is ok
>>>
>>> static class Test_RefOut
>>> {
>>> internal static void Go()
>>> {
>>> Dictionary<string, string> dict = null;
>>>
>>> int x = GetDictByRef(ref dict);
>>>
>>> Console.WriteLine("result : {0}", dict);
>>> }
>>>
>>> static int GetDictByRef(ref Dictionary<string, string> dict)
>>> {
>>> //dict = new Dictionary<string, string>();
>>> return 2;
>>> }
>>>
>>> }
>>>True. OK - back to message 1583810:
>>" value types : depending on the size of the value type "
>>
>>What if the parameter is a biggish structure. More bytes to pass there. e.g.
public struct LotsOfDoubles
>> {
>> public double a, b, c, d, e, f, g, h, i, j;
>> }>
>
>OK,
>
>
> public struct LotsOfDoubles
> {
> public double a, b, c, d, e, f, g, h, i, j;
> }
>
> static class Test_RefOut
> {
> internal static void Go()
> {
> LotsOfDoubles lod = new LotsOfDoubles();
>
>
> int x = GetLotsOfDoublesByRef(ref lod);
>
> Console.WriteLine("result : {0}", lod);
> }
>
> static int GetLotsOfDoublesByRef(ref LotsOfDoubles lod)
> {
> lod = new LotsOfDoubles();
> lod.a = 1.4;
> lod.b= 1.4;
> lod.c = 1.4;
> lod.d = 1.4;
> lod.e = 1.4;
> lod.f = 1.4;
> lod.g = 1.4;
> lod.h = 1.4;
> lod.i = 1.4;
> lod.j = 1.4;
>
> //dict = new Dictionary<string, string>();
> return 2;
> }
>
> }
>>
>When calling: The local address of LotsOfDoubles is put onto the stack
>In the method called. the address is treated as a struct - the same amount of work it would take to initialize if the calling method
>
>
>No waste - It's only the address that is passed (like the address of an object on the heap would be passed)
>
>
>
>ildasm
>
>So,
> for each field
> load the address of the struct on the stack
> load a constant (1.4 here) on the stack
> store the constant in field x
>
>
>.method private hidebysig static int32 GetLotsOfDoublesByRef(valuetype GregoryAdam.Test.Tests.LotsOfDoubles& lod) cil managed
>{
> // Code size 164 (0xa4)
> .maxstack 2
> .locals init ([0] int32 CS$1$0000)
> IL_0000: nop
> IL_0001: ldarg.0
> IL_0002: initobj GregoryAdam.Test.Tests.LotsOfDoubles
> IL_0008: ldarg.0
> IL_0009: ldc.r8 1.3999999999999999
> IL_0012: stfld float64 GregoryAdam.Test.Tests.LotsOfDoubles::a
> IL_0017: ldarg.0
> IL_0018: ldc.r8 1.3999999999999999
> IL_0021: stfld float64 GregoryAdam.Test.Tests.LotsOfDoubles::b
> IL_0026: ldarg.0
> IL_0027: ldc.r8 1.3999999999999999
> IL_0030: stfld float64 GregoryAdam.Test.Tests.LotsOfDoubles::c
> IL_0035: ldarg.0
> IL_0036: ldc.r8 1.3999999999999999
> IL_003f: stfld float64 GregoryAdam.Test.Tests.LotsOfDoubles::d
> IL_0044: ldarg.0
> IL_0045: ldc.r8 1.3999999999999999
> IL_004e: stfld float64 GregoryAdam.Test.Tests.LotsOfDoubles::e
> IL_0053: ldarg.0
> IL_0054: ldc.r8 1.3999999999999999
> IL_005d: stfld float64 GregoryAdam.Test.Tests.LotsOfDoubles::f
> IL_0062: ldarg.0
> IL_0063: ldc.r8 1.3999999999999999
> IL_006c: stfld float64 GregoryAdam.Test.Tests.LotsOfDoubles::g
> IL_0071: ldarg.0
> IL_0072: ldc.r8 1.3999999999999999
> IL_007b: stfld float64 GregoryAdam.Test.Tests.LotsOfDoubles::h
> IL_0080: ldarg.0
> IL_0081: ldc.r8 1.3999999999999999
> IL_008a: stfld float64 GregoryAdam.Test.Tests.LotsOfDoubles::i
> IL_008f: ldarg.0
> IL_0090: ldc.r8 1.3999999999999999
> IL_0099: stfld float64 GregoryAdam.Test.Tests.LotsOfDoubles::j
> IL_009e: ldc.i4.2
> IL_009f: stloc.0
> IL_00a0: br.s IL_00a2
> IL_00a2: ldloc.0
> IL_00a3: ret
>} // end of method Test_RefOut::GetLotsOfDoublesByRef
>Oh well, another argument bites the dust :-}
What if the called method is in a different app domain ?
IAC, I'd stiil argue that using 'out' rather than 'ref' gives a clear indication to the caller of the behaviour of the method - i.e 'don't bother passing in an object because it don't mean nothin'
