Estándares y Consideraciones de Desarrollo para Microsoft .NET

SMEii – Sistema de Monitoreo y Evaluación Integral de Indicadores de los pacientes de VIH y TBC Estándares y consideraciones de Desarrollo para Proyectos sobre plataformas Microsoft .NET

MINSA Pág.: 1

SMEii Sistema de Monitoreo y Evaluación Integral de Indicadores

de los pacientes de VIH y TBC

Estándares y Consideraciones de Desarrollo para Proyectos sobre plataformas Microsoft.NET

Versión 0.8

Autor : Eduardo Rivera Alva


MINSA Pág.: 2

Tabla de contenidos

1 INTRODUCCIÓN ............................................................................................................................3

2 CONVENCIONES DEL DOCUMENTO .......................................................................................4

3 TERMINOLOGÍA Y DEFINICIONES........................ ..................................................................5

4 RESUMEN ILUSTRATIVO............................................................................................................6

4.1 EQUIVALENCIAS ENTRE C# Y VB.NET ......................................................................................6 4.2 CONVENCIONES DE NOMBRE....................................................................................................10 4.3 ESTILOS DE CODIFICACIÓN ......................................................................................................11 4.4 USO DEL LENGUAJE.................................................................................................................11

5 CONVENCIONES DE NOMBRES ..............................................................................................12

5.1 RECOMENDACIONES GENERALES.............................................................................................12 5.2 USO DE NOMBRES Y SINTAXIS..................................................................................................13

6 ESTILO DE CODIFICACIÓN......................................................................................................17

6.1 FORMATO.................................................................................................................................17 6.2 COMENTARIOS.........................................................................................................................18

7 USO DEL LENGUAJE ..................................................................................................................20

7.1 GENERAL .................................................................................................................................20 7.2 VARIABLES Y TIPOS.................................................................................................................22 7.3 CONTROL DE FLUJOS................................................................................................................25 7.4 CONTROL DE EXCEPCIONES.....................................................................................................27 7.5 EVENTOS, DELEGADOS E HILOS...............................................................................................27 7.6 COMPOSICIÓN DE OBJETOS......................................................................................................27

8 CONSIDERACIONES DE ARQUITECTURA ...........................................................................29

8.1 CAPA DE ACCESO A DATOS (DAL) ...........................................................................................29 8.2 CAPA DE LÓGICA DEL NEGOCIO (BLL) .....................................................................................30 8.3 CAPA DE PRESENTACIÓN (UI) ..................................................................................................30

9 FRAMEWORK Y HERRAMIENTAS DE DESARROLLO............. .........................................31

9.1 GENERADORES DE PROCEDIMIENTOS ALMACENADOS..............................................................31 9.2 GENERADORES DE CLASES ENTIDADES Y CONTROLADORAS.....................................................31 9.3 GENERADORES DE INTERFACES DE USUARIO............................................................................31 9.4 CONTROLES Y COMPONENTES..................................................................................................31

10 APLICACIÓN PRÁCTICA DE CONCEPTOS...........................................................................32


MINSA Pág.: 3

1 Introducción Este documento describe reglas y recomendaciones para el desarrollo de aplicaciones usando los lenguajes de la plataforma Microsoft.Net: C# y VB.NET, y su objetivo es definir líneas guías para enmarcar la consistencia de estilo y de formato para ayudar a los desarrolladores a evitar errores comunes. También se han incluido lineamientos y recomendaciones para el desarrollo de aplicaciones escalables y en capas. Específicamente este documento cubre convenciones de nombres, estilos de codificación, uso del lenguaje, mejores prácticas para aplicaciones, etc. Todos estos temas son cubiertos detallando reglas y recomendaciones las cuales son aplicables para C# y cuando y VB.NET. Las fuentes de información utilizadas para el desarrollo de este documento, son las siguientes: Design Guidelines for Class Library Developers http://msdn2.microsoft.com/en-us/library/czefa0ke(VS.71).aspx Guidelines and Best Practices http://msdn2.microsoft.com/en-us/library/ms184412.aspx

Best Practices http://msdn2.microsoft.com/en-us/library/ms184411(VS.80).aspx


MINSA Pág.: 4

2 Convenciones del Documento Este documento requiere de estándares para asegurar la claridad cuando se indiquen las reglas y líneas guías. Ciertas convenciones son usadas a través de este documento para añadir énfasis. En seguida algunas de las convenciones usadas a través del documento. Color y Énfasis:

Azul Texto coloreado de azul indica una palabra clave de C# o de VB.NET.

Negrita Texto con énfasis adicional para resaltarlo. Palabras Clave: Siempre Enfatiza que la regla debe ser cumplir. Nunca Enfatiza que la acción nunca se debe de ejecutar.

Evitar Enfatiza que la acción debe de ser prevenida, pero algunas excepciones pueden existir.

Tratar Enfatiza que la regla debe de cumplirse siempre y cuando

sea posible y sea adecuado. Ejemplo Precede el texto usado para ilustrar la regla o

