Conjunto de reglas Reglas de directrices de diseño ampliadas para código administrado
El conjunto Reglas de directrices de diseño extendidas de Microsoft expande las reglas de directrices de diseño básicas para maximizar los problemas de mantenimiento y uso que se notifican.Se pone especial énfasis en las directrices de nomenclatura.Debe incluir este conjunto de reglas si el proyecto incluye código de bibliotecas o si desea exigir los más altos estándares para escribir código que resulte fácil de mantener.
Las Reglas de directrices de diseño extendidas incluye todas las Reglas de directrices de diseño básicas de Microsoft.Estas últimas incluyen todas las Reglas mínimas recomendadas de Microsoft.Para obtener más información, vea Conjunto de reglas Reglas de directrices de diseño básicas para código administrado y Conjunto de reglas Reglas recomendadas administradas para código administrado.
En la tabla siguiente se describen todas las reglas del conjunto Reglas de directrices de diseño extendidas de Microsoft.
Regla |
Descripción |
|---|---|
Los tipos que poseen campos desechables deben ser desechables |
|
Declare los controladores de evento correctamente |
|
Marcar los ensamblados con AssemblyVersionAttribute |
|
Los tipos secundarios deberían poder llamar a los métodos de interfaz |
|
Los tipos que poseen recursos nativos deben ser descartables |
|
Mueva P/Invokes a la clase NativeMethods |
|
No oculte métodos de clases base |
|
Implemente IDisposable correctamente |
|
No producir excepciones en ubicaciones inesperadas |
|
Evitar aceleradores duplicados |
|
Deben existir puntos de entrada P/Invoke |
|
Los elementos P/Invoke no deben estar visibles |
|
Los tipos de diseño automático no deben ser visibles para COM |
|
Llame a GetLastError inmediatamente después de P/Invoke |
|
Los tipos base de tipos visibles para COM deben ser visibles para COM |
|
Los métodos de registro COM se deben adjuntar |
|
Declare los elementos P/Invoke correctamente |
|
Quitar los finalizadores vacíos |
|
Los campos de tipos de valor deberían ser portátiles |
|
Las declaraciones P/Invoke deben ser portátiles |
|
No bloquear objetos con identidad débil |
|
Revisar las consultas SQL en busca de vulnerabilidades de seguridad |
|
Especifique cálculo de referencias para argumentos de cadena P/Invoke |
|
Revisar la seguridad declarativa en los tipos de valor |
|
Los punteros no deberían estar visibles |
|
Los tipos seguros no deberían exponer campos |
|
La seguridad del método debería ser un supraconjunto del tipo |
|
Los métodos APTCA deben llamar solo a métodos APTCA |
|
Los tipos APTCA solo amplían tipos base APTCA |
|
No exponer indirectamente métodos con peticiones de vínculos |
|
Las peticiones de vínculos de reemplazo deberían ser idénticas a la base |
|
Incluir cláusulas Finally vulnerables en un bloque Try externo |
|
Las peticiones de vínculos de tipos requieren peticiones de herencias |
|
Los tipos críticos para la seguridad no pueden participar en la equivalencia de tipos |
|
Los constructores predeterminados deben ser al menos tan críticos para la seguridad como los constructores predeterminados de tipo base. |
|
Los delegados deben enlazarse a métodos con una transparencia coherente |
|
Los métodos deben mantener una transparencia coherente cuando reemplazan métodos base |
|
Los métodos transparentes deben contener solo IL que se pueda comprobar |
|
Los métodos transparentes no deben llamar a métodos con el atributo SuppressUnmanagedCodeSecurity |
|
El código transparente no debe hacer referencia a elementos críticos para la seguridad |
|
Los métodos transparentes no deben satisfacer LinkDemands |
|
Los tipos deben ser al menos tan críticos para la seguridad como sus interfaces y tipos base. |
|
Los métodos transparentes no pueden usar aserciones de seguridad |
|
Los métodos transparentes no deben llamar a código nativo |
|
Iniciar de nuevo para preservar los detalles de la pila |
|
No aplicar Dispose a los objetos varias veces |
|
Inicializar campos estáticos de tipo de valor insertados |
|
No marcar los componentes con servicio como WebMethod |
|
Aplique Dispose a los campos a los que se pueda |
|
No llamar a métodos reemplazables en constructores |
|
Los tipos descartables deben declarar el finalizador |
|
Los finalizadores deben llamar al finalizador de la clase base |
|
Implementar constructores de serialización |
|
Sobrecargar el operador de igualdad al reemplazar el tipo de valor de igualdad |
|
Marcar puntos de entrada de Windows Forms con STAThread |
|
Marcar todos los campos no serializables |
|
Llamar a métodos de clase base en tipos ISerializable |
|
Marcar los tipos ISerializable con SerializableAttribute |
|
Implementar los métodos de serialización de forma correcta |
|
Implementar ISerializable correctamente |
|
Proporcionar argumentos correctos para los métodos de formato |
|
Prueba para NaN correcta |
|
No declarar miembros estáticos en tipos genéricos |
|
No exponer listas genéricas |
|
Utilizar instancias genéricas del controlador de eventos |
|
Los métodos genéricos deben proporcionar un parámetro de tipo |
|
Evitar parámetros excesivos en tipos genéricos |
|
No anidar tipos genéricos en firmas de miembro |
|
Utilizar valores genéricos cuando sea posible |
|
Las enumeraciones deben tener un valor igual a cero |
|
Las colecciones deben implementar la interfaz genérica |
|
Considerar pasar los tipos base como parámetros |
|
Los tipos abstractos no deberían tener constructores |
|
El operador de sobrecarga es igual que la suma y resta de sobrecarga |
|
Marcar los ensamblados con CLSCompliantAttribute |
|
Marcar los ensamblados con ComVisibleAttribute |
|
Marcar atributos con AttributeUsageAttribute |
|
Definir descriptores de acceso para los argumentos de atributo |
|
Los indizadores no deben ser multidimensionales |
|
Utilizar las propiedades donde corresponda |
|
Reemplaza argumentos repetitivos con una matriz de parámetros |
|
No debería utilizar parámetros predeterminados |
|
Marcar enumeraciones con FlagsAttribute |
|
El almacenamiento de la enumeración debe ser de tipo Int32 |
|
Utilizar eventos cuando sea apropiado |
|
No capturar los tipos de excepción general |
|
Implementar constructores de excepción estándar |
|
Los tipos anidados no deben ser visibles |
|
Las implementaciones de ICollection tienen miembros fuertemente tipados |
|
Invalidar métodos en tipos comparables |
|
Los enumeradores deben estar fuertemente tipados |
|
Las listas están fuertemente tipadas |
|
Proporcionar un mensaje ObsoleteAttribute |
|
Utilizar argumento integral o de cadena para los indizadores |
|
Las propiedades no deben ser de solo escritura |
|
No sobrecargar el operador de igualdad en los tipos de referencia |
|
No declarar miembros protegidos en tipos sealed |
|
No declarar miembros virtuales en tipos sealed |
|
Declare tipos en espacios de nombres |
|
No declarar campos de instancia visibles |
|
Los tipos titulares estáticos deben ser sealed |
|
Los tipos titulares estáticos no deben tener constructores |
|
Los parámetros de URI no deben ser cadenas |
|
Los valores devueltos URI no deben ser cadenas |
|
Las propiedades URI no deben ser cadenas |
|
Las sobrecargas URI de cadena llaman a sobrecargas System.Uri |
|
Los tipos no deben ampliar ciertos tipos base |
|
Los miembros no deben exponer algunos tipos concretos |
|
Las excepciones deben ser públicas |
|
Los nombres de las variables no deben coincidir con los nombres de los campos |
|
Evite la excesiva complejidad |
|
Los identificadores se deberían diferenciar en algo más que en el uso de mayúsculas y minúsculas |
|
Los identificadores no deberían coincidir con palabras clave |
|
Revisar parámetros sin utilizar |
|
Quitar variables locales no utilizadas |
|
Evitar variables locales excesivas |
|
Inicializar campos estáticos de tipo de referencia insertados |
|
Evitar código privado al que no se llama |
|
Evitar las clases internas sin instancia |
|
Evitar atributos no sellados |
|
Preferir las matrices escalonadas antes que multidimensionales |
|
Invalidar Equals y el operador Equals en los tipos de valores |
|
Las propiedades no deberían devolver matrices |
|
Comprobar si las cadenas están vacías mediante la longitud de cadena |
|
Marcar el miembro como estático |
|
Evitar los campos privados sin utilizar |
|
No provocar tipos de excepción reservados |
|
Utilizar equivalentes administrados de la API Win32 |
|
Crear instancias de las excepciones del argumento correctamente |
|
Los campos no constantes no deben ser visibles |
|
No marcar enumeraciones con FlagsAttribute |
|
No producir excepciones en cláusulas de excepción |
|
Debe proteger los finalizadores |
|
No reducir la visibilidad del miembro heredado |
|
Los miembros deben diferenciarse por algo más que por un tipo de valor devuelto |
|
Reemplazar Equals al sobrecargar operadores de igualdad |
|
Las sobrecargas del operador tienen alternativas con nombre |
|
Los operadores deben tener sobrecargas simétricas |
|
Las propiedades de la colección deben ser de sólo lectura |
|
Usar parámetros para argumentos de variable |
|
Pasar objetos System.Uri en lugar de cadenas |
|
Proporcionar métodos de deserialización para campos opcionales |
|
Evitar espacios de nombres con pocos tipos |
|
Evitar parámetros out |
|
Evitar interfaces vacías |
|
No pasar tipos por referencia |
|
Validar argumentos de métodos públicos |
|
Evitar una herencia excesiva |
|
Revisar los nombres de campos erróneos |
|
Evitar el código difícil de mantener |
|
Evitar el acoplamiento excesivo de clases |
|
No nombrar valores de enumeración como 'Reserved' |
|
En las palabras compuestas de la cadena de recursos se deberían utilizar las mayúsculas y minúsculas correctamente |
|
En las palabras compuestas se deberían utilizar las mayúsculas y minúsculas correctamente |
|
Las cadenas de recursos deberían tener la ortografía correcta |
|
Los identificadores deberían tener la ortografía correcta |
|
Los identificadores no deberían contener subrayado |
|
Los identificadores deberían utilizar las mayúsculas y minúsculas correctamente |
|
Los identificadores deberían tener el sufijo correcto |
|
Los identificadores no deberían tener el sufijo incorrecto |
|
No utilizar prefijos en valores de enumeración con el nombre del tipo |
|
Los eventos no deberían tener prefijos antes ni después |
|
Las enumeraciones Flags deberían tener nombres en plural |
|
Los identificadores deberían tener el prefijo correcto |
|
Solo las enumeraciones FlagsAttribute deberían tener nombres en plural |
|
Los nombres de parámetro no deberían coincidir con los nombres de miembro |
|
Los identificadores no deberían contener nombres de tipo |
|
Los nombres de propiedades no deberían coincidir con los métodos Get |
|
Los identificadores no deberían tener el prefijo incorrecto |
|
Los nombres de tipo no deben coincidir con los espacios de nombres |
|
Los nombres de parámetro deberían coincidir con la declaración base |
|
Utilizar términos preferidos |
|
Los literales se deberían escribir correctamente |