在C＃中，它是否与Java中引用方法期间的对象创建相同？

Question

I have a programming competition tomorrow and I have a quick question:

In Java, if you would pass an object in a parameter for a method, you actually got not a copy of the object, but the actual object.

Is it the same as C#?

public static void PunchyManager(string[] inputArray, ref int a, ref int b)
{
            string[] tempStrArray = inputArray;
}

If I do that will I basically make a pointer to inputArray, instead of having a copy?

Just a quick question, thanks!

Answer 1

In regard to your basic question in relation to Java Yes.

More generally Yes and no . Reference types (classes) are passed by reference which is like a single pointer . For something that can truly modify references outside the caller you should use the ref keyword even on reference types. This is similiar to a double pointer (assuming we are referring to pointers as they work in C for our pointer analogies).

class RefRefExample
{
    static void Method(ref string s)
    {
        s = "changed"; 
    }
    static void Main()
    {
        string str = "original";
        Method(ref str);
        // str is now "changed"
    }
}

In the above example if we passed str without using the ref keyword we would reassign the local reference of s instead of the original reference of str. By passing our reference by reference we can modify the original reference outside of the function as well. References themselves are still copied by value (but the copied reference still points to the same value) without the ref keyword.

http://msdn.microsoft.com/en-us/library/14akc2c7(v=vs.80).aspx

---

For practical usage in the scenario you are describing the modern C# idiom usually uses lists and they will likely be much faster to use as far as programming in your competition:

public static void PunchyManager(List<string> inputList, ref int a, ref int b)
{
    var tempList = new List<string>();
    foreach (var item in inputList)
       tempList.Add(item);     
}

Working on the original input list would modify objects through the reference so you would be affecting the original values outside of the method whereas the templList is a copy - Lists are very convenient . Furthermore you can convert them back to Arrays using .ToArray()

Answer 2

*edit Oh, you wish to know if it is the same in c# as java, your wording was a bit off.

Correct, if you do

public static void main(String[] args)
{
    int myArray[] = new int[1];

    test(myArray);

    System.out.println(myArray[0]);
}

public void test(int[] array)
{
    array[0] = 1;
}

You will get an output of 1

Answer 3

In CLR there are two kinds of objects:

1. Reference types (also known as just "objects")
2. Value types (also known as "structures" or "structs", even they are technically objects too).

The difference between them is that "objects" are located on heap, when "structs" are located on stack.

Types like Int32, Int64, Float, Double, etc are value types (structs). You can also define your own structure:

public struct MyStruct { ... }

Therefore, when you pass a "struct" around it is passed by copying the value.

Example:

int x = 5; //creates a value type on stack
int y = x; //makes a copy so now we have two objects on stack, not just one

"Objects" are passed by reference.

object x = new Object(); //create an object, x holds a reference to this object
object y = x; // y now holds a reference to the same object x has a reference to.

When you pass reference types around you generally don't need to use a ref keyword. However, if you want to pass a reference to a value type instance you may want to use this keyword.

Answer 4

Yes, class instances are passed as references in C#. If you want to pass value type (like Int32) as reference you need to use ref keyword.

Answer 5

Thing is, If you pass the parameter with keyword ref, modification of the variable inside the method will be reflected to caller as well. This is applicable to even struct(exmple int). But for struct or class, if you pass the parameter with out ref/out, this will be assumed as pass by value, which means, modification inside the method cannot be reflected to caller for structs. For classes, modification will be reflected to caller still without passing with out ref. BUT, StringBuilder sb = new StringBuilder() statement ask the sb to point to this one (an newly created new StringBuilder()). So reference knot will be moved from one which was pointed in the caller to new StringBuilder() in the callee. This has to be remembered always.

Pass by value with ref:

    static void Main(string[] args)
        {
            StringBuilder y = new StringBuilder();
            y.Append("hello");
            Foo(ref y);
Console.WriteLine(y);
       }

        private static void Foo(ref StringBuilder y)
        {
            StringBuilder sb = y;
            sb.Append("99");
        }

o/p : hello99

Pass by value without ref:

    static void Main(string[] args)
        {
            StringBuilder y = new StringBuilder();
            y.Append("hello");
            Foo(y);
Console.WriteLine(y);
       }

        private static void Foo(StringBuilder y)
        {
            StringBuilder sb = new StringBuilder
            sb.Append("99");
        }
o/p : hello

Answer 6

To assign something different to your array you'd want to have the parameter use the 'ref' keyword.

http://msdn.microsoft.com/en-us/library/szasx730(v=vs.71).aspx