Is Int[] a Reference Type or a Value Type

Is int a value type or reference type?

Int is certainly not a reference type in C#. It's a numerical struct, which is a value type. When talking about C#, it is incorrect to say int is a reference type.

Is int? a value type or a reference type?

int? is equivalent to Nullable<int> which means it is a struct.

So that means it is a value type.

In my opinion it should be a reference type as it can be null.

Your assumption is wrong. From documentation;

Nullable structure represents a value type that can be assigned
null. The Nullable structure supports using only a value type as
a nullable type because reference types are nullable by design.

So it has 2 values;

1. The value of data
2. Boolean value which determines the values has been set or not. (Nullable<T>.HasValue)

Is int[] a reference type or a value type?

Arrays are mechanisms that allow you
to treat several items as a single
collection. The Microsoft® .NET Common
Language Runtime (CLR) supports
single-dimensional arrays,
multidimensional arrays, and jagged
arrays (arrays of arrays). All array
types are implicitly derived from
System.Array, which itself is derived
from System.Object. This means that
all arrays are always reference types
which are allocated on the managed
heap, and your app's variable contains
a reference to the array and not the
array itself.

https://msdn.microsoft.com/en-us/library/bb985948.aspx

Is object a reference type or value type?

It is a reference type

Doing an example with string isn't very illuminating, because string is also a reference type (as is SampleClass, obviously); your example contains zero "boxing".

if object is reference type then why obj2 value is still "OldString"

Why wouldn't it be? When you create a new string, that doesn't change old references to point at the new string. Consider:

 object obj1 = "OldString";
 // create a new string; assign obj1 the reference to that new string "OldString"

object obj2 = obj1;
 // copy the reference from obj1 and assign into obj2; obj2 now refers to
 // the same string instance

 obj1 = "NewString";
 // create a new string and assign that new reference to obj1; note we haven't
 // changed obj2 - that still points to the original string, "OldString"

Array in C# are reference type, why they acts as a value types?

One picture is worth a thousand words, so here is what's going on:

The effect of the assignment of "Three" to t2 is that before the assignment t1 and t2 referenced the same object, but after the assignment they reference different objects. Nothing else is going on here.

The situation would have been different if you had an array of mutable objects, and manipulated their value instead of setting their references. For example, imagine replacing the array of strings with an array of StringBuilder objects, and calling t2.Replace("Two", "Three") instead of the assignment. Now the effect would be different, because t1, t2, and data[0] would be pointing to the same object.

Difference between passing a reference type and a value type as argument to a method

Beside Reference Type and Value Type, there are Mutable Type and Immutable Type.

Immutable means that object cannot and will not be changed after initialization. As a result, your statement only produces new string but does not modify original string.

s += "Hi";

The hello string object remains hello. Change is that s is assigned with a new object helloHi.

---

You are unfortunate enough using string as an example.

Try to use mutable types like StringBuilder in your example.

public class C
{
    public static void Main(string[] args)
    {
        StringBuilder s = new StringBuilder("hello");
        StringBuilder w = Changestring(s);
        StringBuilder x = s;
    }

    private static StringBuilder Changestring(StringBuilder s)
    {
        s.Append("Hi");
        return s;
    }
}

How to make a reference type from int

That's not how variables in C# work. It has nothing to do with boxing value types.

Consider this:

object o1 = new object();
object o2 = o1;

o2 = new object();

Why would you expect o1 and o2 to contain a reference to the same object? They are the same when you set o2 = o1, but once you set o2 = new object(), the value (the memory location pointed to by the variable) of o2 changes.

Maybe what you're trying to do can be done like this:

class Obj {
    public int Val;
}

void Main() {
    Obj o1 = new Obj();
    o1.Val = 5;
    Obj o2 = o1;
    o2.Val = 8;
}

At the end of Main, the Val property of o1 will contain 8.

Primitive type and reference type objects

A primitive type is an object which the language has given a
predefined value

Why? Even references can have predefined values as noted. For primitive (built in) types you may want to say these are types that a language provides built in support for. What your instructor might be glad to hear about is if you say that most primitive types are also value types in C# and you might want to discuss value types semantics (e.g., value type variable directly contains value - whereas a reference variable just contains an address to some object in memory).

About reference types again you may say that a reference variable doesn't contain the value or object directly - rather just a reference to it. Now again you may want to discuss reference semantics. For example if you have two reference variables pointing to same object - and you change the object from one reference change will be visible from another reference too - because both references point to same object. This is not the case with value types. If you assign same value type object to two different value type variables and change one variable - this change will not be visible in the second value type variable because each of them holds the value directly (e.g. each will have its own copy of the value type variable it was assigned to).

Static types you have already described.

---

Related Topics