Лучшая практика: упорядочивание общедоступных/защищать/частных в рамках определения класса?

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

Это будет мой порядок

1. Статические переменные
2. Статические методы
3. Общедоступные переменные
4. Защищенные переменные
5. Частные переменные
6. Конструкторы
7. Открытые методы
8. Защищенные методы
9. Частные методы

Я использую следующие правила:

• статические перед чем-либо
• переменные перед конструкторами перед методами (я считаю конструкторы должны быть в категории методы)
• публичный перед защищенным перед частным

Идея состоит в том, что вы определяете объект (данные) до поведения (методов). Статику нужно разделять, потому что на самом деле они не являются частью объекта или его поведения.

Раньше я очень заботился. За последние несколько лет при использовании современных IDE практически все можно получить всего в 1 или 2 нажатия клавиши, я позволил своим стандартам существенно ослабить. Теперь я начинаю со статики, переменных-членов, затем конструкторов, после чего я особо не беспокоюсь об этом.

В C # я позволяю Resharper организовать все автоматически.

Я в целом согласен с публичным, защищенным, частным порядком, а также со статическими данными, данными-членами, порядком функций-членов.

Хотя я иногда группирую как элементы (геттеры и сеттеры), я обычно предпочитаю перечислять членов внутри группы БУКВАЛЬНО, чтобы их было легче найти.

Мне также нравится выстраивать данные / функции по вертикали. Я ставлю табуляцию / пробел вправо достаточно, чтобы все имена были выровнены в одном столбце.

Каждому свое, и, как говорит Эльзо, современные IDE упростили поиск участников и их модификаторов с помощью цветных значков в раскрывающемся списке меню и т. д.

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

Итак, если это синглтон, я помещаю семантика (статический класс getInstance ()) в первую очередь.

Если это конкретная фабрика, я сначала помещаю функцию getNew () и функции регистрации / инициализации.

... и так далее. Когда я говорю «первый», я имею в виду вскоре после c'tors и d'tor - поскольку они являются способом создания экземпляра любого класса по умолчанию.

Следующие ниже функции находятся в:

1. логическом порядке вызова (например, инициализировать (), preProcess (), process (), postProcess ()),

Некоторые редакторы, такие как Eclipse и его детище, позволяют вам переупорядочивать в обзоре схемы переменных и методов в алфавитном порядке или как на странице.

Я думаю, что у меня другая философия на этот счет, чем у большинства. Я предпочитаю группировать связанные элементы вместе. Я терпеть не могу прыгать, чтобы работать с классом. Код должен течь и использовать довольно искусственный порядок, основанный на доступности (общедоступный, частный, protected и т. д.) или экземпляр против статического или член против свойства против функции не помогает сохранить хороший поток. Итак, если я создаю общедоступный метод Метод , который реализуется частными вспомогательными методами HelperMethodA , HelperMethodB и т. Д., То вместо того, чтобы иметь эти методы далеко друг от друга в файл, я буду держать их близко друг к другу. Точно так же, если у меня есть метод экземпляра, который реализуется статическим методом, я тоже сгруппирую их вместе.

Мои классы часто выглядят так:

class MyClass {
    public string Method(int a) {
        return HelperMethodA(a) + HelperMethodB(this.SomeStringMember);
    }

    string HelperMethodA(int a) { // returns some string }

    string HelperMethodB(string s) { // returns some string }

    public bool Equals(MyClass other) { return MyClass.Equals(this, other); }

    public static bool Equals(MyClass left, MyClass right) { // return some bool }

    public double SomeCalculation(double x, double y) {
        if(x < 0) throw new ArgumentOutOfRangeException("x");
        return DoSomeCalculation(x, y); 
    }

    const double aConstant;
    const double anotherConstant;
    double DoSomeCalculation(double x, double y) {
        return Math.Pow(aConstant, x) * Math.Sin(y) 
            + this.SomeDoubleMember * anotherConstant;
    }       
}