Estndar de Desarrollo

Table of contents
Introduccin.......................................................................................................3
Alcance..........................................................................................................3
Empezando........................................................................................................3
System requirements.....................................................................................3
Estilo..............................................................................................................4
Codificacin.......................................................................................................5
Pautas Generales...........................................................................................5
Notacin........................................................................................................6
Conceptos..................................................................................................8
Notacin CamelCase..................................................................................9
Definicin, su mbito o Alcance..................................................................10
Definicin de Variables................................................................................10
Definicin de Constantes.............................................................................10
Definicin de Enumeradores........................................................................10
Definicin de una Clase...............................................................................10
C#....................................................................................................................10
Buenas Practicas..........................................................................................10
Notacin......................................................................................................11
Identacion, Espaciado y Agrupacin............................................................12
Comentarios................................................................................................14
Test Unitario.................................................................................................15
Convenciones..............................................................................................16
Nomenclatura..........................................................................................16
Diseo......................................................................................................16
Comentarios............................................................................................16
Lenguaje..................................................................................................16
ASP NET...........................................................................................................21
TERMINOLOGIA................................................................................................23

Introduccin

En el presente documento se definirn los estndares de programacin para las Aplicaciones .NET bajo
las 3 Capas de Desarrollo de Aplicaciones: Presentacin, Reglas de Negocio y Acceso a Datos.
Asimismo, el presente documento pretende ser una Gua General de Estndares para el desarrollo de toda
Aplicacin basada en Tecnologa .NET.
Created with the Personal Edition of HelpNDoc: Easily create Web Help sites

Alcance
Este documento describe reglas y recomendaciones para el desarrollo de aplicaciones y libreras de clases
usando el lenguaje C#, Visual Basic y ASP. La meta es definir lneas guas para enmarcar la consistencia
de estilo y de formato y ayudar a los desarrolladores a evitar errores comunes.
A pesar de ser un tema complejo, crear estndares para la programacin puede ser de mucha utilidad para
desarrolladores dentro de la organizacin, es por eso que estos estndares deben tender a lo prctico.
Las tcnicas mencionadas en el presente trabajo, no pretenden forman conjuntos inflexibles de
estndares, ms bien, intenta servir de gua en el desarrollo de un estndar para este proyecto especfico
de software o para un conjunto de proyectos con similares caractersticas.
Abarcar los conceptos de nomenclaturas, definicin de variables, mtodos, manejo de errores y
comentarios as como algunas buenas prcticas de programacin
Establecer la nomenclatura: nombrar proyectos, archivos de cdigo fuente, e identificadores incluyendo
campos, variables, propiedades, mtodos, parmetros, clases, interfases y espacios de nombres
(Namespaces).

Created with the Personal Edition of HelpNDoc: Easily create Help documents

Empezando
Created with the Personal Edition of HelpNDoc: Produce Kindle eBooks easily

System requirements

Ide
Visual Studio .NET 2008

Lenguaje de Programacin
Lenguaje C#

Created with the Personal Edition of HelpNDoc: Produce electronic books easily

Estilo

Formato
1. Nunca declarar ms de un espacio de nombres por archivo.
2. Evitar colocar mltiples clases en un mismo archivo.
3. Siempre colocar llaves ({ y }) en lneas separadas a excepcin de cuando se declaran las
propiedades Get y Set.
4. Declarar cada variable independientemente nunca en la misma sentencia.
5. Colocar la sentencia using 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
alfabticamente.
Ejemplo:
using System;
using System.Collections
using System.Data;
using System.Data.SqlClient;
using System.Xml;
using Gustozzi.BE;
using Acceso_a_Datos;

Comentarios
1. Usar // o /// pero no /* */
2. No utilizar marcos de asteriscos.
Ejemplo:
//******************************************
// Cuadro de comentarios
//******************************************
3. Tratar de usar comentarios en el interior de los mtodos para explicar aspectos globales del algoritmo.
4. No utilizar comentarios para explicar cdigo obvio.

Uso del Lenguaje

1.
Nunca omitir los modificadores de acceso. Declare explcitamente todos los mtodos con su
apropiado modificador de acceso en lugar de dejarlo con el de por defecto.
Ejemplo:
// Mal!
void Escribir_Evento(string mensaje)
{}
// Bien!
private void Escribir_Evento(string mensaje)
{}
2.

Tratar de inicializar las variables cuando las declare.

string strVariable System.String

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

Solo declarar constantes para tipos de datos simples.

8.

Siempre inicializar explcitamente los tipos referenciados en un arreglo al recorrer un bucle.

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 match vaco.

4.

Evitar anidar bloques try/catch en otro bloque catch.

5.

Ordenar los filtros de excepciones de ms especfica a ms genrica.

6.

Evitar el relanzamiento de excepciones.

7.

Solo usar el bloque finally para liberar recursos utilizados en el bloque try

8.

Siempre utilizar validaciones para evitar excepciones.

