View
108
Download
17
Category
Preview:
Citation preview
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
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.: 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
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.: 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
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.: 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.
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.: 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.
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.: 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
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.: 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
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.: 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
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.: 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
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.: 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.
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.: 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 ().
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.: 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
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.: 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
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.: 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
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.: 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
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.: 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
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.: 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.
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.: 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>
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.: 19
/// ]]></code> ///</example>
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.: 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.
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.: 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.
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.: 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.
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.: 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.
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.: 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
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.: 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);
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.: 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.
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.: 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.
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.: 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))
{…}
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.: 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.
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.: 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.
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.: 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/
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.: 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.
Recommended