Estándares y Consideraciones de Desarrollo para Microsoft

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
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.: 1
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.: 2
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
http://msdn2.microsoft.com/en-
Best Practices us/library/ms184411(VS.80).aspx
MINSA Pág.: 3
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.: 4
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.: 5
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
Construcción de una clase. Public Class public class MiClase
MiClase {
Public Sub public
New(...) MiClase(...)
MyBase.New {
… …
End Sub }
… …
End Class }
Nota: Se tiene que llamar Nota: La llamada al

explícitamente al constructor de la clase
constructor de la clase padre es generada
padre si es que se automáticamente por el
necesita llamar en compilador en C#,
VB.NET 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 public class A : B
Inherits B {
… …
End Class }
Indica que la clase solo MustInherit abstract

puede ser heredara y no
instanciada.
Indica que la clase no puede NotInheritable sealed
ser heredara.
Llamar a la propia MyClass
implementación de un
método en lugar de llamar al
método sobre en una clase
derivada.
MINSA Pág.: 6
Referir a la clase padre de MyBase base

una clase derivada.
Declarar un delegado Delegate delegate

(referencia segura a un
método)
Indica que el método o la Overrides override
propiedad sobrescriben la
implementación de la clase
padre.
Indica que aquellos métodos MustOverride abstract
no cuentan con (en una clase declarada (en un clase declarada
implementación y deben MustInherit) abstract)
implementarse en clases
derivadas.
Indica que el método o NotOverridable sealed
propiedad no pueden ser Nota: Por defecto, los
sobrescritas en clases métodos no
derivadas. sobrescribibles.
Indica que el método o Overridable virtual

propiedad pueden ser
sobrescritas en clases
derivadas.
Sobrecarga de procesos, Overloads [Se define funciones con el
funciones o métodos. mismo nombre pero con
diferente cantidad de
parametros.]
Especifica que una variable WithEvents
contiene un objeto cuyos
eventos deseas controlar.
Especifica el eventos por cual Handles
un procedimiento o método
va a ser llamado a raíz de
este.
Evalúa una expresión con el With MiObjeto
cual se tienen múltiples <.Miembro>
accesos a los miembros de <.Miembro>
un objeto. End With
Refiere al objeto actual. Me this

Declaración de un tipo Enum enum
enumerado. …
End Enum
Declaración de una interfase. Interface interface

Implementación de una Implements class MiC1ase :
interfase. IDisposable
MINSA Pág.: 7
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 Public public
accesible fuera del proyecto o
de su ensamblado.
Indica que la clase es Friend internal
accesible solo dentro de su
ensamblado.
Indica que la clase solo es Private private
accesible en el proyecto por
clases anidadas dentro de
esta clase.
Modificadores de Acceso
de Miembros de una Clase
Indica que el miembo es Public public
accesible fuera de la clase y
del proyecto.
Indica que el miembro es Friend internal
accesible fuera de la clase
pero no del proyecto.
Indica que el miembro solo es Private private
accesible en el ambito de la
clase.
Indica que el miembro es Protected protected
accesible solo para la clase y
para las clases derivadas
Indica que el miembro es Shared static
compartido a través de todas
las instancias de la clase.
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 Sub void
método sin valor de retorno.
Declaración de un objeto que volatile
puede ser modificado
asincronamente
MINSA Pág.: 8
Declaración explicita de Option Explicit

variables
Declaración de eventos. Event, RaiseEvent event
Declaración de una Structure struct
estructura. …
End Structure
Declaración de objeto nulo. Nothing null