recomendación. Razón Explica el propósito detrás de la regla o recomendación.


MINSA Pág.: 5

3 Terminología y Definiciones La siguiente terminología es referenciada a través de este documento: Modificador de Acceso

Las palabras clave de C# o de VB.NET que declaran el nivel de accesibilidad de código que se tiene para tipos y miembros. Ejemplo : [VB.NET] Private, Public, Friend, Protected, Shared [C#] private, public, internal, protected, static Aunque los modificadores de acceso varían, las clases y la mayoría de sus miembros usan por defecto private o Private . Excepciones para esto son las interfaces y enumerados los cuales por defecto son públicos. En la sección de breve resumen se muestra una tabla de equivalencias de modificadores de acceso entre VB.NET y C#.

Camel Case Forma de escribir una palabra donde su primera letra esta en minúsculas, y la primera letra de las subsiguientes palabras en mayúsculas. Ejemplo : nombreVendedor

Pascal Case Forma de escribir una palabra donde la primera letra esta en mayúscula, y la primera letra de las subsiguientes palabras igualmente en mayúscula. Ejemplo : NombreVendedor

Common Type System (CTS)

El sistema común de tipos (CTS) del .NET Framework define como los tipos son declarados, usados y manejados. Todos los tipos nativos de C# y de VB.NET están basados sobre el CTS para asegurar el soporte de la integración de los diferentes lenguajes del .NET Framework.

Identificador El desarrollador define un nombre único para declarar un objeto o instancia de alguno.

Número Mágico Cualquier número usado con una expresión (o inicialización de alguna variable) que no contiene en si un significado obvio o conocido. Este usualmente excluye los enteros 0 y 1 y cualquier otra equivalente numérico que se evalúe como cero.


MINSA Pág.: 6

4 Resumen ilustrativo Esta sección contiene cuadros y tablas describiendo a alto nivel el resumen de las recomendaciones y estándares de nombres, estilos de codificación y uso del lenguaje. Igualmente se presenta una tabla de equivalencias entre los lenguajes VB.NET y C# para tener en cuenta cada una de las reglas.

4.1 Equivalencias entre C# y VB.NET Propósito VB .NET C#

Programación Orientada a Objetos

Public Class MiClase Public Sub New(...) MyBase.New … End Sub … End Class

public class MiClase { public MiClase(...) { … } … }

Construcción de una clase.

Nota : Se tiene que llamar explícitamente al constructor de la clase padre si es que se necesita llamar en VB.NET

Nota : La llamada al constructor de la clase padre es generada automáticamente por el compilador en C#, llamando al constructor de la clase padre que contenga la misma cantidad de parámetros de entrada.

Declaración de Clase Class class

Herencia de Clase Public Class A Inherits B … End Class

public class A : B { … }

Indica que la clase solo puede ser heredara y no instanciada.

MustInherit abstract

Indica que la clase no puede ser heredara.

NotInheritable sealed

Llamar a la propia implementación de un método en lugar de llamar al método sobre en una clase derivada.

MyClass


MINSA Pág.: 7

Referir a la clase padre de una clase derivada.

MyBase base

Declarar un delegado (referencia segura a un método)

Delegate delegate

Indica que el método o la propiedad sobrescriben la implementación de la clase padre.

Overrides override

Indica que aquellos métodos no cuentan con implementación y deben implementarse en clases derivadas.

MustOverride (en una clase declarada MustInherit)

abstract (en un clase declarada abstract)

Indica que el método o propiedad no pueden ser sobrescritas en clases derivadas.

NotOverridable Nota : Por defecto, los métodos no sobrescribibles.

sealed

Indica que el método o propiedad pueden ser sobrescritas en clases derivadas.

Overridable virtual

Sobrecarga de procesos, funciones o métodos.

Overloads [Se define funciones con el mismo nombre pero con diferente cantidad de parametros.]

Especifica que una variable contiene un objeto cuyos eventos deseas controlar.

WithEvents

Especifica el eventos por cual un procedimiento o método va a ser llamado a raíz de este.

Handles

Evalúa una expresión con el cual se tienen múltiples accesos a los miembros de un objeto.

With MiObjeto <.Miembro> <.Miembro> End With

Refiere al objeto actual. Me this

Declaración de un tipo enumerado.

Enum … End Enum

enum

Declaración de una interfase. Interface interface

Implementación de una interfase.

Implements class MiC1ase : IDisposable


MINSA Pág.: 8

Indicador de índice. Default Property public string this [ int index] { get { return List[index];} set {List[index]= value ;} }

Modificadores de Acceso de Clases

Indica que la clase es accesible fuera del proyecto o de su ensamblado.

Public public

Indica que la clase es accesible solo dentro de su ensamblado.

Friend internal

Indica que la clase solo es accesible en el proyecto por clases anidadas dentro de esta clase.

Private private

Modificadores de Acceso de Miembros de una Clase

Indica que el miembo es accesible fuera de la clase y del proyecto.

Public public

Indica que el miembro es accesible fuera de la clase pero no del proyecto.

Friend internal

