Orden de los elementos en las clases: Campos, Propiedades, Constructores, Métodos

En lugar de agrupar por visibilidad o por tipo de elemento (campo, propiedad, método, etc.), ¿qué tal agrupar por funcionalidad?

Recomendaría usar los estándares de codificación de iDesigno los enumerados en El sitio web de Brad Abram. Esos son los dos mejores que he encontrado.

Los miembros de las clases deben estar alfabetizados y agrupados en secciones (Campos, Constructores, Propiedades, Eventos, Métodos, implementaciones de interfaces privadas, tipos anidados)

Esta es una pregunta antigua pero todavía muy relevante, así que agregaré esto: ¿Qué es lo primero que busca cuando abre un archivo de clase que puede o no haber leído antes? ¿Fields? Propiedades? Me he dado cuenta por experiencia que casi invariablemente voy a la caza de los constructores, porque lo más básico para entender es cómo se construye este objeto.

Por lo tanto, he comenzado a poner a los constructores en primer lugar en los archivos de clase, y el resultado ha sido psicológicamente muy positivo. La recomendación estándar de poner constructores después de un montón de otras cosas se siente disonante.

La próxima característica del constructor primario en C# 6 proporciona evidencia de que el lugar natural para un constructor está en la parte superior de una clase; de hecho, los constructores primarios se especifican incluso antes de la llave abierta.

Es curioso cuánta diferencia hace un reordenamiento como este. Me recuerda cómo se ordenaban las sentencias using - con los espacios de nombres del sistema primero. El comando "Organizar usos" de Visual Studio usó este orden. Ahora los using se ordenan alfabéticamente, sin dar un tratamiento especial a los espacios de nombres del Sistema. El resultado se siente más simple y limpio.

No conozco un idioma o un estándar de la industria, pero tiendo a poner las cosas en este orden con cada sección envuelta en una # región:

Usando instrucciones

Espacio de nombres

Clase

Miembros privados

Propiedades públicas

Constructores

Métodos públicos

Métodos privados

Como se mencionó anteriormente, no hay nada en el lenguaje C# que dicte el diseño, yo personalmente uso regiones, y hago algo como esto para una clase promedio.

public class myClass
{
#region Private Members

#endregion
#region Public Properties

#endregion

#region Constructors

#endregion
#region Public Methods

#endregion
}

Tiene sentido para mí de todos modos

Desde StyleCop

Campos privados, campos públicos, constructores, propiedades, métodos públicos, métodos privados

Como StyleCop es parte del proceso de compilación de MS, podría verlo como un estándar de facto

Normalmente trato de seguir el siguiente patrón:

• miembros estáticos (normalmente tienen otro contexto, deben ser seguros para subprocesos, etc.)
• miembros de instancia

Cada parte (estática e instancia) consta de los siguientes tipos de miembros:

• operadores (son siempre estáticos)
• campos (inicializados antes de los constructores)
• constructores
• destructor ( es una tradición para seguir la constructores )
• propiedades
• métodos
• eventos

Luego los miembros se ordenan por visibilidad (de menos a más visible):

• privado
• interno
• interno protegido
• protegido
• público

El orden no es un dogma: las clases simples son más fáciles de leer, sin embargo, las clases más complejas necesitan una agrupación específica del contexto.

Lo más cercano que es probable que encuentre es "Pautas de diseño, código administrado y. NET Framework" ( http://blogs.msdn.com/brada/articles/361363.aspx [2]}) por Brad Abrams

Muchas normas se describen aquí. La sección relevante es 2.8 creo.

Mi preferencia es ordenar por tipo y luego disminuir la visibilidad de la siguiente manera

public methods
public events
public properties

protected methods
protected events
protected properties

private methods
private events
private properties
private fields

public delegates
public interfaces
public classes
public structs

protected delegates
protected interfaces
protected classes
protected structs

private delegates
private interfaces
private classes
private structs

Sé que esto viola Style Cop y si alguien puede darme una buena razón por la que debería colocar los detalles de implementación de un tipo antes de su interfaz, estoy dispuesto a cambiar. En la actualidad, tengo una fuerte preferencia por poner a los miembros privados en último lugar.

Nota: No uso campos públicos o protegidos.

Las únicas pautas de codificación que he visto sugeridas para esto es poner los campos en la parte superior de la definición de la clase.

Tiendo a poner a los constructores a continuación.

Mi comentario general sería que debería atenerse a una clase por archivo y si la clase es lo suficientemente grande como para que la organización de propiedades versus métodos sea una gran preocupación, ¿qué tan grande es la clase y debería refactorizarla de todos modos? ¿representa múltiples preocupaciones?

Prefiero poner los campos privados en la parte superior junto con el constructor(s), luego poner los bits de la interfaz pública después de eso, luego los bits de la interfaz privada.

Además, si la definición de su clase es lo suficientemente larga como para que el orden de los elementos importe mucho, eso es probablemente un olor a código que indica que su clase es demasiado voluminosa y compleja y debe refactorizar.

Lo mantengo lo más simple posible (al menos para mí)

Enumeraciones
Declaraciones
Constructores
Overrides
Métodos
Propiedades
Controlador de eventos

Ciertamente no hay nada en el lenguaje que lo haga cumplir de ninguna manera. Tiendo a agrupar cosas por visibilidad (público, luego protegido, luego privado) y uso #regiones para agrupar cosas relacionadas funcionalmente, independientemente de si es una propiedad, método o lo que sea. Los métodos de construcción (ya sean ctor reales o funciones de fábrica estáticas) suelen estar en la parte superior, ya que son lo primero que los clientes necesitan saber.

Sé que esto es viejo pero mi orden es la siguiente:

En orden de público, protegido, privado, interno, abstracto

• Constantes
• Variables estáticas
• Campos
• Eventos
• Constructor(es)
• Métodos
• Propiedades
• Delegados

También me gusta escribir propiedades como esta (en lugar del enfoque abreviado)

// Some where in the fields section
private int someVariable;

// I also refrain from
// declaring variables outside of the constructor

// and some where in the properties section I do
public int SomeVariable
{
    get { return someVariable; }
    set { someVariable = value; }
}