Created with the Personal Edition of HelpNDoc: Easily create EPub books

Codificacin
Created with the Personal Edition of HelpNDoc: Full-featured Help generator

Pautas Generales

Pautas Generales
1. Evitar nombres totalmente en MAYSCULAS o en minsculas a menos que estos sean de una sola
palabra.
2. Nunca usar nombres que comiencen con caracteres numricos.
3. Todos los nombres a utilizar deben ser especficos y deben tener el largo necesario para ser
entendidos.
4. Evitar el uso de abreviaturas a menos que el nombre completo sea excesivo. En los casos necesarios,
las abreviaturas deben ser totalmente conocidas y aprobadas por todos los integrantes.
5. Nunca usar palabras reservadas para nombres.

Prefijo de Controles

Prefijo (minsculas)
bto
txt
grv

Objeto/Control
Boton
TextBox
GridView

lbl

Label

lst

ListBox

cr

CrystalReportViewer

wf

WebForm

ddwn

DropDownList

Sufijo de las clases

1. Todos los nombres de las entidades del negocio deben llevar el prefijo be seguido de un nombre que
la defina claramente con la primera letra en maysculas. Ejm: beEquipo
2. Los nombres de clases de la lgica del negocio llevaran el prefijo bl seguido de un nombre que
empiece con maysculas y que la identifique claramente. Ejm: blEquipo
3. Las clases de acceso a datos sern nombrados con el prefijo dal seguido de un nombre que empiece
con maysculas y que la identifique claramente. Ejm: dalEquipo
4. Los formularios web empezaran con el sufijo wf seguido de un nombre que describa el caso de uso
que representa. Ejm: wfRegistrarEquipo

Variables
Los nombres de variables iniciarn con la descripcin del tipo que las contendr seguido de un nombre
que las especifique claramente sin llegar a ser demasiado extenso.

Created with the Personal Edition of HelpNDoc: Free iPhone documentation generator

Notacin

I. Resumen
Notacin
Pascal

Camel
Hngara

Descripcin
Especifica que la primera letra de cada palabra
utilizada en el identificador debe estar en
maysculas.
Tiene dos variantes: UpperCamel (igual que
Pasca) y LowerCamel (camel por si misma)
Es similar a la notacin Pascal pero con prefijos;
estos prefijos significan el tipo del identificador.

Ejemplos
PrecioMinimo, ValorDeuda, SaldoCliente,
MontoAcumuladoActual
lowerCamel: saldoCliente, precioLista,
montoAcumuladoActual
curSaldoCliente, strCodigoArticulo

Camel Case
Es quizs la ms famosa y la que, aparte de los lenguajes de programacin, tambin se le he visto fuera
de estas. Existen en principio dos variantes de esta notacin, la UpperCamelCase y la lowerCamelCase.
La principal diferencia entre ambas es que en el caso del upper la primera letra siempre se escribir en
mayscula mientras que en la segunda la primera palabra siempre ser entera en minsculas.

Pascal
Es igual que la UpperCamel.

Hngara
La notacin hngara est basada en parte en CamelCase, especficamente la lowerCamelCase. En su
versin ms bsica, tenemos varios tipos de datos los que reciben una letra. De esa forma, un string
recibir la letra s, un int la letra i, un decimal la letra d. Un arreglo recibir por supuesto la letra a.

Teniendo eso en cuenta, y combinndola con la CamelCase no resulta difcil pensar en qu sigue: Un
nombre cualquiera para nuestra variable siguiendo las reglas del CamelCase.
De esta forma, podemos tener:
aIndicadorResultados
iContador
sPrimerNombre
De esta forma, con slo una mirada podemos saber de qu tipo es nuestra variable, y mediante
CamelCase (asignndole un nombre significativo) podremos saber cul es su funcin, lo cual encuentro
ideal en un lenguaje como PHP donde una misma variable puede ser un float o un bit al momento
siguiente.

Lenguaje de Programacin
Identifier
Namespace
Classes
Interface

Casing
Pascal
Pascal
Pascal

Method

Pascal

Property
Public

Pascal

Example
namespace System.Security { ... }
public class StreamReader { ... }
public interface IEnumerable { ... }
* Lleva siempre la "I" inicial
public class Object {
public virtual string ToString();
}
public class String {
public int RecordID { get; }
}

Property
Private

"_"+LCamel

public class String {

public int _recordID { get; }
}
* el guin bajo se puede obviar.
public class Process {
public event EventHandler Exited;
}

Event

Pascal

Field

Pascal

public class MessageQueue {

public static readonly TimeSpan
InfiniteTimeout;
}
public struct UInt32 {
public const Min = 0;
}

Enum value

Pascal

public enum FileMode {

Append,
...
}

Parameter

LCamel

public class Convert {

public static int ToInt32(string value);
}

Base de Datos
Identifier
Nombre de
tabla

Casing
Pascal

Atributos
(campos)
Funciones

LCamel

