dotnet / corefx

Rama: maestro corefx / Documentation / coding- Guidelines / coding-style.md Encontrar archivo Copiar ruta

Inconsistencia del estilo de codificación catcake : importaciones de espacio de nombres - Corrección ( # 32975 ) 7866452 on 23 Oct 2018

11 contribuyentes

136 líneas (108 sloc) 6.66 KB

Estilo de codificación C #
Para los archivos C ++ (* .cpp y * .h), usamos el formato clang (versión 3.6+) para asegurar el estilo del código. Después de
cambiar cualquier archivo Cpp o H y antes de fusionar, se debe ejecutar src / Native / format-code.sh. Esta secuencia de
comandos garantizará que todos los archivos de código nativo cumplan con las pautas de estilo de codificación.

Para los archivos que no son de código (xml, etc.), nuestra mejor guía actual es la consistencia. Al editar archivos, mantenga el
nuevo código y los cambios de acuerdo con el estilo de los archivos. Para archivos nuevos, debe ajustarse al estilo de ese
componente. Si hay un componente completamente nuevo, cualquier cosa que sea razonablemente aceptada en general está
bien.

La regla general que seguimos es "usar los valores predeterminados de Visual Studio".

1. Usamos tirantes estilo Allman , donde cada paréntesis comienza en una nueva línea. Un solo bloque de instrucciones de
línea puede pasar sin llaves, pero el bloque debe estar correctamente sangrado en su propia línea y no debe estar
anidado en otros bloques de instrucciones que usen llaves (consulte la edición 381 para ver ejemplos). Una excepción es
que using se permite que una declaración se anide dentro de otra using declaración comenzando en la siguiente línea
en el mismo nivel de sangría, incluso si la anidada using contiene un bloque controlado.
2. Utilizamos cuatro espacios de sangría (sin pestañas).
3. Usamos _camelCase para campos internos y privados y utilizamos readonly cuando sea posible. Prefije los campos de
instancia internos y privados con _ , campos estáticos con s_ y hilos de campos estáticos con t_ . Cuando se usa en
campos estáticos, readonly debe aparecer después static (por ejemplo, static readonly no readonly static ). Los
campos públicos deben usarse con moderación y deben usar PascalCasing sin prefijo cuando se usan.
4. Evitamos a this. menos que sea absolutamente necesario.
5. Siempre especificamos la visibilidad, incluso si es la predeterminada (por ejemplo, private string _foo no string
_foo ). La visibilidad debe ser el primer modificador (por ejemplo, public abstract no abstract public ).

6. Las importaciones de espacio de nombres deben especificarse en la parte superior del archivo, fuera de las
namespace declaraciones, y deben ordenarse alfabéticamente, con la excepción de los System.* espacios de nombres,
que se colocan sobre todos los demás.
7. Evite más de una línea vacía en cualquier momento. Por ejemplo, no tenga dos líneas en blanco entre los miembros de
un tipo.
8. Evita los espacios libres espurios. Por ejemplo if (someVar == 0)... , evite , donde los puntos marcan los espacios libres
espurios. Considere habilitar "Ver espacio en blanco (Ctrl + E, S)" si usa Visual Studio para ayudar a la detección.
9. Si un archivo difiere en estilo de estas pautas (por ejemplo, los miembros privados se nombran en m_member lugar de
_member ), el estilo existente en ese archivo tiene prioridad.

10. Solo utilizamos var cuando es obvio cuál es el tipo de variable (por ejemplo, var stream = new FileStream(...) no var
stream = OpenStandardInput() ).

11. Utilizamos palabras clave de idioma en lugar de tipos BCL (por ejemplo, en int, string, float lugar de Int32, String,
Single , etc.) tanto para referencias de tipo como para llamadas a métodos (por ejemplo, en int.Parse lugar de
Int32.Parse ). Vea el número 391 para ejemplos.

12. Usamos PascalCasing para nombrar todas nuestras variables y campos locales constantes. La única excepción es para el
código de interoperabilidad donde el valor constante debe coincidir exactamente con el nombre y el valor del código al
que llama mediante interoperabilidad.
13. Usamos en nameof(...) lugar de "..." siempre que sea posible y relevante.
14. Los campos deben especificarse en la parte superior dentro de las declaraciones de tipo.
15. Al incluir caracteres no ASCII en el código fuente, use las secuencias de escape Unicode (\ uXXXX) en lugar de caracteres
literales. Los caracteres literales que no son ASCII ocasionalmente pueden ser confusos por una herramienta o editor.
 16. Cuando use etiquetas (para goto), haga sangría en la etiqueta una menos que la sangría actual.

Hemos proporcionado un archivo de Visual Studio vssettings ( corefx.vssettings ) en la raíz del repositorio corefx, que
permite el formateo automático de C # conforme a las directrices anteriores. Tenga en cuenta que las reglas 7 y 8 no están
cubiertas por los ajustes vs, ya que estas no son reglas compatibles actualmente con el formato VS.

Además, para el formateo automático en editores que no sean de Visual Studio, también se ha proporcionado un archivo
EditorConfig ( .editorconfig ) en la raíz del repositorio de Corefx.

También usamos la herramienta de .NET Codeformatter Tool para asegurarnos de que la base del código mantenga un estilo
consistente a lo largo del tiempo, la herramienta corrige automáticamente la base del código para cumplir con las pautas
descritas anteriormente.

Archivo de ejemplo:
ObservableLinkedList`1.cs:

utilizando el sistema ;
utilizando el sistema . Colecciones ;
utilizando el sistema . Colecciones . genérica ;
utilizando el sistema . Colecciones . especializada ;
utilizando el sistema . ComponentModel ;
utilizando el sistema . Diagnostico ;
utilizando Microsoft . Win32 ;

Sistema de espacio de nombres . Colecciones . Genérico

{
clase parcial pública ObservableLinkedList < T >: INotifyCollectionChanged , INotifyPropertyChanged
{
privado ObservableLinkedListNode < T > _head ;
int _count privado ;

público ObservableLinkedList ( IEnumerable < T > items )

{
if ( items == null )
lanza una nueva excepción ArgumentNullException ( nameof ( items ));

foreach ( artículo de T en artículos )

{
AddLast ( item );
}
}

evento público NotifyCollectionChangedEventHandler CollectionChanged ;

pública int Contador

{
obtener { return _count ; }
}

público ObservableLinkedListNode AddLast ( valor de T )

{
var newNode = new LinkedListNode < T > ( esto , valor );

InsertNodeBefore ( _head , node );

}

vacío virtual protegido OnCollectionChanged ( NotifyCollectionChangedEventArgs e )

{
NotifyCollectionChangedEventHandler manejador = CollectionChanged ;
si ( manejador ! = nulo )
{
manejador ( este , e );
}
}

void privado InsertNodeBefore ( LinkedListNode < T > node , LinkedListNode < T > newNode )
{
...
}

...
}
}
ObservableLinkedList`1.ObservableLinkedListNode.cs:

utilizando el sistema ;

Sistema de espacio de nombres . Colecciones . Genéricos

{
clase parcial ObservableLinkedList < T >
{
clase pública ObservableLinkedListNode
{
privado readonly ObservableLinkedList < T > _parent ;
privado lectura de T _valor ;

ObservableLinkedListNode interno ( ObservableLinkedList < T > parent , valor de T )

{
Depuración . Afirmar ( padre ! = Nulo );

_parente = padre ;
_valor = valor ;
}

Valor T público
{
obtener { return _valor ; }
}
}

...
}
}