Declaración de un Espacio de Namespace namespace
Nombres. … {
End Namespace …
}
Indica el uso de un espacio Imports using
de nombres.
Devuelve un carácter de una GetChar [ ]
cadena literal.
Devuelve la dirección de una AddressOf delegate
función
Prueba si un objeto es nulo Obj Is Nothing obj == null
Bloqueo de Hilos SyncLock lock
MINSA Pág.: 9
4.2 Convenciones de Nombre
“c” = camelCase
“P” = PascalCase
“_” = Prefijo con raya inferior
“X” = No aplicable
Internal
Identificador Public Protected Friend Private Notas
Coincidir con el
Ensamblado y con el
Archivo Espacio de Nombre
Proyecto P x x x (Namespace).
Coincidir con la clase
Archivo Fuente P x x x que contiene.
Aplicar cuanto sea
Otros Archivos P x x x posible.
Espacio de Coincidir parcialmente
Nombre el
(namespace) P x x x Proyecto/Ensamblado.
Clase o Añadir sufijo de
Estructura P P P P subclase.
Añadir prefijo de I
Interfase P P P P capital.
Clase Usar T o K como
Genérica P P P P identificadores de tipo.
Usar un verbo o pareja
Método P P P P verbo-objeto.
No usar prefijos con
Propiedad P P P P Get o Set.
Solo usar campos
[C#] _c privados. Nunca
Campo P P P [VB.NET] c notación Húngara.
[C#] _c Solo usar campos
Constante P P P [VB.NET] c privados.
Campo [C#] _c
Estático P P P [VB.NET] c
Enumerador P P P P
Delegado P P P P
Evento P P P P
Parametro x x x c
Evitar usar nombres de
Variables un solo carácter o de
internas x x x c enumerados.
MINSA Pág.: 10
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.
[C#] Usar // o /// pero no /* … */ y no utilizar marcos de
asteriscos.
Utilizar /// para comentarios XML de las funciones y métodos.
Comentarios [VB.NET] Usar el ‘ para todo tipo de comentario
Variables Una variable por declaración.
4.4 Uso del Lenguaje
Código Estilo
• Usar datos nativos de datos de C# y VB.NET versus los
Tipos Nativos de Datos
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.: 11
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.: 12
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 • Utilizar estilo de Escritura Pascal
Proyecto • 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 • Estilo de Escritura Pascal

(Namespace) • Tratar de coincidir el nombre ensamblado/proyecto.
Ejemplo:
[C#] namespace Empresa.SistemaWeb
[VB.NET] Namespace Empresa.SistemaWeb
MINSA Pág.: 13
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.: 14
Método • Utilizar estilo de Escritura Pascal

• Tratar de usar un verbo o par verbo-objeto.
Ejemplo:
[C#]
public void Ejecutar() { … }
private string ObtenerVersionEnsamblado(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, • Utilizar estilo de Escritura Pascal

Protegido o • Evitar el uso de campos no privados.
Interno) • 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.: 15
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 • Tratar como campo.
Campo Estático
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.: 16
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.: 17
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.: 18
///]]></code>
///</example>
MINSA Pág.: 19
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.: 20
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.: 21
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.: 22
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.: 23
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.: 24
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!
if (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.: 25
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.: 26
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.: 27
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.: 28
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.: 29
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.: 30
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

• 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

• 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.: 31
• 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.
MINSA Pág.: 32

Estándares y Consideraciones de Desarrollo para Microsoft

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Estándares y Consideraciones de Desarrollo para Microsoft

Încărcat de

Drepturi de autor:

Formate disponibile

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

Estándares y Consideraciones de Desarrollo para

Autor : Eduardo Rivera Alva

Específicamente este documento cubre convenciones de nombres, estilos de

Design Guidelines for Class

2 Convenciones del Documento

En seguida algunas de las convenciones usadas a través del documento.

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

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

Tratar Enfatiza que la regla debe de cumplirse siempre y cuando

Ejemplo Precede el texto usado para ilustrar la regla o

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

Aunque los modificadores de acceso varían, las clases y la mayoría de

Common Type System (CTS)

4.1 Equivalencias entre C# y VB.NET

Nota: Se tiene que llamar Nota: La llamada al

Indica que la clase solo MustInherit abstract

Referir a la clase padre de MyBase base

Declarar un delegado Delegate delegate

Indica que el método o Overridable virtual

Refiere al objeto actual. Me this

Declaración de una interfase. Interface interface

Indicador de índice. Default Property public string

Declaración explicita de Option Explicit

Declaración de objeto nulo. Nothing null

4.2 Convenciones de Nombre

4.3 Estilos de Codificación

4.4 Uso del Lenguaje

5.1 Recomendaciones Generales

1. Siempre usar nombres con estilo de escritura CamelCase o PascalCase.

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

5.2 Uso de nombres y sintaxis

Identificador Convención de Nombramiento

Archivo Fuente • Utilizar estilo de Escritura Pascal

Archivo de Recurso • Tratar de utilizar estilo de escritura Pascal.

Espacio de Nombre • Estilo de Escritura Pascal

Clase o Estructura • Utilizar estilo de Escritura Pascal

Friend Class CoordenadaAttribute

Public Class ClienteCollection

Public Class ClienteEventArgs

Private Structure PropiedadesAplicacion

Interfase • Utilizar estilo de Escritura Pascal

Método • Utilizar estilo de Escritura Pascal

Private Function ObtenerVersionEnsamblado(ByVal

Propiedad • Utilizar estilo de Escritura Pascal

Campo (Público, • Utilizar estilo de Escritura Pascal

Delegado o Evento • Tratar como campo.

1. Nunca declarar más de un espacio de nombres por archivo.

8. Agrupar la implementación interna de las clases por el tipo de miembros en

9. Ordenar las declaraciones a partir de los modificadores de acceso y

12. Recursivamente indentar todos lo bloques de código en medio de llaves.

1. [C#] Usar // o /// pero no /* … */

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

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

7 Uso del Lenguaje

1. [C#] Nunca omitir los modificadores de acceso. Declare explícitamente

2. [VB.NET] Nunca utilizar la declaración explicita de variables con valor Off.

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

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

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