Почему у вас есть модификаторы доступа на уровне классов вместо уровня объекта?

При использовании С# я недавно понял, что я могу вызывать частные функции объекта Foo из статических функций Foo и даже из других объектов Foo. После всего, что я узнал о модификаторах доступа, это звучит очень странно для меня.

Насколько я знаю, вы делаете функцию частной, когда она делает что-то, что является частью какого-то внутреннего процесса. Только сам объект знает, когда использовать эти функции, потому что другие объекты не должны/не могут управлять потоком объекта. Есть ли причина, по которой другие объекты того же класса должны быть исключены из этого довольно простого правила?

В соответствии с запросом пример:

public class AClass {
    private void doSomething() { /* Do something here */ }
    public void aFunction() {
        AClass f = new AClass();
        f.doSomething(); // I would have expected this line to cause an access error.
    }
}

Ответ 1

Когда вы делаете элемент частным, он является приватным для других классов, а не для самого класса.

Это может быть полезно, например, если у вас есть метод Equals, которому нужен доступ к другим частным членам экземпляра:

public class AClass
{
    private int privateMemberA;

    // This version of Equals has been simplified
    // for the purpose of exemplifying my point, it shouldn't be copied as is
    public override bool Equals(object obj)
    {
        var otherInstance = obj as AClass;
        if (otherInstance == null)
        {
            return null;
        }

        return otherInstance.privateMemberA == this.privateMemberA;
    }
}

Ответ 2

Модификатор private обеспечивает Encapsulation.

Идея заключается в том, что "внешний мир" не должен вносить изменения в внутренние процессы AClass, поскольку реализация AClass может со временем меняться (и вам придется изменить весь внешний мир, чтобы исправить различия в реализации, что почти невозможно).

Когда экземпляр AClass выполняет доступ к внутренним компонентам другого экземпляра AClass - вы можете быть уверены, что оба экземпляра всегда знают детали реализации AClass. Если логика внутренних процессов AClass изменена - все, что вам нужно сделать, это изменить код AClass.

Однако в некоторых других языках private работает на уровне экземпляра, но это не так на С#.

Ответ 3

Члены

Private доступны только из всех других членов в рамках этого класса. Не имеет значения, выполняется ли это несколькими экземплярами или одним экземпляром.

Вы пытаетесь вытеснить членов только для вызова из this., поэтому им не разрешено вызывать из внешнего мира (видимые с точки зрения экземпляра), но им разрешено вызывать один раз вы вошли в область вашего экземпляра. Это просто невозможно в С#.

Будет приятной особенностью, хотя...:)

Ответ 4

закрытый (ссылка на С#) говорит:

Частное ключевое слово - это модификатор доступа к членству. Частный доступ - это наименее разрешительный уровень доступа. Частные члены доступны только внутри тела класса или структуры, в которой они объявлены (...)

Еще больше:

Вложенные типы в одном и том же теле также могут обращаться к тем частным членам.

Таким образом, следующий код будет работать отлично.

class Foo
{
    private void PrivateMethod()
    {
    }
    class FooBaby
    {
        public static void MethodB()
        {
            Foo foo = new Foo();
            foo.PrivateMethod();
        }
    }
}

В вопросе "почему" классы имеют модификаторы доступа, а не объекты, это один из способов скрыть информацию в ООП (подробнее об Encapsulation (объектно-ориентированное программирование).

Я также рекомендую вам ознакомиться с главами:

10.5 Доступ пользователя
17.2.3 Модификаторы доступа

Стандартная спецификация языка ECMA-334 С#.

Ответ 5

private означает, что вы можете получить доступ к нему только из самого класса. Является ли оно статичным или нет, не имеет никакого значения. Хотя это не исключение этого правила...

Кристофа

Ответ 6

Ну, причина, по которой вы можете получить доступ к частному методу, заключается в том, что вы находитесь внутри AClass

Например, если вы создаете BClass и создаете AClass внутри, вы не сможете получить доступ к закрытому методу

public class AClass
{
    private void doSomething() { /* Do something here */ }
    public void aFunction()
    {
        AClass f = new AClass();
        f.doSomething(); // we are inside AClass so we can access
    }
}

public class BClass
{
    private void doSomething() { /* Do something here */ }
    public void aFunction()
    {
        AClass f = new AClass();
        f.doSomething(); // Will not compile because we are outside AClass
    }
}

Итак, в основном его...

Публичная. Если вы можете увидеть класс, вы можете увидеть метод

Частный. Если вы являетесь частью класса, вы можете увидеть этот метод, в противном случае нет.