Passing by reference twice

[tshad]

If I am passing a variable by reference to another routine by reference, do
I need to dereference first?

string testString;
....

FirstSub(ref firstString)
{
HandleString(re f firstString); //do I need to de
reference here or just pass theString without the "ref"
}
void HandleString(re f theString)
{
Console.WriteLi ne(thestring);
}

[Michael C]

"tshad" <ts**********@f tsolutions.com> wrote in message
news:Oc******** ******@TK2MSFTN GP05.phx.gbl...

If I am passing a variable by reference to another routine by reference,
do I need to dereference first?

string testString;
...

FirstSub(ref firstString)
{
HandleString(re f firstString); //do I need to de
reference here or just pass theString without the "ref"
}
void HandleString(re f theString)
{
Console.WriteLi ne(thestring);
}
No, but why pass it a ref?

[tshad]

Because I am building the string in another function which can get fairly
large and I don't want to pass the actual string which will get very large.

It does seem to work now and I am not sure what I was doing that was causing
the problem. The example actually work.

I am curious as to why it work, however.

If I have testString and I pass it as a reference to FirstSub, then it has
the reference to testString (not the string itself). When I pass it to
HandleString, aren't I passing a reference to a reference of testString?

If that is the case, how does HandleString handle it correctly?

Thanks,

Tom

"Michael C" <no****@nospam. com> wrote in message
news:u4******** ******@TK2MSFTN GP03.phx.gbl...

"tshad" <ts**********@f tsolutions.com> wrote in message
news:Oc******** ******@TK2MSFTN GP05.phx.gbl...

If I am passing a variable by reference to another routine by reference,
do I need to dereference first?

string testString;
...
FirstSub(ref testString);

void FirstSub(ref firstString) {
HandleString(re f firstString); //do I need to de
reference here or just pass theString without the "ref"
}
void HandleString(re f theString)
{
Console.WriteLi ne(thestring);
}

No, but why pass it a ref?

[Michael C]

"tshad" <ts**********@f tsolutions.com> wrote in message
news:Ol******** ******@TK2MSFTN GP02.phx.gbl...

Because I am building the string in another function which can get fairly
large and I don't want to pass the actual string which will get very
large.
C# doesn't copy the entire string when passing it by value. It's a reference
type so only a pointer to it will be passed anyway. You only need to pass a
reference if you want to modify the string.
If that is the case, how does HandleString handle it correctly?

It probably just passes on the pointer it has.

Michael

[Mike]

"Michael C" <no****@nospam. com> wrote in message
news:uT******** *****@TK2MSFTNG P02.phx.gbl...

"tshad" <ts**********@f tsolutions.com> wrote in message
news:Ol******** ******@TK2MSFTN GP02.phx.gbl...

Because I am building the string in another function which can get fairly
large and I don't want to pass the actual string which will get very
large.
C# doesn't copy the entire string when passing it by value. It's a
reference type so only a pointer to it will be passed anyway. You only
need to pass a reference if you want to modify the string.

As strings are immutable in C#, in neither case (ref or not) is it possible
for you to modify a string.
If it's passed by ref, you can modify the reference that the caller has
passed to a new string, but you still can not change the existing string.
If you want to actually "modify a string", pass a StringBuilder or char[]
instead.

m

If that is the case, how does HandleString handle it correctly?

It probably just passes on the pointer it has.

Michael

[Mart]

Hi,

In .NET, String is a Reference Type. It is allocated on the heap, and
the variable that you've declared (testString) contains it's address (a
pointer to it). This means that you will always be passing some form of
reference to the instance rather than the instance itself, whether you
pass the testString variable by ref or by value -- so I'm not sure that
you need to put the 'ref' bit in.

If testString was a Value Type, then adding ref would give you the same
behaviour as when you pass a Reference Type by value -- it would allow
you to manipulate the same instance of the Value Type.

In the code in your post, would I think that all of the variables will
be pointing to the same instance of your String. I suspect you could
drop the ref and all would be ok.

