'ref' question

[Priyesh]

public class stringtemp
{
String k ;
public stringtemp(ref String inp)
{
k = inp ;
}
public void Change()
{
k = k.Remove(0, 1) ;
}
};

String stringtochange = new String("Hello". ToCharArray()) ;
stringtemp t = new stringtemp(ref stringtochange) ;
t.Change() ;

Why isnt stringtochange changed to 'ello' here? When I try a similar sample
with an ArrayList instead of a String, my original variable gets reflected.
So my question is: How can i make sure i am operating on a reference?
Documentation says all class types are passed by references. Could someone
elaborate?

TIA

[Bruce Wood]

The two replies you already received are correct. Here is another way
of phrasing it.

You are, in a way, comparing apples and oranges. The case of ArrayList
and String are identical. You have the same capabilities and the same
thing is happening, but you're failing to see a distinction.

The distinction is this: when you pass an ArrayList, you can _change
the ArrayList_, but you _can't_ change _which ArrayList_ "ar" points
to. "ar" still points to the _same ArrayList as before_. It's just that
you've change _what_ that particular ArrayList _contains_.

If you try to write the code so that you try to change _which
ArrayList_ ar points to, you'll find that you can't:

public class arraylistchange
{
ArrayList ar ;

//This is passed in as a reference even if i dont specify ref.
// (So is a string, by the way.)
public arraylistchange (ArrayList arIn)
{
//This seems to be copied as a reference. So my member
//variable ar is a reference type even if i dont specify it to be?
// (The string variable was a reference type, too.)
ar = arIn ;
}
public void Change()
{
// Here we create a whole new ArrayList and change what
// this.ar points to.
ArrayList newOne = new ArrayList();
newOne.Add("123 ");
newOne.Add("456 ");
this.ar = newOne;
}
};

ArrayList ar = new ArrayList(10) ;
ar.Add("123") ;
arraylistchange archange = new arraylistchange (ar) ;
archange.Change () ;
int n = ar.Count ;//is *1*, because it still points to the original
ArrayList, not the new one

See? You can change the ArrayList itself, but if you change _which
ArrayList_ the field this.ar points to, the variable ar on the outside
doesn't change. It can't, because C# doesn't allow references to
references.

This is what is happening with strings. As C# Learner pointed out,
strings are immutable. In your string Change() method, you didn't say:

this.k.SetNewSt ringValue("Hell o");

or something like that. You didn't _change the value of the string_.
You instead _changed which string_ this.k pointed to, because C# won't
let you change the values of strings, only create new ones and point
variables to the new string.

So, what you were doing in the two methods was different.

That's why I said that Strings, because of the way they're implemented
in C#, sort of act like value types. You can't point x to a string and
y to a string then "change the string" so that it changes in x and y,
because in C# you can't change strings. You can only change x to point
to a different string, which of course doesn't affect y at all.

ArrayLists and other reference types are different. You can change an
ArrayList: add items, remove items, etc. If x and y point to the same
ArrayList, and you change that ArrayList, both x and y will now point
to the changed ArrayList. However, as for strings, if you point x and y
to the same ArrayList and then create a new ArrayList and point x to
that, y remains unaffected.

Does that help? :)

[Priyesh]

Bruce.

Defenitely helps. Thanks for your time.

"Bruce Wood" <br*******@cana da.com> wrote in message
news:11******** **************@ g43g2000cwa.goo glegroups.com.. .

The two replies you already received are correct. Here is another way
of phrasing it.

You are, in a way, comparing apples and oranges. The case of ArrayList
and String are identical. You have the same capabilities and the same
thing is happening, but you're failing to see a distinction.

The distinction is this: when you pass an ArrayList, you can _change
the ArrayList_, but you _can't_ change _which ArrayList_ "ar" points
to. "ar" still points to the _same ArrayList as before_. It's just that
you've change _what_ that particular ArrayList _contains_.

If you try to write the code so that you try to change _which
ArrayList_ ar points to, you'll find that you can't:

public class arraylistchange
{
ArrayList ar ;

//This is passed in as a reference even if i dont specify ref.
// (So is a string, by the way.)
public arraylistchange (ArrayList arIn)
{
//This seems to be copied as a reference. So my member
//variable ar is a reference type even if i dont specify it to be?
// (The string variable was a reference type, too.)
ar = arIn ;
}
public void Change()
{
// Here we create a whole new ArrayList and change what
// this.ar points to.
ArrayList newOne = new ArrayList();
newOne.Add("123 ");
newOne.Add("456 ");
this.ar = newOne;
}
};

ArrayList ar = new ArrayList(10) ;
ar.Add("123") ;
arraylistchange archange = new arraylistchange (ar) ;
archange.Change () ;
int n = ar.Count ;//is *1*, because it still points to the original
ArrayList, not the new one

See? You can change the ArrayList itself, but if you change _which
ArrayList_ the field this.ar points to, the variable ar on the outside
doesn't change. It can't, because C# doesn't allow references to
references.

This is what is happening with strings. As C# Learner pointed out,
strings are immutable. In your string Change() method, you didn't say:

this.k.SetNewSt ringValue("Hell o");

or something like that. You didn't _change the value of the string_.
You instead _changed which string_ this.k pointed to, because C# won't
let you change the values of strings, only create new ones and point
variables to the new string.

So, what you were doing in the two methods was different.

That's why I said that Strings, because of the way they're implemented
in C#, sort of act like value types. You can't point x to a string and
y to a string then "change the string" so that it changes in x and y,
because in C# you can't change strings. You can only change x to point
to a different string, which of course doesn't affect y at all.

ArrayLists and other reference types are different. You can change an
ArrayList: add items, remove items, etc. If x and y point to the same
ArrayList, and you change that ArrayList, both x and y will now point
to the changed ArrayList. However, as for strings, if you point x and y
to the same ArrayList and then create a new ArrayList and point x to
that, y remains unaffected.

Does that help? :)

[Priyesh]

Thanks.

"C# Learner" <cs****@learner .here> wrote in message
news:1l******** *******@csharp. learner...

Priyesh <pr*****@donotr eply.com> wrote:

This does not hold good when i use an ArrayList or another user defined
class. My original variable is *magically*
changed.

That's because ArrayList is mutable, while String isn't.

Consider:

1 {
2 string original = "foo";
3 string copy = original;
4
5 copy = "bar";
6 }

After the assignment in line three, both original and copy reference the
same string. However, after line five, copy now references a new string.

Replace line five with (from your example)

copy = original.Remove (0, 1)

and you get the same situation: copy now references a whole new string.

This happens because strings are immutable (their state cannot be
changed).

The same thing happens here, for example:

myString = myString.Replac e("foo", "bar");

After this, myString now references a whole new string which looks like
the
old one but has all occurences of "foo" replaced with "bar".

//This is passed in as a reference even if i dont specify ref.
public arraylistchange (ArrayList arIn)

Note that this is a mistake -- if that parameter were of type string, a
reference would be passed just the same. The only difference here is that
strings are immutable, while ArrayLists aren't.

Also, a 'ref' parameter is different from a reference type parameter. See
<http://www.yoda.arachs ys.com/csharp/parameters.html >.