Stored
Procedures

prefijo+P
ascal

Pascal

Parmetros
LCamel
en SP
Vistas
prefijo+Pasc
al

Example
Modulo, Cliente, Usuario, OrdenVenta, OrdenCompra,
Importacion
* En singular; sin tildes
* Nombre de Funcionalidad o Entidad
idRegistro, fechaRegistro, apellidoPaterno
* No abreviaturas, salvo prefijos autorizados
ContarPalabras, ValidaRUC, ExtraeTexto
* Caracter genrico, altamente reutilizable
procClienteInserta
getSaldoVencido
updOrdenCompra
@idCliente
vwClienteFacturacion

Abreviaturas autorizadas
Abreviatur
a
id

Ambito

Explicacin

propiedades

Identificacin de un registro o entidad. Puede ser

numerica o alfanumerica.

Notaciones:

Pascal (UpperCamel)
camel (lowerCamel)

Created with the Personal Edition of HelpNDoc: Full-featured multi-format Help generator

Conceptos

Resumen
Notacion
Pascal

Descripcin
Especifica que la primera letra de cada palabra

Ejemplos
PrecioMinimo, ValorDeuda, SaldoCliente,

Camel
Hungara

utilizada en el identificador debe estar en

maysculas.
Tiene dos variantes: UpperCamel (igual que
Pasca) y LowerCamel (camel por si misma)
Es similar a la notacin Pascal pero con prefijos;
estos prefijos significan el tipo del identificador.

MontoAcumuladoActual
lowerCamel: saldoCliente, precioLista,
montoAcumuladoActual
curSaldoCliente, strCodigoArticulo

Camel Case
Es quizs la ms famosa y la que, aparte de los lenguajes de programacin, tambin se le he visto fuera
de estas. Existen en principio dos variantes de esta notacin, la UpperCamelCase y la lowerCamelCase.
La principal diferencia entre ambas es que en el caso del upper la primera letra siempre se escribir en
mayscula mientras que en la segunda la primera palabra siempre ser entera en minsculas.

Pascal
Es igual que la UpperCamel.

Hngara
La notacin hngara est basada en parte en CamelCase, especficamente la lowerCamelCase. En su
versin ms bsica, tenemos varios tipos de datos los que reciben una letra. De esa forma, un string
recibir la letra s, un int la letra i, un decimal la letra d. Un arreglo recibir por supuesto la letra a.
Teniendo eso en cuenta, y combinndola con la CamelCase no resulta difcil pensar en qu sigue: Un
nombre cualquiera para nuestra variable siguiendo las reglas del CamelCase.
De esta forma, podemos tener:
aIndicadorResultados
iContador
sPrimerNombre
De esta forma, con slo una mirada podemos saber de qu tipo es nuestra variable, y mediante
CamelCase (asignndole un nombre significativo) podremos saber cul es su funcin, lo cual encuentro
ideal en un lenguaje como PHP donde una misma variable puede ser un float o un bit al momento
siguiente.

Created with the Personal Edition of HelpNDoc: Easily create EBooks

Notacin CamelCase
CamelCase es la prctica de escribir palabras compuestas o frases en las que las palabras estn unidas
sin espacios como por ejemplo BreakFast, myName etc.
CamelCase se llama as debido a que cada palabra en el identificador se junta sin espacios, pero con la
primera letra de cada palabra en mayuscula, mirando como jorobas de un camello.
Hay dos variedades en CamelCase: UpperCamelCase y lowerCamelCase.
En las variables, referencias, nombres de mtodos se declaran en lowerCamelCase.
int animalCount;//Variable declared using lowerCamelCase
public abstract int getAnimalCount();//Method defined using UpperCamelCase
UpperCamleCase tambin se llama como notacin Pascal.
La nica diferencia entre el LowerCamelCase y UpperCamelCase (notacin Pascal) es que la primera letra
de la palabra compuesta se capitaliza (escribe en mayuscula). En algunos lenguajes de programacin los
nombres de clase se declaran en notacin UpperCamelCase.
class AnimalTest //Observe the UpperCamelCase notation used for declaring the class name
{

String name;
public AnimalTest(String name)
{
this.name=name;
}
}
Microsoft .NET recomienda UpperCamelCase para la mayora de los identificadores (lowerCamelCase se
recomienda para los parmetros y variables) y es una convencin comn de los lenguajes .NET.

Created with the Personal Edition of HelpNDoc: Easy EPub and documentation editor

Definicin, su mbito o Alcance

Created with the Personal Edition of HelpNDoc: Free help authoring tool

Definicin de Variables
Created with the Personal Edition of HelpNDoc: Free EPub producer

Definicin de Constantes
Created with the Personal Edition of HelpNDoc: Free help authoring tool

Definicin de Enumeradores
Created with the Personal Edition of HelpNDoc: Full-featured Documentation generator

Definicin de una Clase

Created with the Personal Edition of HelpNDoc: Produce Kindle eBooks easily