Cheers, Mart.

[Michael C]

"Mike" <vi********@yah oo.com> wrote in message
news:uT******** ******@TK2MSFTN GP05.phx.gbl...

As strings are immutable in C#, in neither case (ref or not) is it
possible for you to modify a string.
If it's passed by ref, you can modify the reference that the caller has
passed to a new string, but you still can not change the existing string.
If you want to actually "modify a string", pass a StringBuilder or char[]
instead.

That's true, although from outside the function the appearance is the string
has been modified. This is the same as any time you use a string as you're
always getting a reference to a new string, so the case of using the
function is nothing special.

Michael

[Bruce Wood]

> Because I am building the string in another function which can get fairly

large and I don't want to pass the actual string which will get very large.
A string is a reference type, so whenever you pass it, it doesn't get
copied on the stack anyway. You're always passing a reference.

The only question is whether you want to replace the string you passed
with a different string, in which case you need the "ref" keyword. What
"ref" says is that you may want to change the variable that contains a
reference (pointer) to the string to contain a reference (pointer) to a
different string upon return.

So, if HandleString changes the string to which theString points, and
wants the caller to FirstSub to receive the change, then you need
"ref". Something like this:

void FirstSub(ref string theString)
{
...
HandleString(re f theString);
...
}

void HandleString(re f string aString)
{
aString = String.Format(. ..);
}

Then any caller to FirstSub will get a changed string on return.

If FirstSub and HandleString are just _using_ the string for something,
but not replacing it with a different string, there is no reason to use
"ref".
I am curious as to why it works, however.

If I have testString and I pass it as a reference to FirstSub, then it has
the reference to testString (not the string itself). When I pass it to
HandleString, aren't I passing a reference to a reference of testString?

No, because C# isn't like C. In C#, when you mention the variable name
then the language dereferences automatically. So, in

void FirstSub(ref string theString)
{
...
}

when you say "theString" , you are not talking about the reference to
"theString" . You are talking about "theString" itself (which is a
reference to a string). So, no, you never get a reference to a
reference to a reference, because there is no language construct for
talking about "the reference to the reference called 'theString'". The
"ref" simply indicates how "theString" gets passed to the method. Once
inside the FirstSub method, "theString" is just a normal string again.

[Jon Skeet [C# MVP]]

Mart <ma***********@ simpl.co.nz> wrote:

In .NET, String is a Reference Type. It is allocated on the heap, and
the variable that you've declared (testString) contains it's address (a
pointer to it). This means that you will always be passing some form of
reference to the instance rather than the instance itself, whether you
pass the testString variable by ref or by value -- so I'm not sure that
you need to put the 'ref' bit in.

He does if the point is that a method lower down the call chain will
change the value of the parameter to be a different string. For
instance:

using System;

public class Test
{
static void Main()
{
string x = "hello";

Foo (ref x);
Console.WriteLi ne (x);
}

static void Foo (ref string y)
{
Bar (ref y);
}

static void Bar (ref string z)
{
z = "there";
}
}

The code actually being shown doesn't use this facility, admittedly,
and it looks like the OP does have misconceptions given his reluctance
to pass the string reference by value because "I don't want to pass the
actual string which will get very large".

Obligatory link for this kind of thread:
http://www.pobox.com/~skeet/csharp/parameters.html

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[Fabio]

"tshad" <ts**********@f tsolutions.com> ha scritto nel messaggio
news:Ol******** ******@TK2MSFTN GP02.phx.gbl...

Because I am building the string in another function which can get fairly
large and I don't want to pass the actual string which will get very
large.

IMHO it is not a good design the use of "ref" in a method.
It only add confusion for the use of the method.

For strings also, since they are immutable, there is no reasons to use ref.

Best a simple method following the designing guideline:

public string GetHandledStrin g(string myString)
{
myString = ...
return myString;
}
--

Free .Net Reporting Tool - http://www.neodatatype.net