Indica que el miembro solo es accesible en el ambito de la clase.

Private private

Indica que el miembro es accesible solo para la clase y para las clases derivadas

Protected protected

Indica que el miembro es compartido a través de todas las instancias de la clase.

Shared static

Otros

Indica comentario. ‘ , Rem //, /* */ /// Para comentarios XML

Indica constante. Const const, readonly

Creación de un nuevo objeto. New, CreateObject new

Declaración de una función o método sin valor de retorno.

Sub void

Declaración de un objeto que puede ser modificado asincronamente

volatile


MINSA Pág.: 9

Declaración explicita de variables

Option Explicit

Declaración de eventos. Event, RaiseEvent event

Declaración de una estructura.

Structure … End Structure

struct

Declaración de objeto nulo. Nothing null

Declaración de un Espacio de Nombres.

Namespace … End Namespace

namespace { … }

Indica el uso de un espacio de nombres.

Imports using

Devuelve un carácter de una cadena literal.

GetChar [ ]

Devuelve la dirección de una función

AddressOf delegate

Prueba si un objeto es nulo Obj Is Nothing obj == null

Bloqueo de Hilos SyncLock lock


MINSA Pág.: 10

4.2 Convenciones de Nombre

“c” = camelCase “P” = PascalCase “_” = Prefijo con raya inferior “X” = No aplicable

Identificador Public Protected Internal Friend Private Notas

Archivo Proyecto P x x x

Coincidir con el Ensamblado y con el Espacio de Nombre (Namespace).

Archivo Fuente P x x x Coincidir con la clase que contiene.

Otros Archivos P x x x Aplicar cuanto sea posible.

Espacio de Nombre (namespace ) P x x x

Coincidir parcialmente el Proyecto/Ensamblado.

Clase o Estructura P P P P

Añadir sufijo de subclase.

Interfase P P P P Añadir prefijo de I capital.

Clase Genérica P P P P

Usar T o K como identificadores de tipo.

Método P P P P Usar un verbo o pareja verbo-objeto.

Propiedad P P P P No usar prefijos con Get o Set.