C#
Created with the Personal Edition of HelpNDoc: Easy EPub and documentation editor

Buenas Practicas
1. En C#: Utilizar tipos especficos de C# (alias) en lugar de los tipos definidos en el namespace System.

2. Para comparar dos strings se debe utilizar el String.Equal pasando cmo parmetro el
StringComparison para evitar diferencias entre maysculas y minsculas, as como tambin las
diferentes culturas.
3. Utilizar String.Empty en lugar de .
4. Evitar mtodos y propiedades pblicas, a menos que sea estrictamente necesario el acceso desde
afuera de la clase. Utilizar el keyword internal si estos miembros deben ser accedidos desde dentro del
mismo assembly.

5. Utilizar el archive AssemblyInfo para completar informacin como Nmero de versin, Descripcin,
Compaa, Copyright, etc.
6. Al abrir conexiones a bases de datos, Sockets, Streams, etc. siempre cerrarlos en los bloques finally.
Esto asegurar que an ante la eventualidad de una excepcin, estos accesos sern cerrados. Se
puede usar el Using en caso de no tener que capturar una excepcin en particular dentro del catch.
7. La declaracin de las variables locales de un mtodo, deber realizarse en el bloque superior de ste.
Todas las variables deben estar declaradas en el mismo lugar y deben ser iniciadas para limpiar su
valor predeterminado.
8. Utilizar la clase StringBuilder en lugar de String cuando sea requerido manipular cadenas en loops y
en operaciones de concatenacin intensivas ya que ste reporta una mejor performance. En caso de
tratarse de concatenaciones simples, utilizar String.Concat.
9. Utilizar el largo de cadenas para determinar si stas son vacas, en lugar de realizar una comparacin
con una cadena vaca. Si la variable puede tener el valor null, es posible tambin utilizar el mtodo
String.IsNullOrEmpty para realizar esta verificacin:
if ( String.IsNullOrEmpty(customerName))
Created with the Personal Edition of HelpNDoc: Easily create CHM Help documents

Notacin
CRITERIOS DE CODIFICACION
Los trminos Pascal Casing y Camel Casing son utilizados a lo largo de esta seccin.
Pascal Casing: Establece que el primer carcter de todas las palabras se expresa en mayscula y el resto
de los caracteres en minscula, por ejemplo: CustomerOrder.
Camel Casing: Define que el primer carcter de todas las palabras, excepto la primera palabra se expresa
en mayscula y el resto de los caracteres en minscula, por ejemplo: customerOrder.
NOMENCLATURA
1. Se deber utilizar Pascal Casing para los nombres de clases y para los nombre de los mtodos

2. El nombre del archivo debe coincidir con el nombre de la clase y debe respetar la notacin Pascal
Casing.
3. Se deber utilizar Camel casing para nombrar variables y parmetros de mtodos.

4. Se deber utilizar Pascal Case para nombrar constantes.

5. Se deber utilizar Pascal Case para nombrar enumerados y su nombre debe estar expresado en
forma singular (de igual forma estn definidos en el .net framework). Cada miembro del enumerado
deber tambin ser nombrado utilizando Pascal Case y deber siempre tener un valor asignado
explcitamente.

6. Utilizar el prefijo I con Pascal Casing para nombrar Interfaces ( Ejemplo: IUser)
7. No se debe anteponer ningn prefijo que represente el tipo de datos de variables o constantes.
8. No utilice caracteres de subrayado (_) para nombres de variables locales.

9. Todas las variables de miembros deben estar precedidas por el carcter de subrayado (_) de modo
que puedan diferenciarse de otras variables locales.
10. Utilizar prefijos como is o similares al nombrar variables de tipo bool.
private bool isFinished;
11. Evite los nombres completo de tipo, en su lugar utilice la instruccin using.
12. Con los genricos, use maysculas para los tipos

13. Se debe respetar el siguiente patrn de nomenclatura para los elementos de interfaz de usuario, de
modo que se les pueda diferenciar del resto de las variables. Se agregar un prefijo que haga
referencia al tipo de control que se nombra, segn la siguiente lista:

14. Evite casting explicito. Use el operator as para castear un tipo.

Created with the Personal Edition of HelpNDoc: Easy to use tool to create HTML Help files and
Help web sites

Identacion, Espaciado y Agrupacin

1. Utilice TAB de 4 posiciones para indentar cdigo. No utilice espacios.
2. Los comentarios deben estar en el mismo nivel que el cdigo, es decir que han de utilizar el mismo
nivel de indentacin.
3. Las llaves de apertura y cierre deben estar en el mismo nivel que el cdigo fuera de stas.
4. Utilice una lnea en blanco para separar grupos lgicos de cdigo.

5. Una nica lnea en blanco debe separar un mtodo de otro, dentro de una clase.
6. Las llaves deben estar en una lnea independiente y no en la misma lnea que if, for, etc.
7. Utilizar un nico espacio antes y despus de cada operador, as como tambin entre trminos
utilizados durante la invocacin de mtodos.

