Пример #1
0
 public static void DoubleValue(NumberHolder numberHolder)
 {
     numberHolder.Number *= 2;
 }
Пример #2
0
 public static void ReplaceAndDoubleValue(NumberHolder numberHolder)
 {
     numberHolder = new NumberHolder(100);
     DoubleValue(numberHolder);
 }
Пример #3
0
        public static void Main(string[] args)
        {
            int number = 10;

            DoubleValue(number);

            Console.WriteLine(number);
            // Prints out 10. Value is unchanged since primitive data
            // types are passed by value by default.

            DoubleValue(ref number);

            Console.WriteLine(number);
            // Prints out '20'. Value of the number is changed since we're
            // passing a reference of the variable by using 'ref' keyword.

            var numbers = new int[] { 2, 4, 8, 16 };

            DoubleValues(numbers);

            Console.WriteLine(string.Join(", ", numbers));
            // Prints out '4, 8, 16, 32'. Non-primitive data types are passed by reference.
            // Which means that data altered inside the method will be reflected on the
            // original array in this case.

            var holder = new NumberHolder(15);

            DoubleValue(holder);

            Console.WriteLine(holder.Number);
            // Prints out '30'. Our custom class is a reference type, so it's being passed by
            // reference to the overload of DoubleValue method which accepts this data type.
            // Any change done to our class is being reflected to the original instance.

            var secondHolder = new NumberHolder(20);

            ReplaceAndDoubleValue(secondHolder);

            Console.WriteLine(secondHolder.Number);
            // Prints out '20'. We passed 'secondHolder' by reference, but since new reference
            // has been assigned to that variable within 'ReplaceAndDoubleValue' method
            // any additional changes done to that class does not affect our original instance.

            int result = MultiplyByRandomNumber(number, out int randomNumber);

            Console.WriteLine("Random number is: {0}", randomNumber);
            Console.WriteLine("Multiplication result is: {0}", result);
            // Keyword 'out' is yet another way to pass the value into a method by reference.
            // In this example, we're declaring an integer of name 'randomNumber' and passing
            // it to the 'MultiplyByRandomNumber' method by reference by using 'out' keyword.
            // Any change of that variable within the method will be visible after its execution.

            string text = "Strings are immutable objects.";

            text += "Every time we append something to the previous string, a new one is created on the heap.";

            text.Replace("Strings", "");
            // Previous line of code won't alter the existing 'text' variable. Instead of that,
            // new string is created on the heap and is being returned back from the 'Replace'
            // method. Since we're not storing it to a new variable, the reference to that
            // new string is lost and it will be collected in the next cleaning cycle of the Garbage Collector.
        }