Campo P P P [C#] _c [VB.NET] c

Solo usar campos privados. Nunca notación Húngara.

Constante P P P [C#] _c [VB.NET] c

Solo usar campos privados.

Campo Estático P P P

[C#] _c [VB.NET] c

Enumerador P P P P Delegado P P P P Evento P P P P Parametro x x x c

Variables internas x x x c

Evitar usar nombres de un solo carácter o de enumerados.


MINSA Pág.: 11

4.3 Estilos de Codificación Código Estilo Archivos Fuente Un espacio de nombre por archivo y una clase por archivo. Llaves "{" Una por línea. Siempre usar llaves cuando sea opcional. Indentación Usar tabs de tamaño de 4 espacios en blanco.

Comentarios

[C#] Usar // o /// pero no /* … */ y no utilizar marcos de asteriscos. Utilizar /// para comentarios XML de las funciones y métodos. [VB.NET] Usar el ‘ para todo tipo de comentario

Variables Una variable por declaración.

4.4 Uso del Lenguaje Código Estilo Tipos Nativos de Datos • Usar datos nativos de datos de C# y VB.NET versus los

tipos del CTS del .NET. • [C#] Usar int NO System.Int32 • [VB.NET] Usar Integer NO System.Int32

Propiedades • Evitar utilizar prefijos Get o Set MyBase / base • Usar solamente en constructores o en sobre escritura. Condicionales

• Evitar evaluar condiciones booleanas contra true o false .

• No utilizar asignaciones en la condición. • Evitar usar invocaciones a métodos en las condiciones.

Excepciones

• Usar throw e ; cuando se necesite re lanzar excepciones.

• Capturar solo cuando se vaya a manejar la excepción. • Usar validaciones para evitar excepciones. • Heredar siempre de la clase Exception .

Eventos • Siempre chequear nulos antes de invocarlos. Dispose () y Close () • Siempre invocarlos si estan implementados en la clase,

declares cuando sean necesarios. Finalizadores

• Evitarlos. • [C#] Usar los destructores de c#. • Nunca cree el método Finalize () en C#. • [VB.NET] Implementar el método Finalize ().


MINSA Pág.: 12

5 Convenciones de Nombres Esta sección se concentra completamente en el trabajo de nombrar proyectos, archivos de código fuente, e identificadores incluyendo campos, variables, propiedades, métodos, parámetros, clases, interfases y espacios de nombres (Namespaces).

5.1 Recomendaciones Generales

1. Siempre usar nombres con estilo de escritura CamelCase o PascalCase. 2. Evitar nombres totalmente en MAYÚSCULAS o en minúsculas. Nombres de

una sola palabra serán totalmente en minúsculas si se usa con el estilo de escritura camelcase.

3. Nunca cree espacios de nombres, clases, métodos, propiedades, campos o parámetros que varían solamente por su capitalización.

4. Nunca usar nombres que comiencen con caracteres numéricos. 5. Siempre escoja nombres específicos y con significado en si mismos. 6. Variables y propiedades deben describir la entidad que representan no el

tipo o tamaño. 7. Nunca usar notación Húngara .

Ejemplo : strNombre o chrTipoRol 8. Evitar el uso de abreviaturas a menos que el nombre completo sea

excesivo. 9. Evitar abreviaturas que su longitud sea mayor a 5 caracteres. 10. Cualquier abreviatura debe ser totalmente conocida y aceptada por el

equipo de desarrollo. 11. Usar mayúsculas en caso de abreviaciones de 2 letras, y estilo de escritura

PascalCase para abreviaturas más largas. 12. Nunca usar palabras reservadas para nombres. 13. Evitar conflictos de nombres con los espacios de nombres o tipos existentes

en el .NET Framework. 14. Evitar añadir redundancia en prefijos o sufijos de los identificadores.

Ejemplo : [C#]

/// Mal! public enum TiposRolEnum { … }

public class CPoliticasInternas { … } public struct CoordenadaStruct { … } [VB.NET] /// Mal!

Public Enum TiposRolEnum …

End Enum Public Class CPoliticasInternas … End Class

Public Structure CoordenadaStruct … End Class


MINSA Pág.: 13

15. Nunca incluir el nombre de la clase a los nombres de las propiedades.

Ejemplo : Cliente.Nombre NO Cliente.NombreCliente 16. Tratar de utilizar los siguientes prefijos en las variables y propiedades

booleanas, “Puede”, “Es” o “Tiene”. 17. Cuando se defina el espacio de nombres raíz para un proyecto, utilice el

nombre de la compañía, y el nombre del proyecto con estilo de escritura PascalCase. Ejemplo : Empresa.SistemaOnline o Empresa.SistemaFacturacion

5.2 Uso de nombres y sintaxis Identificador Convención de Nombramiento Archivo de Proyecto

• Utilizar estilo de Escritura Pascal • Siempre coincidir el nombre del ensamblado y el espacio de

nombres raíz. Ejemplo : Empresa.SistemaOnline.csproj -> Empresa.SistemaOnline.dll -> namespace: Empresa.SistemaOnline

Archivo Fuente

• Utilizar estilo de Escritura Pascal • Siempre coincidir el nombre de la clase y el nombre del

archivo. • Evitar incluir más de una clase, enumerador (global) o

delegado (global) por archivo. • Usar un nombre descriptivo para el archivo que contenga

múltiples clases, enumeradores o delegados. Ejemplo : [C#] MiClase.cs => public class MiClase [VB.NET] MiClase.vb => Public Class MiClase

Archivo de Recurso

• Tratar de utilizar estilo de escritura Pascal. • Utilizar un nombre que describa la información que contenga

el archivo.

Espacio de Nombre (Namespace)

• Estilo de Escritura Pascal • Tratar de coincidir el nombre ensamblado/proyecto. Ejemplo : [C#] namespace Empresa.SistemaWeb [VB.NET] Namespace Empresa.SistemaWeb


MINSA Pág.: 14

Clase o Estructura

• Utilizar estilo de Escritura Pascal • Usar un sustantivo o frase de sustantivos para el nombre de

la clase. • Agregar un sufijo apropiado cuando se nombre sub clases. Ejemplo : [C#] private class MiClase { … } internal class CoordenadaAttribute: Attribute { … } public class ClienteCollection : CollectionBase { … } public class ClienteEventArgs : EventArgs { … } private struct PropiedadesAplicacion { … } [VB.NET] Private Class MiClase … End Class Friend Class CoordenadaAttribute Inherits Attribute … End Class Public Class ClienteCollection Inherits CollectionBase … End Class Public Class ClienteEventArgs Inherits EventArgs … End Class Private Structure PropiedadesAplicacion … End Structure

Interfase

• Utilizar estilo de Escritura Pascal • Siempre agregar el prefijo "I" Ejemplo : [C#] interface ICliente { … } [VB.NET] Interface ICliente … End Interface


MINSA Pág.: 15

Método

• Utilizar estilo de Escritura Pascal • Tratar de usar un verbo o par verbo-objeto. Ejemplo : [C#] public void Ejecutar() { … } private string ObtenerVe rsionEnsamblado(Assembly libreria) { … } [VB.NET] Public Sub Ejecutar() … End Sub Private Function ObtenerVersionEnsamblado( ByVal libreria As Assembly) As String … End Function

Propiedad

• Utilizar estilo de Escritura Pascal • El nombre de la propiedad debe representar la entidad que

devuelve. • Nunca utilizar los prefijos "Get" o "Set". Ejemplo : [C#] public string Nombre { get { … } set { … } } [VB.NET] Public Property Nombre() As String Get … End Get Set ( ByVal Value As String ) … End Set End Property

Campo (Público, Protegido o Interno)

• Utilizar estilo de Escritura Pascal • Evitar el uso de campos no privados. • Usar propiedades en lugar de estos campos. Ejemplo : [C#] public string Nombre; protected IList ListaInterna; [VB.NET] Public Nombre As String Protected ListaInterna As IList


MINSA Pág.: 16

Campo (Privado)

[C#] Utilizar estilo de escritura tipo CamelCase y utilizar el prefijo "_". [VB.NET] Utilizar estilo de escritura tipo CamelCase. Ejemplo : [C#] private string _nombre; [VB.NET] Private nombre As String

Constante o Campo Estático

• Tratar como campo.

Enumerador

• Utilizar estilo de Escritura Pascal Ejemplo : [C#] public enum TiposCliente { Normal, Frecuente } [VB.NET] Public Enum TiposCliente Normal Frecuente End Enum

Delegado o Evento

• Tratar como campo. Ejemplo : [C#] public event EventHandler CargarComponente; [VB.NET] Public Event CargarComponente As EventHandler

Variable (Interna)

• Utilizar estilo Camel. • Evitar el uso de nombres de un solo carácter tales como "x" o

"y" a excepción de aquellos usados en la sentencia for . • Evitar enumerar nombre de variables como cadena1, cadena2,

cadena3, etc. Parametro

• Utilizar estilo de escritura Pascal Ejemplo : [C#] public void Ejecutar( string Texto, int iteraciones) { … } [VB.NET] Public Sub Ejecutar( ByVal Texto As String , ByVal Iteraciones As Integer ) … End Sub


MINSA Pág.: 17

6 Estilo de Codificación Las siguientes secciones describen el camino preferido para implementar código fuente en C# y VB.NET, para así crear un código legible, claro y consistente que sea fácil de comprender y mantener.

6.1 Formato

1. Nunca declarar más de un espacio de nombres por archivo. 2. Evitar colocar múltiples clases en un mismo archivo. 3. [C#] Siempre colocar llaves (“{“ y “}”) en líneas separadas. 4. [C#] Siempre usar llaves (“{“ y “}”) en sentencias condicionales. 5. Siempre usar Tab e indentación de tamaño 4. 6. Declarar cada variable independientemente – nunca en la misma sentencia. 7. Colocar la sentencia “using ” o “Imports ” en la parte superior del archivo.

El grupo de los espacios de nombres de .NET colocarle por encima de los espacios de nombres particulares y todos en ordenados alfabéticamente. Ejemplo:

[C#] using System;

using System.Collections using System.Data; using System.Data.SqlClient; using System.Xml; [VB.NET] Imports System Imports System.Collections Imports System.Data Imports System.Data.SqlClient Imports System.Xml

8. Agrupar la implementación interna de las clases por el tipo de miembros en el siguiente orden: a. Campos b. Propiedades c. Constructores y Destructores d. Métodos e. Enumeradores, Estructuras o Clases internas

9. Ordenar las declaraciones a partir de los modificadores de acceso y visibilidad: a. Privados b. Internos c. Protegidos d. Público

10. Utilizar #region o #Region "” para agrupar los tipos de miembros de la clase.

11. Añadir el nombre de la carpeta al espacio de nombres para archivos en el interior de estos.


MINSA Pág.: 18

12. Recursivamente indentar todos lo bloques de código en medio de llaves. 13. [C#] Evitar declarar múltiples atributos en una misma línea. En lugar de ello

colocar cada atributo en una sentencia separada. Ejemplo :

[C#] // Mal! [Atributo1, Atributo2, Atributo3] public class MiClase { … } // Bien! [Atributo1] [Atributo2] [Atributo3] public class MiClase { … }

6.2 Comentarios

1. [C#] Usar // o /// pero no /* … */ 2. [C#] No utilizar marcos de asteriscos.

Ejemplo : //****************************************** // Cuadro de comentarios //******************************************

3. Tratar de usar comentarios en el interior de los métodos para explicar

aspectos globales del algoritmo. 4. No utilizar comentarios para explicar código obvio. 5. Incluir lista de tareas para utilizar los filtros de comentarios.

Ejemplo : [C#] // TODO: Obtener cadena de conexión del registro [VB.NET] ' TODO: Obtener cadena de conexión del registro

6. [C#] SIEMPRE aplicar bloques de comentarios XML propios de C# (///) a las

declaraciones de los miembros públicos, protegidos e internos. No olvidar que cuando se presiona tres veces slash (“/”), el editor generará los bloques de comentarios respectivos.

7. [C#] Siempre agregar el elemento CDATA a los comentarios que contengan código para evitar problemas de codificación. Ejemplo : [C#] ///<example> /// Agregar la siguiente llave a los valores de la /// aplicación en el web.config ///<code ><![CDATA[ /// <configuration> /// <appSettings> /// <add key=”miLLave” value=”miValor”/> /// </appSettings> /// </configuration>


MINSA Pág.: 19

/// ]]></code> ///</example>


MINSA Pág.: 20

7 Uso del Lenguaje

7.1 General

1. [C#] Nunca omitir los modificadores de acceso. Declare explícitamente todos lo identicadores con su apropiado modificador de acceso en lugar de dejarlo con el de por defecto. Ejemplo : [C#] // Mal! void EscribirEvento( string mensaje) {…} // Bien! private void EscribirEvento( string mensaje) {…}

2. [VB.NET] Nunca utilizar la declaración explicita de variables con valor Off. Siempre declararla como On Ejemplo : [VB.NET]

'Mal! Option Explicit Off

'Bien! Option Explicit On

3. [VB.NET] Tratar de utilizar la declaración implícita de conversión con valor

On (el valor Off es por defecto). Ejemplo : [VB.NET]

Option Strict On

4. Nunca usar el valor por defecto de la versión del ensamblado (“1.0.*”). Incremente el valor de AssemblyVersionAttribute manualmente.


MINSA Pág.: 21

5. Asignar el valor de ComVisibleAttribute a false para todos los

ensamblados. Después de aquello, dependiendo la necesidad, habilite el atributo ComVisibleAttribute para las clases o métodos.

Ejemplo : [C#] assembly: ComVisible( false )] [ComVisible( true )] public MiClase {…} [VB.NET] <Assembly : ComVisible( False )> <ComVisible( True )> _ Public MiClase { … } 6. NUNCA referenciar circularmente los ensamblados.


MINSA Pág.: 22

7.2 Variables y Tipos 1. Tratar de inicializar las variables cuando las declare. 2. Siempre utilizar los tipos de dato de C# y VB.NET en lugar de los tipos del CTS

de .NET. Ejemplo : [C#] short NO System.Int16 int NO System.Int32 long NO System.Int64 string NO System.String [VB.NET] Short NO System.Int16 Integer NO System.Int32 Long NO System.Int64 String NO System.String 3. Solo declarar a los campos como privados. Usar propiedades para acceder a

los campos privados utilizando los modificadores de acceso de tipo público, protegido o interno.

4. Evitar el uso de números mágicos. En lugar de ello, usar constantes o enumeradores.

5. Evitar declarar variables de cadena con valores literales. En lugar use constantes, recursos, registros de sistema u otro tipo de repositorio de datos.

6. Solo declarar constantes para tipos de datos simples. 7. [C#] Declarar variables readonly o static readonly en lugar de

constantes de tipos complejos. 8. [C#] Evitar utilizar conversiones directas (cast). En su lugar, utilizar el operador

“as ” y verificar por nulos (null ). Ejemplo : [C#]

object data = CargarData(); DataSet ds = dataObject as DataSet; if (ds != null ) {…}

9. Siempre inicializar explícitamente los tipos referenciados en un arreglo al

recorrer un bucle.


MINSA Pág.: 23

10. Evitar encapsular o desencapsular (boxing / unboxing) variables de tipo valor. Ejemplo : [C#] int fila = 1; //Encapsulamiento implicito. object objFila = fila; //Desencapsulamiento explicito. int nuevaFila = ( int )objFila; [VB.NET] Dim fila As Integer = 1 'Encapsulamiento implicito. Dim objFila As Object = fila 'Desencapsulamiento explicito. Dim nuevaFila As Integer = CType(objFila, Integer ) 11. [C#] Tratar de usar el prefijo “@” en las cadenas literales en lugar de utilizar

escapes. 12. Es preferible utilizar StringBuilder en lugar de concatenación de cadenas. 13. No comparar cadenas a String.Empty o “” para verificar cadenas vacías. En

su lugar, comparar por su longitud (String.Length) a cero. 14. Evitar la creación de cadenas ocultas en un bucle. Usar String.Compare()

en su lugar. Ejemplo :

[C#] // Mal! int id = -1; string nombre = “Juan Perez”; for ( int i=0; i<listaClientes.Count; i++) {

if (listaCliente[i].Nombre. ToLower() == nombre) { id = listaCliente[i].Id }

}

// Bien! int id = -1; string nombre = “Juan Perez”; for ( int i = 0; i<listaClientes.Count; i++) { // El argumento “ignoreCase” igual // a true realiza // una comparación sin importarle la // capitalización // de las cadenas y sin alojar una nueva cadena // en memoria.


MINSA Pág.: 24

if (String.Compare(listaCliente[i].Nombre, nombre, true) == 0)

{ id = listaCliente[i].Id; }

} [VB.NET] ' Mal! Dim id As Integer = -1 Dim nombre As String = "Juan Perez" For i As Integer = 0 To listaClientes.Count If listaClientes(i).Nombre.ToLower() = nombre Then id = listaClientes(i).Id

End If Next ' Bien! Dim id As Integer = -1 Dim nombre As String = "Juan Perez" For i As Integer = 0 To listaClientes.Count

' El argumento “ignoreCase” igual ' a True realiza ' una comporación sin importarle la ' capitalización ' de las cadenas y sin alojar una nueva cadena ' en memoria.

If String .Compare(listaClientes(i).Nombre, nombre, True ) = 0 Then id = listaClientes(i).Id End If Next


MINSA Pág.: 25

7.3 Control de Flujos 1. Evitar la creación de métodos recursivos. Utilizar bucle en su lugar. 2. Utilizar el operador condicional ternario solo para condiciones triviales. Evitar

operaciones complejas con este operador. Ejemplo : [C#] int resultado = esValido ? 9 : 4; [VB.NET] Dim resultado As Integer = IIf(esValido, 9, 4)

3. Evitar evaluar condiciones booleanas contra true o false .

Ejemplo : [C#] // Mal! if (esValido == true ) {…} // Bien! i f (esValido) {…} [VB.NET] ' Mal! If esValido = True Then … End If ' Bien! If esValido Then … End If

4. [C#] Evitar asignación de variables en expresiones condicionales.

Ejemplo : [C#]

if (( i=2)==2) {…}

5. Evitar expresiones condicionales complejas, usar variables booleanas para

separar la expresión en expresiones manejables. Ejemplo : [C#] // Mal!

if ((valor > this ._highScore) && (valor != this ._highScore)) && (valor < this ._maxScore))

{…} // Bien! esHighScore = (valor >= this ._highScore); esEmpate = (valor == this ._highScore);


MINSA Pág.: 26

esValido = (valor < this ._maxScore); if ((esHighScore && !esEmpate) && esValido) {…} [VB.NET] ' Mal!

If ((valor > Me.highScore) & (valor <> Me.highScore)) & (valor < Me.maxScore) Then

… End If

' Bien! Dim esHighScore As Boolean = (valor >= Me.highScore) Dim esEmpate As Boolean = (valor = Me.highScore) Dim esValido As Boolean = (valor < Me.maxScore) If (esHighScore And Not esEmpate) And esValido Then …

End If 6. [C#] Solo usar expresiones switch/case para operaciones simples con

condicionales lógicas. 7. [C#] Preferir if/else anidadas sobre switch/case para secuencias

condicionales cortas y condiciones complejas.


MINSA Pág.: 27

7.4 Control de Excepciones 1. No usar los bloques try/catch para control de flujos. 2. Solo capturar las excepciones cuando van a ser controladas. 3. Nunca declarar un bloque catch vacío. 4. Evitar anidar bloques try/catch en otro bloque catch . 5. Usar filtros de excepciones específicas. 6. Ordenar los filtros de excepciones de más especifica a más genérica. 7. Solo usar el bloque finally para liberar recursos utilizados en el bloque try 8. Siempre utilizar validaciones para evitar excepciones. 9. Evitar definir excepciones personalizadas. Usar las clases de excepciones

existentes. 10. Cuando una excepción personalizada es necesaria;

a. Siempre derivar de Exception no de ApplicationException b. Siempre sobrescribir el método ToString() . c. Siempre sobrescribir el operador implicito string cuando se

sobrescriba el método ToString() . d. Siempre implementar los siguientes patrones de constructores

[C#] public MiExcepcion(); public MiExcepcion( string mensaje);

public MiExcepcion(string mensaje, Exception innerException);

11. Cuando se lance una nueva excepción, siempre pasar la innerException para poder mantener la pila de excepciones.

7.5 Eventos, Delegados e Hilos 1. Siempre chequear que las instancias de los eventos y delegados sean

diferentes de nulo. 2. Usar por defecto las clases EventHandler y EventArgs para los eventos

más simples. 3. [C#] Siempre usar la palabra clave “lock ” en lugar del tipo Monitor . 4. Solo bloquear objetos privados o estáticos privados. 5. [C#] Evitar bloquear los tipos de objetos.

Ejemplo : lock ( typeof (MiClase));

6. [C#] Evitar bloquear la instancia actual de un objeto.

Ejemplo : lock ( this );

7.6 Composición de Objetos 1. Siempre declarar los tipos explícitamente con un espacio de nombres. Nunca

usar el espacio de nombres por defecto “{global}”. 2. Evitar declarar métodos con más de 7 parametros. Si fuera necesario

considerar para una estructura o clase.


MINSA Pág.: 28

3. [C#] No usar la palabra reservada “new” para ocultar miembros de tipos derivados.

4. Solo usar la palabra reservada “base ” o “MyBase” cuando se invoque en el constructor o implementación de una sobre escritura de algún método.

5. [C#] No usar el modificador de acceso protected con sealed en las clases. 6. [VB.NET] No usar el modificador de acceso Protected con

NotInheritable . 7. [C#] Considerar usar sobrecarga en lugar de params como parámetro. 8. [C#] Siempre validar una variable de tipo enumerador antes de utilizarla dentro

de un método. Esta variable puede contener cualquier valor que el tipo Enum puede soportar (por defecto es int ).

Ejemplo : [C#] public void Test(CategoriaLibros cat) { if (Enum.IsDefined( typeof (CategoriaLibros),

cat)) {…} }

9. Siempre llamar al método Close() o Dispose() en las clases que lo

implementen. 10. [C#] Utilizar la palabra reservada “using ” para asegurar la llamada al método

Dispose() . 11. [C#] Siempre implementar la interfase IDisposable y su respectivo patrón

en las clases que referencien a recursos externos. Ejemplo : [C#]

using (SqlConnection cn = new SqlConnection(this._connectionString))

{…}


MINSA Pág.: 29

8 Consideraciones de Arquitectura En el desarrollo de aplicaciones empresariales escalables y seguras se encuentran ciertas prácticas conocidas como “mejores prácticas”. En ésta sección se dan pautas generales y lineamientos para lograr este tipo de aplicaciones. Para el caso de aplicaciones empresariales Windows o Web, se debe seguir el siguiente esquema:

Según la figura, podemos concretar dichas capas de la siguiente manera: • Una librería de clases con la capa de acceso a datos y librerías utilitarias. (DAL –

data access layer). • Una librería de clases con la capa de lógica del negocio. (BLL – business logic

layer) • Un proyecto Web o proyecto Windows, dependiendo del tipo de interfaz que se

utilizará en la aplicación (UI). Este proyecto abarca toda la capa de interfaz de usuario y presentación.

8.1 Capa de acceso a datos (DAL) En esta capa deben programarse las clases entidades y controladoras lo suficientemente inteligentes como para manejar el aspecto CRUD (Create, Restore, Update, Delete) de las tablas de la base de datos de la aplicación. Adicionalmente, pueden existir clases utilitarias que permitan la interacción con la base de datos.


MINSA Pág.: 30

8.2 Capa de lógica del negocio (BLL) En esta capa deben crearse clases que interactúan con las clases de la DAL para realizar procesos propios del negocio en base a una lógica determinada. .

8.3 Capa de presentación (UI) En esta capa debe programarse la interfaz de usuario de la aplicación, Específicamente puede ser un proyecto Windows, Web o consola. Aquí se deben realizar las llamadas a la capa de BLL con la información que se captura desde la interfaz. Adicionalmente en esta capa deben realizarse las validaciones de los datos ingresados antes de pasar a otras capas.


MINSA Pág.: 31

9 Framework y herramientas de desarrollo Para la agilización de los proyectos, se recomienda utilizar herramientas que simplifiquen ciertas tareas rutinarias y necesarias en el desarrollo de aplicaciones, es así que se puede utilizar herramientas como:

• Generadores de procedimientos almacenados (stored procedures) • Generadores de clases entidades y controladoras • Generadores de interfaces de usuario • Controles de usuario (usercontrols) y Componentes (dll’s) de terceros.

9.1 Generadores de procedimientos almacenados Las herramientas sugeridas para ésta tarea son:

• MyGenerationSoftware : (http://www.mygenerationsoftware.com/portal/dOOdads/Overview/tabid/63/Default.aspx) y utilizando el framework dOOdads que permite la creación de procedimientos almacenados y clases de acceso a datos en CSharp.

• SubSonic • Sharp Generador • Cooperator Framework • EasyObjects.NET

9.2 Generadores de clases entidades y controladoras Las herramientas sugeridas para ésta tarea son:

• MyGenerationSoftware : (http://www.mygenerationsoftware.com/portal/dOOdads/Overview/tabid/63/Default.aspx) y utilizando el framework dOOdads que permite la creación de procedimientos almacenados y clases de acceso a datos en CSharp.

• SubSonic • Sharp Generador • Cooperator Framework • EasyObjects.NET

9.3 Generadores de interfaces de usuario No se encuentran herramientas por el momento.

9.4 Controles y Componentes Las herramientas sugeridas para ésta tarea son:

• Treeview : http://treeviewadv.sourceforge.net/ • Docking Systems (manejo de ventanas):

http://sourceforge.net/projects/dockpanelsuite/ • Importación de archivos planos: http://www.filehelpers.com/


MINSA Pág.: 32

• Grillas: http://www.devage.com

10 Aplicación práctica de conceptos Para poner en práctica los conocimientos mencionados en los puntos anteriores, sugiere crear una aplicación Windows y Web con el lenguaje CSharp (C#) que permita el mantenimiento de la tabla Clientes, Proveedores y Ordenes de la base de datos Northwind. Las instrucciones son las siguientes:

• Seguir las consideraciones de arquitectura mencionadas anteriormente para la creación del proyecto Windows y web. Se deben crear dos librerías de clases (DAL y BLL) y el proyecto web o Windows.

• Utilizar la herramienta de MyGenerationSoftware para generar los procedimientos almacenados y clases entidades.

• Utilizar los controles sugeridos para la creación de interfaz de usuario. También es válido aportar controles o componentes adicionales que el desarrollador considere.

• Utilizar Visual Studio 2005 y SQL Server 2005. • Utilizar la base de datos Northwind en la versión para SQL Server 2005. Los

scripts de creación de la BD, se pueden descargar desde el website de Microsoft.

• El mantenimiento debe ser de tablas relacionadas en forma Maestro-Detalle, como Cliente-Ordenes o Proveedor-Compras.

• Sugerir mejores prácticas o conocimientos que puedan mejorar el ejemplo.

Estándares y Consideraciones de Desarrollo para Microsoft .NET

Documents

Transcript of Estándares y Consideraciones de Desarrollo para Microsoft .NET