No, "blue colored types" in the Visual Studio editor is C# keywords.
Those cyan-colored ones are types.

This also makes it easier (for that other thread on the forum about case
sensitivity) to spot mistakes like If and While.

No, it's a reference type.

You can spot reference types by writing their class name or keyword and
hovering the mouse over them, it would say things like:

for string: class System.String
for int: struct System.Int32

anything that is a struct is a value type, anything that is a class is a
reference type.

Ok. C# or .NET doesn't make such distinctions between the two.

Well, yes.

Passing an object by value does not create a copy of the object, it just
creates a copy of the reference to the object.

Let me describe the difference using other terms.

Suppose I want you to go to a house somewhere. I write down the address
on a piece of paper (copy) and give it to you (pass it). You then go to
the house and do what you need to do there.

Now, let's suppose I did the same thing with another person as well once
you indicate you're done with the house (return from the method). I
write down the address on another piece of paper and give it to him,
then he would end up in the same house as you did. Any changes you did
to the house, he will see when he gets there. Additionally, if you made
a copy of the note before indicating you were done with it, you could
revisit the house at any time, observing any changes that other person
had done in the meantime. This is because which house we're talking
about here hasn't changed at all, it's still just one house.

Now, the difference between this (passing by value) and passing by
reference is that once you're done with the house, if you were passed
the address by reference, you would be free to take an eraser and erase
out the address I wrote on the paper, and write a new one instead,
before handing back the paper to me (return from the method).

So for instance, if I have a piece of paper with the address on, and I
give this to you, passing it by reference, and you change the address
before giving the paper back to me, when I give the paper to that other
person, he will not go to the original house I had in mind, he will go
to the house you wrote down the address to on the paper.

This is the distinction between passing by reference and passing by value.

Note again, that this is different from preventing you from messing up
the house by making sure you either is not allowed to change it, or that
I would give you a whole new house to play with.

In .NET, if you want to make sure the code being called cannot mess up
your object, you have a few options available:

1. pass it an immutable object (String is such an object)
2. pass it a copy of the original object (in which case the called code
can mess it up all it wants, it won't matter to you)
3. other languages have syntax for this, notably the "const" keyword in
C++, which C# or .NET doesn't have

Option 1 would force the called code to basically do what you would do
in option 2, in order for it to work with a modified object, it would
basically have to construct a whole new object based on the original one
with a few changes.

<snip>

"<b>This difference is absolutely crucial to understanding parameter passing
in C#, and is why I believe it is highly confusing to say that objects are
passed by reference by default instead of the correct statement that object
references are passed by value by default.</b>"

While I am quite aware of what you are referring to (sic!), I'm not sure about
the "highly confusing" part. Or rather, what is initially more confusing.

I've seen my share of e.g. StringBuilders being passed with the ref keyword,
"because I need to append to it in my method".

Is it easier to say "don't worry, your object will be passed by reference"
here, or would you say "don't worry, what you think of as 'your object' is in
fact only a reference, and it will be passed by value (the reference), which
is enough, because your method gets passed a copy of the reference (by value)
and hence can easily modify the object (via the reference) it is referring to"

Maybe, didactically, something comparable to the buddhist "two truth doctrine"
is what we need here. The "commonsense truth" would be that objects are passed
by reference. The absolute spiritual truth :-) being that there is no such
thing as an "object" per se, always only a reference to it, which is indeed
passed by value by default.

  Regards,
  Gilles.

.NET uses Unicode, yes.  But that doesn't imply:

In fact, it directly contradicts it, since Unicode is specifically not  
byte-sized characters (that would instead be ASCII,  
"ANSI-that's-really-just-Windows", and a variety of other character  
encodings that do only use single bytes for characters).  In Windows,  
Unicode means 2-byte characters (I think this is basically equivalent to  
UTF-16, as I think Windows supports surrogate pairs in the char data  
types, but I could be wrong...character encodings is definitely not my  
area of expertise and while Unicode was supposed to unify the whole  
character encoding thing, and in fact it has made things better, it's  
gotten quite a bit more complicated since when it first showed up :) ).

Pete

I once made the little code snippet attached below to illustrate.

Arne

==============================================

using System;

namespace E
{
    public struct VT
    {
        public int v;
        public VT(int v)
        {
            this.v = v;
        }
    }
    public class RT
    {
        public int v;
        public RT(int v)
        {
            this.v = v;
        }
    }
    public class MainClass
    {
        public static void VTBV(VT v1, VT v2)
        {
            v1.v++;
            v2.v++;
            VT tmp = v1;
            v1 = v2;
            v2 = tmp;
        }
        public static void VTBR(ref VT v1, ref VT v2)
        {
            v1.v++;
            v2.v++;
            VT tmp = v1;
            v1 = v2;
            v2 = tmp;
        }
        public static void RTBV(RT v1, RT v2)
        {
            v1.v++;
            v2.v++;
            RT tmp = v1;
            v1 = v2;
            v2 = tmp;
        }
        public static void RTBR(ref RT v1, ref RT v2)
        {
            v1.v++;
            v2.v++;
            RT tmp = v1;
            v1 = v2;
            v2 = tmp;
        }
        public static void Main(string[] args)
        {
            VT a = new VT(1);
            VT b = new VT(2);
            VTBV(a, b);
            Console.WriteLine(a.v + " " + b.v);
            VT c = new VT(1);
            VT d = new VT(2);
            VTBR(ref c, ref d);
            Console.WriteLine(c.v + " " + d.v);
            RT e = new RT(1);
            RT f =  new RT(2);
            RTBV(e, f);
            Console.WriteLine(e.v + " " + f.v);
            RT g = new RT(1);
            RT h = new RT(2);
            RTBR(ref g, ref h);
            Console.WriteLine(g.v + " " + h.v);
        }
    }
}