Что такое Инкапсуляция? - C#

Формулировка задачи:

Приятной пятницы всем. Начну с примера. Пусть есть у нас некий класс "A", одно из полей которого это List экземпляров другого класса "B". В классе "B" тоже одно из полей это List экземпляров ещё одного класса "C". Вот такая вот матрёшка, или точнее дерево. Подобная ситуация встречается сплошь и рядом. Вот пример кода если со слов непонятно.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Encapsulation
{
    class Program
    {
        static void Main(string[] args)
        {
            A a = new A();
            Console.ReadKey();
        }
        class A
        {
            public List<B> b;
            public A()
            {
                b = new List<B>();
                b.Add(new B());//Добаим несколько элементов в b
                b.Add(new B());
                b.Add(new B());
            }
        }
        class B
        {
            public List<C> c;
            public B()
            {
                c = new List<C>();
                c.Add(new C());//Добаим несколько элементов в c
                c.Add(new C());
                c.Add(new C());
            }
        }
        class C
        {
            public Int32 SomeValue;
            private static Int32 i;
            public C()
            {
                i++;
                SomeValue = i;
            }
        }
    }
}

В экземплярах класса "C" уже содержатся конкретные данные которые пользователю хотелось бы получить. Собственно если все List'ы делать public то никаких особых проблем нет, и используются выражения типа

Int32 x= a.b[2].c[0].SomeValue;

Но если List будет public, то мы автоматом получаем доступ ко всем внутренностям этой матрёшки и более того мы при желании можем не только считывать значения, но и удалять отдельные внутренние члены всей этой структуры (элемнты List'a). Вот не противоречит ли это дело "Инкапсуляции"? В принципе можно сделать все листы private и написать для них Get-функции. Переписав класс A вот в таком виде.

        class A
        {
            private List<B> b;
            public Int32 GetSomeValue(Int32 IndexB,Int32 IndexC)
            {
                return b[IndexB].c[IndexC].SomeValue;
            }
            public A()
            {
                b = new List<B>();
                b.Add(new B());//Добаим несколько элементов в b
                b.Add(new B());
                b.Add(new B());
            }
        }

Впринципе пользователь теперь может только брать данные, и ничего не сделат со внутренней структурой. Но стоит нам строение нашей матрешки сделать посложнее, чтобы было не одно интересное для чтения значение SomeValue в классе "C" а 10-15, да ещё и не только в классе "C" но и в "B" чёнить добавить, или ещё и классов добавить... То тогда класс в классе A надо будет писать кучу функций типа Get. Спрашивается, а стоит ли так всё усложнять? При этом можно ли говорить об инкапсуляции в классах типа "B" и "C"? Если рассматривать инкапсуляцию как скрытие внутренностей от пользователя, которому дают только класс A то тут пожалуй всё хорошо. Но вот внтури то класса "A" нет даже намёка на инкапсуляцию классов "B" и "C". Конечно можно и для них сделать Get функции. Но тогда программа ещё сильнее раздуется на пустом месте. И снова спрашивается, а стоит ли так всё усложнять? Впринципе в данном случае решением проблемы была бы возможность List'ам (как-то) выставить атрибут - "читать можно а изменять извне класса нельзя". Тогда можно обойтись и без Get-функций. Но стоит только вспомнить о том, что пользователю вобщемто хотелось бы не только что-то счиывать из внутренностей этой матрешки, но и что-то туда записывать... Как в голове рождаются монструозные конструкции из гигансткого кол-ва Set-функций. И снова спрашивается - а до какой степени стоит заморачиваться об инкапсуляции?

Решение задачи: «Что такое Инкапсуляция?»

textual
                            Листинг программы 
                        
                            public int X;