8. Mantener las variables de miembro, propiedades y mtodos en la parte superior del archivo, y
miembros pblicos en la parte inferior del mismo.
9. Utilizar #region para agrupar piezas de cdigo relacionadas. Si se utiliza la agrupacin adecuada
mediante #region, una clase o pgina deber lucir solamente con las regiones cuando todas las
definiciones se contraigan. Mantener las variables miembro privadas, las propiedades y mtodos
privados en la parte superior del archivo y los miembros pblicos en la parte inferior.

Created with the Personal Edition of HelpNDoc: Easily create Web Help sites

Comentarios
Comentarios correctos y significativos hacen al cdigo ms mantenible, sin embargo, se han de seguir los
siguientes lineamientos:
1. No comentar todas y cada una de las lneas de cdigo ni cada variable declarada.
2. Utilizar // o /// para introducir comentarios. Evitar usar /* */ con comentarios de bloque.
3. Escribir comentarios donde sea requerido. Tener en cuenta que el buen cdigo legible requerir de
pocos comentarios. Si todas las variables, mtodos, constantes tienen nombres significativos, esto har
que el cdigo sea fcilmente legible y no requiera de la introduccin de comentarios en exceso.
4. No escribir comentarios en porciones en las que el cdigo es fcilmente entendible y no requiere de
conocimiento especfico para su comprensin.
5. Si se debe utilizar lgica de negocio, se debe documentar correctamente con suficientes comentarios.
6. Si se inicializa una variable a un nmero especial distinto de 0, -1, String.Empty o Null, se deber
documentar la razn por la que se ha escogido dicho valor.
7. Corroborar ortografa, gramtica y semntica de los comentarios, asegurndose de que la puntuacin
es utilizada correctamente.
8. Agregar la documentacin del encabezado de cada mtodo (utilizando ///), especificando
correctamente:
El propsito del mtodo

Nombre, Tipo de datos y Contenido de cada parmetro recibido

El propsito de la informacin retornada
Esto es particularmente til para generar documentacin de forma automtica, a partir de estos
comentarios.

Encabezado de
seccin
Finalidad
Premisas
Efectos

Descripcin del comentario

Lo que hace el procedimiento (no cmo lo
hace).
Lista de cada variable externa, control, archivo
abierto o cualquier otro elemento que no sea
obvio.
Lista de cada variable externa, control o archivo
afectado y el efecto que tiene (slo si no es

Entradas
Resultados

obvio).
Todos los argumentos que puedan no ser
obvios. Los argumentos se escriben en una
lnea aparte con comentarios de lnea.
Explicacin de los valores devueltos por las
funciones.

Created with the Personal Edition of HelpNDoc: Free PDF documentation generator

Test Unitario
Cada una de las operaciones desarrolladas deber contar con tantos test unitarios como escenarios de
prueba se deseen.
Creacin de test unitarios
Cada test unitario deber ser creado bajo la carpeta ProjectoName\Tests, y categorizado (en la forma de
proyecto) en funcin del mdulo al que corresponda.
A su vez, dentro de cada proyecto de test, se deber crear una carpeta con el mismo nombre del proyecto
en el que se encuentra la clase para la cual se desea crear el Test.
Cada archivo correspondiente a un test unitario, deber ser nombrado respetando el siguiente patrn:
UnitTest + [Nombre Clase que se testea]
Cada nombre de mtodo cumplir con la forma Test_ + [Nombre Mtodo] + [Descripcin de Entrada]
Ejemplos:
Los test unitarios correspondientes al mdulo de Customers, debern ser colocados bajo la carpeta
ProjectoName\Tests en el proyecto Customers.
Si se desea verificar el mtodo ValidateCustomer de una clase de nombre CustomerServices,
correspondiente al mdulo Customers se seguirn los siguientes pasos:
Se crear la clase UnitTestCustomerServices y se ubicar en Projecto\Tests\Customers.
Dentro de la clase antedicha, se crear el mtodo de Test_ValidateCustomer_InvalidNumbers.
Se agregar cdigo para verificar que la validacin de clientes opera de acuerdo a lo esperado cuando
recibe ingresos no vlidos.
Alcance de la validacin
Cada mtodo de validacin que sea creado debe contemplar los casos que se tracen como posibles
escenarios de ejecucin vlidos, incluyendo casos de borde

Organizacin de Tests
Para cada mdulo de la solucin se deber crear una Test List (Men Test, Create Test List) que incluya
todos los test asociados al mdulo. Esto permitir que los mismos sean administrados de forma conjunta.
Prcticas recomendadas
1. Evitar crear dependencias entre tests que impliquen que deban ser ejecutados en un orden particular.
Cada test unitario debe ser independiente.
2. Asegurarse de que los tests cubren todas las operaciones definidas en cada servicio.
3. Crear una clase de test para cada una de las clases que se desean verificar. Esto simplificar la
organizacin de los tests y facilitar la tarea de seleccionar la ubicacin de cada uno de ellos.
4. Evitar crear tests que involucren informacin especfica del equipo, como por ejemplo versiones de
software, tipo de arquitectura de procesador, rutas de acceso.
5. Ejecutar absolutamente todos los test desarrollados, cuando se realicen cambios, antes de hacer
check-in y previo al empaquetado de una nueva versin.

Created with the Personal Edition of HelpNDoc: Easily create HTML Help documents

Convenciones
Created with the Personal Edition of HelpNDoc: Free EPub producer

Nomenclatura
Created with the Personal Edition of HelpNDoc: Create iPhone web-based documentation

Diseo
Un buen diseo utiliza un formato que destaque la estructura del cdigo y haga que el cdigo sea ms fcil
de leer. Las muestras y ejemplos de Microsoft cumplen las convenciones siguientes:
1. Utilice la configuracin del Editor de cdigo predeterminada (sangra automtica, sangras de 4
caracteres, tabulaciones guardadas como espacios). Para obtener ms informacin, vea Opciones,
editor de texto, C#, formato.
2. Escriba solo una instruccin por lnea.
3. Escriba solo una declaracin por lnea.
4. Si a las lneas de continuacin no se les aplica sangra automticamente, hgalo con una tabulacin
(cuatro espacios).
5. Agregue al menos una lnea en blanco entre las definiciones de mtodo y las de propiedad.
6. Utilice parntesis para que las clusulas de una expresin sean evidentes, como se muestra en el
cdigo siguiente.

Created with the Personal Edition of HelpNDoc: Easily create iPhone documentation

Comentarios
1.
2.
3.
4.

Coloque el comentario en una lnea independiente, no al final de una lnea de cdigo.

Comience el texto del comentario con una letra mayscula.
Finalice el texto del comentario con un punto.
Inserte un espacio entre el delimitador de comentario (//) y el texto del comentario, como se muestra
en el ejemplo siguiente.
// The following declaration creates a query. It does not run
// the query.

5. No cree bloques con formato de asteriscos alrededor de comentarios.

Created with the Personal Edition of HelpNDoc: Easy EBook and documentation generator

Lenguaje
En las secciones siguientes se describen las prcticas que sigue el equipo C# para preparar las muestras
y ejemplos de cdigo.

String (Tipo de datos)

Utilice el operador + para concatenar cadenas cortas, como se muestra en el cdigo siguiente.
string displayName = nameList[n].LastName + ", " + nameList[n].FirstName;

Para anexar cadenas en bucles, especialmente cuando se trabaja con grandes cantidades de texto,
utilice un objeto StringBuilder.
var phrase = "lalalalalalalalalalalalalalalalalalalalalalalalalalalalalala";
var manyPhrases = new StringBuilder();
for (var i = 0; i < 10000; i++)
{
manyPhrases.Append(phrase);
}
//Console.WriteLine("tra" + manyPhrases);

Variables locales con asignacin implcita de tipos

Utilice tipos implcitos para las variables locales cuando el tipo de la variable sea obvio desde el lado
derecho de la asignacin, o cuando el tipo exacto no sea importante.
// When the type of a variable is clear from the context, use var
// in the declaration.
var var1 = "This is clearly a string.";
var var2 = 27;
var var3 = Convert.ToInt32(Console.ReadLine());
No utilice var cuando el tipo no sea evidente desde el lado derecho de la asignacin.
// When the type of a variable is not clear from the context, use an
// explicit type.
int var4 = ExampleClass.ResultSoFar();
No confe en el nombre de variable para especificar el tipo de la variable. Puede no ser correcto.
// Naming the following variable inputInt is misleading.
// It is a string.
var inputInt = Console.ReadLine();
Console.WriteLine(inputInt);
Evite el uso de var en lugar de dynamic.
Utilice tipos implcitos para determinar el tipo de la variable de bucle en bucles for y foreach.
En el ejemplo siguiente se usan tipos implcitos en una instruccin for.
var syllable = "ha";
var laugh = "";
for (var i = 0; i < 10; i++)
{
laugh += syllable;
Console.WriteLine(laugh);
}

En el ejemplo siguiente se usan tipos implcitos en una instruccin foreach.

foreach (var ch in laugh)
{
if (ch == 'h')
Console.Write("H");
else
Console.Write(ch);
}
Console.WriteLine();
Tipo de datos sin signo
En general, utilice int en lugar de tipos sin signo. El uso de int es comn en todo C#, y es ms fcil
interactuar con otras bibliotecas cuando se usa int.
Matrices

Utilice sintaxis concisa para inicializar las matrices en la lnea de declaracin.

// Preferred syntax. Note that you cannot use var here instead of string[].
string[] vowels1 = { "a", "e", "i", "o", "u" };
// If you use explicit instantiation, you can use var.
var vowels2 = new string[] { "a", "e", "i", "o", "u" };
// If you specify an array size, you must initialize the elements one at a time.
var vowels3 = new string[5];
vowels3[0] = "a";
vowels3[1] = "e";
// And so on.

Delegados
Utilice sintaxis concisa para crear instancias de un tipo de delegado.
// First, in class Program, define the delegate type and a method that
// has a matching signature.
// Define the type.
public delegate void Del(string message);
// Define a method that has a matching signature.
public static void DelMethod(string str)
{
Console.WriteLine("DelMethod argument: {0}", str);
}
// In the Main method, create an instance of Del.
// Preferred: Create an instance of Del by using condensed syntax.
Del exampleDel2 = DelMethod;
// The following declaration uses the full syntax.
Del exampleDel1 = new Del(DelMethod);
Instrucciones try-catch y using en el control de excepciones

Utilice una instruccin try-catch en la mayora de casos de control de excepciones.

static string GetValueFromArray(string[] array, int index)
{
try
{
return array[index];
}
catch (System.IndexOutOfRangeException ex)
{
Console.WriteLine("Index is out of range: {0}", index);
throw;
}
}

Simplifique el cdigo mediante el uso de la instruccin using de C#. Si tiene una instruccin try-finally
en la que el nico cdigo del bloque finally es una llamada al mtodo Dispose, utilice en su lugar una
instruccin using.
// This try-finally statement only calls Dispose in the finally block.
Font font1 = new Font("Arial", 10.0f);
try
{
byte charset = font1.GdiCharSet;
}

finally
{
if (font1 != null)
{
((IDisposable)font1).Dispose();
}
}
// You can do the same thing with a using statement.
using (Font font2 = new Font("Arial", 10.0f))
{
byte charset = font2.GdiCharSet;
}
Operadores && y ||
Para evitar excepciones y aumentar el rendimiento omitiendo las comparaciones innecesarias, utilice
&& en lugar de & y || en lugar de | cuando realice comparaciones, como se muestra en el ejemplo
siguiente.
Console.Write("Enter a dividend: ");
var dividend = Convert.ToInt32(Console.ReadLine());
Console.Write("Enter a divisor: ");
var divisor = Convert.ToInt32(Console.ReadLine());
// If the divisor is 0, the second clause in the following condition
// causes a run-time error. The && operator short circuits when the
// first expression is false. That is, it does not evaluate the
// second expression. The & operator evaluates both, and causes
// a run-time error when divisor is 0.
if ((divisor != 0) && (dividend / divisor > 0))
{
Console.WriteLine("Quotient: {0}", dividend / divisor);
}
else
{
Console.WriteLine("Attempted division by 0 ends up here.");
}
New (Operador)
Utilice la forma concisa de la creacin de instancias de objeto con tipos implcitos, como se muestra en
la siguiente declaracin.
var instance1 = new ExampleClass();
La lnea anterior es equivalente a la siguiente declaracin.
ExampleClass instance2 = new ExampleClass();

Utilice inicializadores de objeto para simplificar la creacin de objetos.

// Object initializer.
var instance3 = new ExampleClass { Name = "Desktop", ID = 37414,
Location = "Redmond", Age = 2.3 };
// Default constructor and assignment statements.
var instance4 = new ExampleClass();
instance4.Name = "Desktop";
instance4.ID = 37414;
instance4.Location = "Redmond";
instance4.Age = 2.3;

Control de eventos
Si va a definir un controlador de eventos que no es necesario quitar ms tarde, utilice una expresin
lambda.

public Form2()
{
// You can use a lambda expression to define an event handler.
this.Click += (s, e) =>
{
MessageBox.Show(
((MouseEventArgs)e).Location.ToString());
};
}
// Using a lambda expression shortens the following traditional definition.
public Form1()
{
this.Click += new EventHandler(Form1_Click);
}
void Form1_Click(object sender, EventArgs e)
{
MessageBox.Show(((MouseEventArgs)e).Location.ToString());
}
Miembros estticos
Llame a miembros estticos con el nombre de clase: ClassName.StaticMember. Esta prctica hace que el
cdigo sea ms legible al clarificar el acceso esttico. No califique un miembro esttico definido en una
clase base con el nombre de una clase derivada. Mientras el cdigo se compila, su legibilidad se presta a
confusin, y puede interrumpirse en el futuro si se agrega a un miembro esttico con el mismo nombre a la
clase derivada.
Consultas LINQ
Utilice nombres descriptivos para las variables de consulta. En el ejemplo siguiente, se utiliza
seattleCustomers para los clientes que se encuentran en Seattle.
var seattleCustomers = from cust in customers
where cust.City == "Seattle"
select cust.Name;

Utilice alias para asegurarse de que los nombres de propiedad de tipos annimos se escriben
correctamente con mayscula o minscula, usando para ello la grafa Pascal.
var localDistributors =
from customer in customers
join distributor in distributors on customer.City equals distributor.City
select new { Customer = customer, Distributor = distributor };

Cambie el nombre de las propiedades cuando puedan ser ambiguos en el resultado. Por ejemplo, si la
consulta devuelve un nombre de cliente y un identificador de distribuidor, en lugar de dejarlos como
Name e ID en el resultado, cambie su nombre para aclarar que Name es el nombre de un cliente e ID
es el identificador de un distribuidor.
var localDistributors2 =
from cust in customers
join dist in distributors on cust.City equals dist.City
select new { CustomerName = cust.Name, DistributorID = dist.ID };

Utilice tipos implcitos en la declaracin de variables de consulta y variables de intervalo.

ar seattleCustomers = from cust in customers
where cust.City == "Seattle"
select cust.Name;
Alinee las clusulas de consulta bajo la clusula from, como se muestra en los ejemplos anteriores.

Utilice clusulas where antes de otras clusulas de consulta para asegurarse de que las clusulas de
consulta posteriores operan en un conjunto de datos reducido y filtrado.
var seattleCustomers2 = from cust in customers

where cust.City == "Seattle"

orderby cust.Name
select cust;

Utilice varias clusulas from en lugar de una clusula join para acceder a colecciones internas. Por
ejemplo, una coleccin de objetos Student podra contener cada uno un conjunto de resultados de
exmenes. Cuando se ejecuta la siguiente consulta, devuelve cada resultado superior a 90, adems
del apellido del alumno que recibi la puntuacin.
// Use a compound from to access the inner sequence within each element.
var scoreQuery = from student in students
from score in student.Scores
where score > 90
select new { Last = student.LastName, score };

Created with the Personal Edition of HelpNDoc: Free Kindle producer

ASP NET
BUENAS PRACTICAS
1. No utilice las variables de sesin a travs del cdigo. Utilice variables de sesin slo dentro de clases
y proporcione mtodos para acceder al valor almacenado en estas variables. Una clase puede tener
acceso a las variables de sesin mediante System.Web.HttpCOntext.Current.Session.
2. No guarde objetos de gran tamao en la sesin. Esto puede consumir gran cantidad de memoria del
servidor en funcin del nmero de usuarios.
3. Siempre use una hoja de estilo para controlar la apariencia de las pginas. Nunca especificar el
nombre de fuente y tamao en ninguna de las pginas. Utilice clases de estilo. Esto le ayudar a
cambiar la interfaz de usuario de su aplicacin fcilmente en el futuro. As, si usted desea personalizar
la interfaz de usuario, slo es cuestin de desarrollar una hoja de estilos nueva
MANEJO DE EXCEPCIONES

1. Nunca capturar una excepcin y no hacer nada. Si se oculta una excepcin, nunca se sabr si la
excepcin sucedido. Muchos desarrolladores utilizan este mtodo para ignorar errores no
significativos. Trate de evitar las excepciones comprobando todas las condiciones de error mediante
programacin. En el peor de los casos, usted debe registrar la excepcin en un log y continuar.

2. En casos de excepcin, mostrar un mensaje amigable al usuario, pero se debe logear la excepcin
actual con todos los detalles posibles sobre el error, incluyendo el momento en que ocurri, el mtodo
y nombre de la clase, etc. Siempre capturar una excepcion especifica, no genricas. Cuando vuelva a
lanzar una excepcin, utilice la instruccin throw sin especificar la excepcin original. De esta manera,
la llamada original conserva la pila.

3. No escriba try-catch en todos sus mtodos. Utilcelo slo si hay una posibilidad de que una excepcin
especfica se puede producir y no se puede evitar por cualquier otro medio. Por ejemplo, si desea
insertar un registro en la base de datos. Algunos desarrolladores tratan de insertar un registro sin
comprobar si ya existe. Esto est estrictamente prohibido. Siempre debe comprobar si hay errores de
forma explcita en lugar de esperar que se produzcan excepciones. Por otro lado, siempre debe utilizar
controladores de excepciones, si se comunica con sistemas externos, como de red, dispositivos
hardware, etc. Estos sistemas estn sujetos a fallos en cualquier momento y la comprobacin de
errores no suele ser fiable. En esos casos, debe tratar de recuperarse del error.
4. No escriba bloques try-catch muy grandes. Si es necesario, escribir por separado try-catch para cada
tarea de realizar e incluya slo la parte especfica del cdigo dentro del try-catch. Esto le ayudar a
encontrar el cdigo que genera la excepcin y se puede dar mensaje de error especfico al usuario.
5. Escriba sus propias clases excepcin si se requiere en la aplicacin:

Heredar de Exception, o de otra clase base propia

El nombre de la clase culminarlo con Exception

Considerar proveer propiedades adicionales.

Created with the Personal Edition of HelpNDoc: Create HTML Help, DOC, PDF and print
manuals from 1 single source

TERMINOLOGIA
Created with the Personal Edition of HelpNDoc: Free EPub producer