Conjunto de reglas Reglas de directrices de diseño básicas para código administrado
Puede utilizar el conjunto Reglas de directrices de diseño básicas de Microsoft para centrarse en facilitar la comprensión y el uso del código.Se recomienda incluir este conjunto de reglas si el proyecto incluye código de bibliotecas o si desea exigir procedimientos recomendados para el código que es fácil de mantener.
El conjunto Reglas de directrices de diseño básicas incluye todas las reglas del conjunto Reglas mínimas recomendadas de Microsoft.Para obtener una lista de las reglas mínimas, vea 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 básicas de Microsoft.
Regla |
Descripción |
---|---|
Los tipos que poseen campos descartables deben ser descartables |
|
Declarar los controladores de eventos correctamente |
|
Marcar los ensamblados con AssemblyVersionAttribute |
|
Los tipos secundarios deben poder llamar a los métodos de interfaz |
|
Los tipos que poseen recursos nativos deben ser descartables |
|
Mover P/Invokes a la clase NativeMethods |
|
No ocultar métodos de clases base |
|
Implementar 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 estar visibles para COM |
|
Llamar a GetLastError inmediatamente después de P/Invoke |
|
Los tipos base de los tipos visibles para COM deben estar visibles para COM |
|
Los métodos de registro COM se deben adjuntar |
|
Declarar elementos P/Invoke correctamente |
|
Quitar los finalizadores vacíos |
|
Los campos de tipo de valor deben ser portables |
|
Las declaraciones P/Invoke deben ser portables |
|
No bloquear objetos con identidad débil |
|
Revisar las consultas SQL en busca de vulnerabilidades de seguridad |
|
Especificar los cálculos de referencias para argumentos de cadena P/Invoke |
|
Revisar la seguridad declarativa en los tipos de valor |
|
Los punteros no deben estar visibles |
|
Los tipos seguros no deben exponer campos |
|
La seguridad del método debe ser un supraconjunto del tipo |
|
Los métodos APTCA deben llamar sólo a métodos APTCA |
|
Los tipos APTCA sólo amplían tipos base APTCA |
|
No exponer indirectamente métodos con peticiones de vínculos |
|
Las peticiones de vínculos de reemplazo deben 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 métodos de serialización correctamente |
|
Implementar ISerializable correctamente |
|
Proporcionar argumentos correctos a 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 de controlador de eventos |
|
Los métodos genéricos deben proporcionar un parámetro de tipo |
|
Evite 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 |
|
Considere pasar los tipos base como parámetros |
|
Los tipos abstractos no deben tener constructores |
|
El operador de sobrecarga equivale a la suma y la 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 debe 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 un argumento integral o de cadena para los indizadores |
|
Las propiedades no deben ser de sólo 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 |
|
Declarar 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 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 |
|
Evitar la excesiva complejidad |
|
Los identificadores se deben diferenciar en algo más que en el uso de mayúsculas y minúsculas |
|
Los identificadores no deben 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 las multidimensionales |
|
Invalidar equals y el operador equals en los tipos de valores |
|
Las propiedades no deben 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 |
|
Los finalizadores deben protegerse |
|
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 |