“Правильність const” у C #

Сенс коректності полягає у можливості забезпечити подання екземпляра, який не може бути змінений або видалений користувачем. Компілятор підтримує це, вказуючи, коли ви порушуєте constness із функції const або намагаєтесь використовувати функцію non-const об'єкта const. Тож, не копіюючи підхід const, чи існує методологія, яку я можу використовувати в C #, яка має однакові цілі?

Я знаю про незмінність, але це насправді не переноситься на об'єкти контейнера, щоб назвати їх, а лише один приклад.

Я теж неодноразово стикався з цим питанням і в кінцевому підсумку використовував інтерфейси.

Я думаю, що важливо відмовитись від думки, що C # - це будь-яка форма або навіть еволюція C ++. Це дві різні мови, які мають майже однаковий синтаксис.

Я зазвичай висловлюю "правильність const" на C #, визначаючи подання класу лише для читання:

public interface IReadOnlyCustomer
{
    String Name { get; }
    int Age { get; }
}

public class Customer : IReadOnlyCustomer
{
    private string m_name;
    private int m_age;

    public string Name
    {
        get { return m_name; }
        set { m_name = value; }
    }

    public int Age
    {
        get { return m_age; }
        set { m_age = value; }
    }
}

Щоб скористатися перевагами безумства (або чистоти з точки зору функціонального програмування), вам потрібно буде сконструювати свої класи таким чином, щоб вони були незмінними, як і клас String з c #.

Цей підхід набагато кращий, ніж просто позначення об'єкта як лише для читання, оскільки за допомогою незмінних класів ви можете легко передавати дані в багатозадачних середовищах.

Я просто хотів зазначити для вас, що багато контейнери System.Collections.Generics мають метод AsReadOnly, який поверне вам незмінну колекцію.

C # не має такої функції. Ви можете передавати аргумент за значенням або за посиланням. Посилання є незмінним, якщо ви не вказали модифікатор ref . Але дані, на які посилаються, не є незмінними. Тому потрібно бути обережним, якщо хочеш уникнути побічних ефектів.

MSDN:

Передавання параметрів

Інтерфейси - це відповідь, і вони насправді потужніші за "const" у C ++. const - це універсальне рішення проблеми, де "const" визначається як "не встановлює членів або викликає щось, що встановлює членів". У багатьох сценаріях це хороший стенограф для стійкості, але не у всіх. Наприклад, розглянемо функцію, яка обчислює значення на основі деяких членів, але також кешує результати. У C ++ це вважається неконстантним, хоча з точки зору користувача це, по суті, const.

Інтерфейси дають вам більшу гнучкість у визначенні конкретного підмножини можливостей, які ви хочете надати з вашого класу. Хочете нестабільність? Просто надайте інтерфейс без методів мутації. Хочете дозволити встановлювати деякі речі, але не інші? Надайте інтерфейс саме з цими методами.

Погодьтеся, що деякі інші розглядають використання полів лише для читання, які ви ініціалізуєте в конструкторі, для створення незмінних об'єктів.

    public class Customer
    {
    private readonly string m_name;
    private readonly int m_age;

    public Customer(string name, int age)
    {
        m_name = name;
        m_age = age;
    }

    public string Name
    {
        get { return m_name; }
    }

    public int Age
    {
        get { return m_age; }
    }
  }

Ви також можете додати область доступу до властивостей, тобто загальнодоступний і захищений набір?

    public class Customer
    {
    private string m_name;
    private int m_age;

    protected Customer() 
    {}

    public Customer(string name, int age)
    {
        m_name = name;
        m_age = age;
    }

    public string Name
    {
        get { return m_name; }
        protected set { m_name = value; }
    }

    public int Age
    {
        get { return m_age; }
        protected set { m_age = value; }
    }
  }

• СопзЬ ключове слово можна використовувати для компіляції констант часу , таких як примітивні типів і рядки
• Тільки для читання ключового слова може бути використано для констант часу виконання , таких як посилальні типи

Проблема лише з читанням полягає в тому, що він дозволяє лише посилання (вказівник) бути постійним. Реч, на яку посилається (на яку вказують), все ще може бути змінена. Це складна частина, але її ніяк не обійти. Реалізувати постійні об'єкти означає змусити їх не піддаватись змінним методам чи властивостям, але це незручно.

Див. Також Ефективний C #: 50 конкретних способів покращити ваш C # (Пункт 2 - Віддавайте перевагу лише читанню, а не const.)