c# typ wartości vs typ referencji

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace ValueType
{
    //niefortunna nazwa. istnieje klasa specjalna o nazwie ValueType, więc dodałem _ pomiędzy. nie powinno to tak wyglądać
    public class Value_Type
    {
        int[] _arrField;

        //tu mamy pola, którym nie przypisaliśmy wartości.
        //ponieważ to są pola a nie zwykłe zmienne, każde z nich zostaje zainicjalizowane (podczas tworzenia obiektu klasy Value_Type)
        //za pomocą default(int), czyli 0
        int a, b, c, d;
        public Value_Type()
        {
            //teraz kopiujemy WARTOŚCI - NIE tworzymy referencji do obiektów, bo int dziedziczy po struct
            //czyli - skoro mamy same zera, to nasza tablica
            this._arrField = new[] { a, b, c, d };
            //przyjmie wartości
            //_arrField = new[] { 0, 0, 0, 0 };
            foreach(var value in this._arrField)
            {
                Console.WriteLine(value);
            }
            //0
            //0
            //0
            //0

            //nawet jeżeli teraz przypiszemmy do pol wartości
            a = 1;
            b = 2;
            c = 3;
            d = 4;
            //to nic nam to nie da (jeśli chodzi o tablicę _arrField)
            //ponieważ już SKOPIOWALIŚMY WARTOŚCI, które wtedy wynosiły 0,
            //więc nasza tablica NADAL wygląda tak samo
            //{ 0, 0, 0, 0 };

            //ale, jeżeli teraz spróbujemy zrobić jeszcze raz tablicę
            this._arrField = new[] { a, b, c, d };
            //to też skopiujemy wartości zz pól abcd, tylko że tym razem mają one jakąś konkretną wartość, więc skopiujemy te wartości
            //czyli teraz ta tablica będzie wyglądać o tak:
            //{ 1, 2, 3, 4 }

            foreach (var value in this._arrField)
            {
                Console.WriteLine(value);
            }
            //1
            //2
            //3
            //4

            //zwracam uwagę, że w żaden sposób nie możemy zmienić wartości obiektów, na które wskazują zmienne a b c d
            //czyli znowu, jeżeli napiszemy
            a = 1333;
            b = 24;
            c = 335;
            d = 4466;
            //to w tablicy NIC nam się nie zmieni
            //ponieważ nie zmieniliśmy wartości obiektów które pamiętamy, tylko STWORZYLIŚMY NOWE obiekty
            //i przypisaliśmy je do zmiennych
            //tym samym straciliśmy odniesienia do starych obiektów


            //w tablicy mamy WARTOŚCI
            //więc jeżeli napiszę coś takiego

            var temp = this._arrField.Last();

            //to
            //temp = 4
            //ale jeżeli zmienię
            this._arrField[3] = 123;
            //to NADAL
            //temp = 4
            //ponieważ SKOPIOWALIŚMY wartość


            //NIE da się zmienić wartości obiektów ValueType w c#
        }
    }

    //pomocnicza klasa do drugiego przykładu
    public class HelperClass
    {
        public int Value { get; set; }
    }

    //zachowałem nazewnictwo z tego, co mam powyżej, ale to jest brzydkie i unikać tego
    public class Reference_Type
    {
        HelperClass[] _arrField;

        //znowu, jak wyżej
        //tu mamy pola, którym nie przypisaliśmy wartości.
        //ponieważ to są pola a nie zwykłe zmienne, każde z nich zostaje zainicjalizowane
        //(podczas tworzenia obiektu klasy Reference_Type)
        //za pomocą default(HelperClass), czyli null
        HelperClass a, b, c, d;
        public Reference_Type()
        {
            //ponieważ każda klasa jest (użycie słowa kluczowego class) ReferenceType - tworzymy nowe referencje do obiektów a,b,c,d
            _arrField = new[] { a, b, c, d };

            //aktualnie nasza tablica wygląda tak:
            //{null, null, null, null}

            //jak w poprzednim przykładzie, przypisanie do abcd aktualnie nic nam nie da
            a = new HelperClass { Value = 5 };
            Console.Write(_arrField[0]);
            //null

            //ponieważ do zmiennej a przypisaliśmy nowy obiekt, a w tablicy została referencja do starego (tzn został null)
            //więc próba
            //Console.Write(_arrField[0].Value);
            //wyrzuciłaby nam NullReferenceException

            //czyli - żeby nie było wątpilowści
            //po przypisaniu do zmiennych REFERENCJI do NOWYCH obiektów
            b = new HelperClass { Value = 55 };
            c = new HelperClass { Value = 57 };
            d = new HelperClass { Value = 59 };
            //nasza tablica nadal wygląda tak
            //{null, null, null, null}


            //ale - jeżeli teraz przypiszemy
            _arrField = new[] { a, b, c, d };
            //to obiekty abcd już istnieją, więc przepisaliśmy referencje
            //czyli nasza tablica wygląda tak:
            //{
            //  HelperClass{ Value = 5 },
            //  HelperClass{ Value = 55 },
            //  HelperClass{ Value = 57 },
            //  HelperClass{ Value = 59 }
            //}


            //Teraz, jeżeli istnieją obiekty w pamięci i mamy w kodzie do nich referencje (które przechowujemy w zmiennych a b c d)
            //możemy zmienić wartości obiektów
            a.Value = 135;
            //czyli - w zmiennej a oraz w pierwszym elemencie tablicy przechowujemy referencje do tego samego obiektu
            //więc
            //a = HelperClass{ Value = 135 }

            //oraz nasza tablica
            //{
            //  HelperClass{ Value = 135 },
            //  HelperClass{ Value = 55 },
            //  HelperClass{ Value = 57 },
            //  HelperClass{ Value = 59 }
            //}

            //ALE
            //jeżeli stworzymy nowy obiekt w pamięci i nadpiszemy referencję którą przechowywaliśmy w zmiennej
            b = new HelperClass { Value = 444 };
            //to w tablicy nic nam się nei zmieni
            //{
            //  HelperClass{ Value = 135 },
            //  HelperClass{ Value = 55 },
            //  HelperClass{ Value = 57 },
            //  HelperClass{ Value = 59 }
            //}
            //ponieważ w tablicy została nam referencja do starego obiektu
            //natomiast do zmiennej b przypisaliśmy nową referencję która odnosi się do zupełnie innego obiektu w pamięci

            //w tym momencie zmiana wartości
            b.Value = 32;
            //nic nam nie zmieni w tablicy, ale oczywiscie zmieni nam wartość obiektu b
            //b = HelperClass{ Value = 32 }


            //mamy w tablicy REFERENCJE do obiektów
            //więc jeżeli zrobię coś takiego
            var temp = this._arrField.Last();
            //to w temp będę miał referencję do tego samego obiektu, do którego referencję przechowuję w ostatnim
            //elemencie tablicy czy zmiennej d
            //czyli zmienna temp
            //temp = new HelperClass { Value = 59 };
            //tak samo jak
            //d = new HelperClass { Value = 59 };
            //tak samo jak
            //this._arrField[3] = new HelperClass { Value = 59 };

            //i skoro to są referencje do tego samego obiektu, to pisząc
            temp.Value = 6565;
            //zmieniam właściwość Value w tym obiekcie, ale nie zmieniam samego obiektu
            //więc
            //temp = new HelperClass { Value = 6565 };
            //tak samo jak
            //d = new HelperClass { Value = 6565 };
            //tak samo jak
            //this._arrField[3] = new HelperClass { Value = 6565 };


            //PISZĄC
            c = new HelperClass { Value = 32 };
            //po pierwsze
            //tworzymy NOWY OBIEKT w pamięci
            //po drugie
            //przypisujemy REFERENCJĘ do ZMIENNEJ
        }
    }
}