Estandar de COdificación C#

Desarrollo Infocorp www.infocorp.com.uy desarrollo@infocorp.com.
uy
Infocorp
Instructivo
septiembre de 2012 Este documento describe los estndares de codificacin para C# utilizados en el Departamento de Desarrollo.Este documento describe los estndares de codificacin para C# utilizados en el Departamento de Desarrollo.
Archivo: Pginas: Fecha: Autor: Contacto: Versin
109933590.doc 36 9/5/2012 15:20:00 a9/p9 Silvia Nane silvian@infocorp.com.uy 3
TABLA DE CONTENIDO
...............................................................................................................................................................................................................1 Tabla de contenido.....................................................................................................................................................................................2 Introduccin................................................................................................................................................................................................3 Objetivo..................................................................................................................................................................................................3 Alcance..................................................................................................................................................................................................3 Condiciones de uso de este documento................................................................................................................................................3 Convenciones utilizadas en este documento.........................................................................................................................................3 Terminologa y definiciones...................................................................................................................................................................4 Fuentes de informacin consultadas.....................................................................................................................................................4 Gua Rpida...............................................................................................................................................................................................5 Convenciones de nomenclatura.............................................................................................................................................................5 Estilos de codificacin............................................................................................................................................................................6 Convenciones de nomenclatura.................................................................................................................................................................8 Guas genricas de nomenclatura.........................................................................................................................................................8 Comentarios y Documentacin Embebida................................................................................................................................................13 Guas para la escritura de comentarios...............................................................................................................................................13 Guas para la escritura de documentacin embebida..........................................................................................................................13 Ciclo de vida de Los objetos.....................................................................................................................................................................14 Guas para la declaracin e inicializacin de variables........................................................................................................................14 Guas para la utilizacin de destructors de clases...............................................................................................................................15 Control de Flujo........................................................................................................................................................................................18 Guas para el uso de variables dentro de sentencias loop...................................................................................................................18 Guas para el uso de sentencias de control.........................................................................................................................................18 Guas para la Programacin de Clases....................................................................................................................................................19 Acerca del uso de propiedades y mtodos..........................................................................................................................................19 Guas para el uso de Propiedades.......................................................................................................................................................20 Guas para el uso de Eventos..............................................................................................................................................................21 Guas para el uso de Mtodos.............................................................................................................................................................23 Guas para el uso de Constructores....................................................................................................................................................26 Guas para el uso de Atributos.............................................................................................................................................................27 Guas para el uso de Parmetros........................................................................................................................................................30 Tipos de Datos.........................................................................................................................................................................................32 Estilo de codificacin................................................................................................................................................................................34 Apndice 1 Tabla de Palabras Reservadas...........................................................................................................................................35
/var/www/apps/conversion/current/tmp/scratch_5/109933590.doc
Pgina 2 de 36
INTRODUCCIN
Este documento describe reglas y recomendaciones para el desarrollo de aplicaciones utilizando el lenguaje C# en el Departamento de Desarrollo de Infocorp. La informacin aqu contenida proviene de varias fuentes, las cuales se listan en el Apndice 1: Bibliografa consultada. Especficamente, este documento contiene: Convenciones de nomenclatura Estilo de codificacin Uso del lenguaje Diseo de modelos de objetos.
Objetivo
El principal objetivo de la utilizacin de estndares de codificacin, es institucionalizar buenas prcticas y recomendaciones de diseo, para lograr mayores niveles de calidad en los productos de software desarrollados en el Departamento de Desarrollo. La utilizacin de estndares debe mostrar efectos positivos sobre: Disminucin de errores / bugs, especialmente en aquellos difciles de individualizar. Mantenimiento del cdigo estructurado de acuerdo a las guas de diseo. Mantenimiento del cdigo escrito de acuerdo a un estilo estandarizado. Performance de la aplicacin desarrollada con prcticas eficientes del lenguaje.
Alcance
Este documento aplica nicamente al lenguaje C# y .Net Framework Common Type Systems (CTS). No se incluyen referencias o prcticas relacionadas al uso de las bibliotecas de clases de .Net Framework. Se incluyen algunos comentarios acerca de prcticas comunes y problemas conocidos de C#, las cuales se describen en forma breve. Dado que las prcticas recomendadas en este manual se aplicarn en forma institucional, se han incluido normas que describen el uso de llaves ( {} ) y tabulaciones, para lograr una lectura uniforme del cdigo generado en Infocorp.
Condiciones de uso de este documento

Una regla puede romperse slo ante razones justificadas, discutidas, con previa autorizacin del responsable del producto, y en caso que no pueda aplicarse ninguna alternativa razonable. El autor de la excepcin, obligatoriamente debe documentar el cdigo explicando la causa de la violacin de la regla. Las preferencias personales no se consideran una razn justificada.
Convenciones utilizadas en este documento

Colores y nfasis Azul Negrita Descripcin Indica una palabra clave de C# o un tipo de .Net. Texto con nfasis adicional que debe ser considerado importante.
Pgina 3 de 36
Trminos claves Siempre Nunca No hacer Evitar Intentar Razn
Descripcin Indica que esta regla DEBE ser respetada, en los trminos de este manual. Indica que esta accin NO DEBE ser realizada, en los trminos de este manual. Indica que esta accin NO DEBE ser realizada, en los trminos de este manual. Indica que esta prctica debe ser evitada siempre que sea posible, pero pueden existir excepciones AUTORIZADAS para su utilizacin. Indica que esta prctica debe aplicarse siempre que sea posible y apropiado. Explica el propsito y las caudas que motivan la regla o recomendacin.
Terminologa y definiciones
Trmino Descripcin Las palabras claves de C# public, protected, internal y private declaran el alcance del acceso que el cdigo permite a sus tipos y miembros. Aunque el acceso por defecto puede variar, las clases y la mayora de los dems miembros del cdigo utilizan private en forma predeterminada. Las excepciones de esta regla incluyen las interfaces y los tipos enumerados, que poseen acceso public en forma predeterminada. Una palabra con la primera letra en minsculas, y la primera letra de cada una de las palabras subsecuentes en maysculas. Ejemplo: customerName Common type System El Common Type System de .Net define cmo deben declararse, utilizarse y administrarse los tipos de datos. Todos los tipos nativos de C# estn basados en el CTS para asegurar la compatibilidad con otros lenguajes del framework. Es un token definido por el programador, que nombra en forma nica un objeto o una instancia de un objeto. Ejemplo: public class MyClassNameIdentifier { }. Cualquier literal numrico utilizado dentro de una expresin (o inicializacin de variable) que no posea un significado claro. Usualmente este trmino no aplica a los valores 0 y 1 y cualquier otra expresin numrica equivalente que su evaluacin resulte 0. Una palabra con la primera letra en maysculas, y la primera letra de cada palabra subsecuente tambin en maysculas. Ejemplo: CustomerName
Access Modifier
Camel Case
Identifier
Magic Number
Pascal Case
Fuentes de informacin consultadas

Basado en: Coding Standard C# - Phillips Medical Systems, C# Coding Standards - Lance Hunt, Microsoft Naming Guidelines - Microsoft Corp.
Pgina 4 de 36
GUA RPIDA
En esta seccin se incluye un breve resumen de los principales estndares descriptos a los largo de este documento. Estas tablas no son detalladas en sus descripciones, pero brindan una rpida referencia a los elementos.
Convenciones de nomenclatura
c P _ X Camel case Pascal case Prefijo con infraguin (underscore) No aplica
Identificador Archivo de proyecto Archivo del cdigo fuente Otros archivos Namespace Class o Struct
Public P P P P P
Protected X X X X P
Internal X X X X P
Private X X X X P
Notas Debe corresponder al Assembly y al Namespace. Debe corresponder con la clase que contiene. Ver Correspondencia parcial Project / Assembly. Agregar sufijo de la subclase. Ejemplo: AppDomain
Interface
Debe tener el prefijo I. Ejemplo: IDerivable
Exception class
Siempre debe tener el sufijo Exception luego del nombre. Ejemplo: AppDomainException
Method
Utilizar verbo o verbo-objeto. Ejemplo: ToString
Property
No utilizar prefijos. No utilizar Get / Set como prefijos. Ejemplo: BackColor
Atributos
_c
Utilizar solo Private fields. No utilizar notacin Hngara (Hungarian Notation).
Pgina 5 de 36
Identificador
Public
Protected
Internal
Private
Notas Ejemplo: _listItem
Constant Static field Read-only
P P
P P
P P
_c _c
Ejemplo: _maximunItems Utilizar slo atributos Private. Ejemplo: _redValue
Enum
Utilizar PascalCase tambin para las opciones. Ejemplo: ErrorLevel
Delegate Event Inline variable Parameter
P P X X
P P X X
P P X X
P P c c Ejemplo: ValueChange Evitar caracteres nicos y tipos enumerados. Ejemplo: typeName
Estilos de codificacin
Cdigo Archivo del cdigo fuente (Source code) Llaves {} Tabulacin (Indent) Comentarios (Comments) Variables Tipos de datos nativos (Native Data Types) Enumerados (Enums) Tipos genricos (Generic types) Propiedades (Properties) Mtodos (Methods) Base / This Estilo Un archivo por Namespace y un archivo por clase. Siempre en una nueva lnea. Utilizar parntesis cuando sea opcional. Utilizar siempre tabs de 4 caracteres. No utilizar espacios en blanco. Utilizar //. No utilizar /**/. Una variable por cada declaracin. Priorizar el uso de tipos nativos de C# ante tipos del CTS. Ejemplo: int en lugar de Int32. Evitar cambiar el tipo de dato predeterminado. Utilizar preferiblemente tipos genricos ante tipos estndar o strong-typed classes. No utilizar prefijos Get / Set. Utilizar un mximo de 7parmetros. Utilizar solo en constructors o dentro de override.
Pgina 6 de 36
Cdigo Condiciones ternarias (Ternary conditions) For each Condicionales (Conditionals)
Estilo
No modificar tipos enumerados dentro de una sentencia foreach. Evitar la evaluacin de condiciones booleanas contra valores true o false. No realizar asignaciones embebidas. No utilizar invocacin de mtodos embebidos.
Manejos de excepciones (Exception Handling)
No utilizar excepciones para el control de flujo. Utilizar throw; NO throw e; cuando se redirije. Slo utilizar catch cuando es posible manejar la excepcin. Utilizar validaciones para evitar la ocurrencia de excepciones.
Eventos (Events) Bloqueo (Locking)
Siempre debe validarse el valor null antes de la invocacin. Utilizar lock() en lugar de Monitor.Enter() No utilizar lock en un tipo, por ejemplo: lock(typeof(MyType)); Evitar el uso de lock ante un this, por ejemplo: lock(this); Preferiblemente, utilizar lock en objetos declarados como private, por ejemplo: lock(myVariable);
Dispose() / Close() Finalizers
Utilizarlo siempre que sea possible. Evitar la implementacin de estos mtodos. Utilizar la sintaxis del destructor de C#. Ejemplo: ~MyClass() {} Nunca debe definirse un mtodo llamado Finalize();
AssemblyVersion ComVisibleAttribute
Incrementar en forma manual. Debe estar con el valor false para todos los assemblies.
Pgina 7 de 36
CONVENCIONES DE NOMENCLATURA
La consistencia del cdigo es la clave para su fcil mantenimiento. Esta aseveracin aplica a la nomenclatura utilizada para los nombres de carpetas, archivos y todos los identificadores contenidos en una aplicacin.
Guas genricas de nomenclatura

REC Utilizar nombres en ingls para todos los elementos que componen una solucin: carpetas, archivos e identificadores. OBL Utilizar siempre la convencin Pascal o Camel 1.1. OBL - Utilizar nomenclatura Pascal y Camel para la nomenclatura de todos los elementos que componen una solucin: carpetas, archivos e identificadores. 1.2. OBL - No utilizar nombres que comiencen con un carcter numrico. OBL No utilizar maysculas y minsculas para diferenciar identificadores. No definir namespaces, clases, mtodos, propiedades, campos o parmetros con igual nombre, pero que difieren en la utilizacin de las maysculas y minsculas. OBL - No utilizar nomenclatura Hngara (iCount, strName). REC Utilizar abreviaturas slo cuando el nombre completo sea demasiado extenso. 1.3. REC - Evitar el uso de contracciones de palabras en los identificadores. 1.4. REC - Evitar el uso de abreviaturas no estndar, por ejemplo: no utilizar GetWin si es posible utilizar GetWindow. 1.5. REC - Cuando sea pertinente, utilizar abreviaturas estndar, por ejemplo: puede utilizarse UI en lugar de UserInterface. 1.6. REC - Utilizar maysculas para las abreviaturas de dos caracteres, y notacin Pascal para abreviaturas ms extensas. REG No utilizar infraguiones en los identificadores. REC Nombrar los identificadores de acuerdo a su significado y no a su tipo. Evitar el uso de terminologa dependiente del lenguaje en los identificadores. Como un ejemplo, supongamos que tenemos varios mtodos que sobrecargados que escriben datos en un stream. No debemos utilizar definiciones como: void Write (double doubleValue); void Write (long longValue); La forma correcta, sera: void Write (double value); void Write (long value); REC Utilizar Can, Has o Is para nombrar variables booleanas. Siempre que sea posible es recomendable utilizar los prefijos Can, Has o Is delante del nombre de las variables de tipo Boolean.
/var/www/apps/conversion/current/tmp/scratch_5/109933590.doc Pgina 8 de 36
Ejemplo: IsIncludedInList(); CanInsert();
REC Utilizar nombres de operaciones aritmticas para nombrar variables que las implementan. Siempre que sea posible es recomendable utilizar los nombres de operaciones aritmticas estndar cuando su resultado se almacene en variables definidas para esos efectos. Ejemplos de estas operaciones son: Sum, Average, Count, Min, Max. En la tabla siguiente se muestran los nombres y abreviaturas sugeridos para identificar estas operaciones. Las abreviaturas son iguales a las utilizadas por MS-Excel. Ejemplo: AverageSalary(long year); CountRows(); REG - Nombrar los namespaces de acuerdo a un pattern bien definido. Los namespaces deben ser nombrados en Pascal, de acuerdo al siguiente pattern: <company>.<technology>.<top-level component>.<bottom-level component> REC Utilizar sustantivos o frases sustantivos para el nombre de clases o struct. Si la clase desarrollada, es una clase derivada, es una buena prctica utilizar un nombre compuesto. Ejemplo: Si tenemos una clase llamada Button, una clase derivada de este podra nombrarse como ShadowButton. REC El nombre de las interfaces debe tener el prefijo I. Todas las interfaces deben comenzar con el prefijo I, y debe utilizarse un sustantivo, una frase con sustantivo o un adjetivo para su nombre. Ejemplo: IComponent sustantivo IComponentAttributePorvider frase con sustantivo IPersistable - adjetivo REC Utilizar nombres similares para la implementacin predeterminada de una interface. Si estamos proveyendo una implementacin predeterminada (default) para una interface particular, se debe utilizar un nombre similar para la clase que la implementa. Nota: Observar que esto aplica slo a las clases que implementan nicamente la interfaz referida. Ejemplo: Si tenemos una clase que implementa la interface IComponent, puede llamarse Component o ComponentDefault. REG Utilizar nombres en singular para tipos enumerados. Para el nombre de los tipos enumerados, debe utilizarse la palabra en singular.
Ejemplo: Si tenemos un tipo enum en el cual almacenaremos un valor de una coleccin restringida de valores, debe llamarse Protocol y no Protocols. public enum Protocol { Tcp; Udp; http; Ftp: }
REG Utilizar nombres en plural para enumeraciones que representan campos de datos. Ejemplo: [flags] public Enum SearchOptions { CaseInsensitive = 0x01, WholeWordOnly = 0x02, AllDocuments = 0x04, } REC Evitar el uso de las letras I O y los nmeros 1 y 0 juntos. Para generar cdigo ms limpio, es conveniente evitar el uso de las letras I O y los nmeros 1 y 0 juntos, ya que puedan generar una confusin entre nmeros y letras. Ejemplos: Bool b001 = (10 == 10) ? (I1 == 11) : (1O1 != 101); OBL Agregar EventHandler para delegaciones relacionadas a eventos. Las delegaciones que sean utilizadas para definir un event handler para un evento, deben nombrarse agregando el texto EventHandler a su nombre (EventNameEventHandler). Ejemplo: public delegate CloseEventHandler(object sender, EventArgs arguments) OBL Agregar CallBack para delegaciones relacionadas a mtodos callback. Las delegaciones que sean utilizadas para pasar una referencia a un mtodo callback (no a un evento), deben nombrarse agregando el texto CallBack a su nombre (MethodNameCallBack). Ejemplo: public delegate AsyncIOFinishedCallBack(IpcClient client, string message) REC No agregar CallBack a los mtodos callback. No deben utilizarse sufijos CallBack o CB para indicar los mtodos
Pgina 10 de 36
REC Utilizar verbos para nombrar eventos. Utilizar verbos para nombrar los eventos de una clase. Ejemplo: Minimize() Maximize() OBL No agregar el texto Event a los nombres de los eventos. OBL Utilizar sufijos ingy ed para indicar pre-eventos y post-eventos. No utilizar patrones del estilo BeginXXX o EndXXX. Si es necesario proveer diferentes eventos que expresen instancias previas y posteriores en el tiempo, utilizar para su nombre el sufijo ing si indica anterioridad, y el sufijo ed si indica posterioridad. Ejemplo: EntityValidating() Evento pre-validacin EntityValidate() Evento de validacin EntityValidated() Evento post-validacin OBL Agregar el prefijo On para los Event Handlers. Para nombrar los event handlers, debe utilizarse el texto On antepuesto a su nombre. Ejemplo: Si tenemos un mtodo que maneja el evento Close de una clase, debe nombrarse como OnClose(). OBL Nombrar las exception classes utilizando el sufijo Exception. Las exception classes deben nombrarse agregando el texto Exception a su nombre (ClassNameException). Ejemplo: IpcException() OBL No incluir el nombre de la clase dentro del nombre de las propiedades. El nombre de las propiedades no debe incluir el nombre de la clase. Ejemplo: Utilizar Customer.Name No utilizar Customer.CustomerName OBL Nombrar las assemblies DLL luego del namespace que las contiene. Para permitir el almacenamiento de los assemblies en la GAC, sus nombres deben ser nicos. Adems debe utilizarse el nombre del namespace como prefijo del nombre del assembly. Ejemplo: Consideremos un grupo de clases organizadas bajo el namespace Infocorp.ICWorkFlow.Platform.OSInterface. En este caso, el assembly generado por estas clases ser llamado Infocorp.ICWorkFlow.Platform.OSInterface.dll. Si se generan mltiples assemblies desde el mismo namespace, es posible agregar un prefijo nico al nombre del namespace.
OBL Utilizar notacin Pascal para nombrar los archivos de cdigo fuente. No utilizar infraguiones para nombrar los archivos de cdigo fuente. OBL Nombrar el archivo de cdigo fuente igual a la clase principal que implementa. El archivo de cdigo fuente de una clase, debe tener el mismo nombre que la clase. Adicionalmente no debe incluirse ms de una clase principal por archivo.
Pgina 12 de 36
COMENTARIOS Y DOCUMENTACIN EMBEBIDA

En esta seccin se describen las guas para la escritura de comentarios y documentacin embebida en el cdigo fuente de las aplicaciones.
Guas para la escritura de comentarios

OBL Cada archivo debe contener un cabezal identificatorio. El cabezal de cada archivo es un bloque #region que contiene el texto de copyright y el nombre del archivo. Ejemplo: # region Copyright Infocorp 2003 // // Todos los derechos reservados. La repoduccin o trasmisin en su // totalidad o en parte, en cualquier forma o medio electrnico, mecnico // o similar es prohibida sin autorizacin expresa y por escrito del // propietario de este cdigo. // // Archivo: PatientAdministration.cs // #endregion OBL Utilizar // para los bloques de comentarios. REC Los comentarios sern escritos en espaol si no hay una peticin expresa del cliente para hacerlo en ingls.
Guas para la escritura de documentacin embebida

OBL Utilizar tags XML para documentar tipos y miembros de clase. Todos los tipos privados y pblicos, mtodos, campos, eventos, etc. deben ser documentados utilizando tags XML. Utilizando estos tags, IntelliSense provee informacin til acerca de los tipos de datos, y adems es posible utilizar herramientas de documentacin automtica basada en estos tags. <Tabla de tags> REC Utlizar #region para agrupar miembros no pblicos. Si una clase contiene un largo nmero de miembros, atributos y/o propiedades, se ubicarn todos los miembros no pblicos en un bloque #region. Se utilizarn regiones separadas para dividir los miembros public, private, protected e internos de una clase.
Pgina 13 de 36
CICLO DE VIDA DE LOS OBJETOS

Esta seccin describe las guas de programacin y recomendaciones que aplican a la codificacin del ciclo de vida de un objeto: declaracin e inicializacin de variables, e implementacin de constructores y destructores de clases.
Guas para la declaracin e inicializacin de variables

REC Declarar e inicializar las variables prximo al lugar donde son utilizadas. REC Inicializar las variables en el punto de su declaracin. Siempre que sea posible, es conveniente inicializar las variables en el mismo punto de su declaracin. Si se est utilizando inicializacin de campos, stos sern inicializados antes de llamar el constructor de la instancia. De la misma forma, los campos estticos se inicializan cuando el constructor esttico es llamado. El compilador siempre inicializa en cero cualquier variable que no haya sido inicializado. { Red, Green } bool fatalSituation = IsFatalSituation(); Color backgroundColor = fatalSituation ? Color.Red : Color.Green; OBL Declarar cada variable en una sentencia diferente. OBL Utilizar const para la declaracin de constantes. La declaracin de constantes utilizando const, asegura la asignacin de memoria una nica vez para el item que est siendo declarado. Ejemplo: private const int MaxUsers = 100; REC Utilizar public static readonly para definir instancias predeterminadas de objetos. Para definir instancias predeterminadas de objetos, es conveniente utlilizar la declaracin public static readonly. Por ejemplo, consideremos una clase Color que internamente almacena los valores numricos del rojo, negro y blanco. Esta clase tiene un constructor que toma un valor numrico, de forma que puede exponer varios colores predeterminados. public struct Color { public static readonly Color Red = new Color(0xFF0000); public static readonly Color Black = new Color(0x000000); public static readonly Color White = new Color(0xFFFFFF); } Ejemplo: enum Color
Pgina 14 de 36
Guas para la utilizacin de destructors de clases

REC Asignar el valor null a los campos de referencia para liberar la Garbage Collector (GC). La asignacin del valor null a los objetos mejora la utilizacin de la memoria porque el objeto pierde la referencia, permitiendo a la GC limpiar la asignacin de memoria en forma temprana. REC Evitar la implementacin de mtodos destructores. En caso que se requiera la implementacin especfica de un destructor, referir a las reglas XX y YY. El uso de destructores en C# no es promovido debido a que introduce una severa detraccin de la performance, por el trabajo que debe realizar la GC. OBL Si es necesaria la implementacin de un destructor, debe utilizarse GC.SuppressFinalize. Si es necesaria la implementacin de un destructor, es necesario verificar que el programador haya utlizado GC.SuppresFinalize() dentro del mtodo Close(). { bool connected = false; public void Connect() { // Do some work and then change the state of this object. connected = true; } public void Close() { // Close the connection, change the state, and instruct // the GC, NOT to call the destructor connected = false; GC.SuppressFinalize(this); } ~IpcPeer() { // If the detructor is called, then Close() was not called. If (connected) { // Warning! User has not called Close(). // Notice that you cant call Close() from here because // the objects involved may have already been garbage // collected (ver regla XX) }
Ejemplo: public class IpcPeer
} } OBL Implementar IDisposable si una clase utiliza recursos no administrados. Si una clase utiliza recursos no administrados, tales como objetos COM, conexiones, sockets, colas, u objetos que consumen recursos extensamente, stos deben ser liberados tan pronto como sea posible. La implementacin de a interface IDisposable permite a las clases de la aplicacin la liberacin explcita de los recursos no administrados. { ///<summary> ///Implementation of the IDisposable interface ///</summary> public void Dispose() { // Call internal Dispose(bool) Dispose(true); // Prevent the destructor from being called GC.SuppressFinalize(this); } ///<summary> /// Central method for cleaning up resources ///</summary> protected virtual void Dispose4(bool explicit) { // If explicit is true, then this method was called through the // public Dispose() if (explicit) { // Release or cleanup managed resources } // Always release or cleanup (any) unmanaged resources } ~ResourceHolder() { // Since other managed objects are disposed automatically, we // should not try to dispose any managed resources (see Rule 5@114). // We therefore pass false to Dispose() Dispose(false);
Ejemplo: public class ResourceHolder : IDisposable
} } Si otra clase deriva de esta clase, la primera slo debe sobre implementar el override del mtodo Dispose(bool) de la clase base. No debe implementar ella misma la interface IDisposable, ni un destructor, pues se dispara automticamente la llamada al destructor de la clase base. { protected override void Dispose(bool explicit) { if (explicit) { // Release or cleanup managed resources of this derived // class only. } // Always release or cleanup (any) unmanaged resources. // Call Dispose on our base class. base.Dispose(explicit); } } OBL Do not access any reference type members in the destructor. Ejemplo: public class DerivedResourceHolder : ResourceHolder
Pgina 17 de 36
CONTROL DE FLUJO
En esta seccin se describen las guas y recomendaciones para la programacin de los procesos de control de flujo y el uso del lenguaje en cada caso.
Guas para el uso de variables dentro de sentencias loop

OBL No cambiar una variable del loop dentro de un bloque for. La actualizacin de una variable loop dentro de un bloque loop es generalmente considerada confuso, y an ms cuando el valor de la variable se modifica en ms de un lugar.
Guas para el uso de sentencias de control

OBL Todas las primitivas de control de flujo (if, else, while, for, do, foreach, switch) deben codificarse con bloque, an cuando est vaco. OBL Todas las sentencias switch deben poseer una etiqueta default en el ltimo case. Es recomendable un comentario como no action donde sea explcita esta intencin. Si la etiqueta default es la ltima, es ms sencillo de ubicar. REC Evitar el uso de sentencias return condicionales o mltiples. La norma para un flujo simple es: una entrada, una salida. En algunos casos tales como validacin de precondiciones, puede ser una buena prctica forzar la salida si una de las precondiciones no se cumple. REC No realizar comparaciones explcitas true o false. Usualmente es considerada una mala prctica comparar una expresin booleana contra expresiones true o false. Ejemplo: while [condition == false] // Mala prctica while [condition != true] // Mala prctica while (((condition == true) == true) == true) // Mala prctica while (booleanCondition) // Prctica recomendada
Pgina 18 de 36
GUAS PARA LA PROGRAMACIN DE CLASES

Esta seccin describe las guas y recomendaciones a seguir en la programacin orientada a objetos. El contenido de esta seccin est dividido en: Gua para el uso de Propiedades Describe las recomendaciones y guas para el uso de propiedades dentro de bibliotecas de clases (class libraries). Gua para el uso de Eventos Describe las recomendaciones y guas para el uso de eventos dentro de bibliotecas de clases (class libraries). Gua para el uso de Mtodos Describe las recomendaciones y guas para el uso de mtodos dentro de bibliotecas de clases (class libraries). Guas para el uso de Constructores Describe las recomendaciones y guas para el uso de constructores dentro de bibliotecas de clases (class libraries). Gua para el uso de variables y campos Describe las recomendaciones y guas para el uso de variables y campos dentro de bibliotecas de clases (class libraries). Gua para el uso de Parmetros Describe las recomendaciones y guas para el uso de parmetros dentro de bibliotecas de clases (class libraries).
Acerca del uso de propiedades y mtodos

Generalmente los mtodos representan acciones, y las propiedades representan datos de una clase. Podemos utilizar las siguientes recomendaciones como gua: REC - Utilizar una propiedad cuando el miembro es un miembro lgico de la clase. Ejemplo:
En la siguiente declaracin, Name es una propiedad porque es un miembro lgico de la clase. public string Name get { return name; } set { name = value; }
Pgina 19 de 36
Utilizar un mtodo cuando la obtencin del valor de una propiedad puede tener un efecto colateral observable. Utilizar un mtodo cuando las llamadas sucesivas al miembro de la clase producen resultados diferentes. Utilizar un mtodo cuando el orden de ejecucin es importante Debe considerarse que las propiedades de tipo deben poder asignarse (set) y obtenerse (get) en cualquier orden. Utilizar un mtodo cuando el miembro es esttico, pero retorna un valor que puede ser cambiado. Utilizar un mtodo cuando el miembro retorna un array. Las propiedades que retornan arrays pueden ser difciles de entender, y resultar engaosas. Usualmente es necesario retornar una copia del array interno, pues el usuario no puede cambiar el estado interno. Esta consideracin, asociada al echo que el usuario puede fcilmente asumir que es un propiedad indizada, conduce a que el cdigo sea ineficiente. Ejemplo: En este ejemplo cada llamada a la propiedad Methods crea una copia del array. Como resultado, tendremos 2n+1 copias del array que ser creado en el loop. Type type = // Get a type. for (int i = 0; i < type.Methods.Length; i++) { if (type.Methods[i].Name.Equals ("text")) { // Perform some operation. } } OBL Si un miembro retorna una copia de un tipo de referencia o un array, es obligatoria su documentacin. En forma predeterminada, todos los miembros que necesitan retornar un objeto interno o un array de objetos, retornarn una referencia a este objeto o al array. En estos casos, esta necesidad siempre debe documentarse claramente en la especificacin.
Guas para el uso de Propiedades

Fuente de esta informacin: [MSDN - Method Usage Guidelines]. OBL - Nombrar las propiedades de acuerdo a las convenciones de nomenclatura indicadas en la seccin [Convenciones de nomenclatura] de este documento. REC - Preservar el valor de la propiedad antes de asignar un nuevo valor con Set. Cuando se cambia el valor de una propiedad utilizando el mtodo Set de la propiedad, debe preservarse el valor anterior antes del cambio. Esto asegura que el dato no se pierde si el mtodo Set produce una excepcin.
OBL - La asignacin de propiedades debe poder realizarse en cualquier orden. Las propiedades no deben tener estado respecto a otras propiedades de la clase, es decir no debera haber diferencia en el estado del objeto si se asigna primero la propiedad A o la propiedad B. Ms informacin: Property State Issues en [MSDN - Properties usage guidelines] REC - Utilizar mtodos que comuniquen el cambio de una propiedad Los componentes deben disparar eventos que informen el cambio de una propiedad si es necesario notificar a sus clientes cuando se produce un cambio de valor dentro del cdigo. La convencin de nomenclatura para estos eventos, consiste en agregar el sufijo Changed al nombre del evento que implementa la notificacin. Ejemplo: Un campo de testo puede disparar el evento TextChanged cuando su propiedad text cambie de valor. Ms informacin: Raising Property-Changed Events en [MSDN - Properties usage guidelines] OBL - Deben utilizarse propiedades Read-Only cuando el usuario no puede cambiar el valor del miembro lgico de la clase. La implementacin de una propiedad Read-Only se realiza programando slo el mtodo Set de la propiedad. OBL No deben utilizarse propiedades Write-Only. No deben implementarse propiedades que slo contengan el mtodo Get. Index properties.
Guas para el uso de Eventos

Fuente de esta informacin: [MSDN - Method Usage Guidelines]. OBL - Nombrar los Eventos de acuerdo a las convenciones de nomenclatura indicadas en la seccin [Convenciones de nomenclatura] de este documento. OBL - Las clases de eventos (Event classes) deben extender System.EventArgs Class Ejemplo: public class MouseEvent: EventArgs {} REC - Utilizar un mtodo protected virtual para levantar eventos. Esta tcnica no es apropiada para clases selladas, porque impide que otras clases deriven de ella. El propsito de este mtodo es proveer una forma para que una clase derivada pueda manejar el evento utilizando override. Esta tcnica es ms natural que el uso de delegates en situaciones donde el programador est creando una clase derivada. El nombre del mtodo agrega la palabra On al nombre del evento que ser levantado. Ejemplo: public class Button
{ ButtonClickHandler onClickHandler; protected virtual void OnClick(ClickEventArgs e) { // Call the delegate if non-null. if (onClickHandler != null) onClickHandler(this, e); } } OBL Debe asumirse que un event handler puede contener cualquier cdigo. Las clases deben estar preparadas para que los event handler realicen cualquier operacin, y en todos los casos el objeto quede en un estado apropiado luego que el evento sea levantado. Debe considerarse tambin el uso de un bloque try/finally en el punto del cdigo donde se levanta el evento Desde que el programador realiza una function callback sobre el objeto que realize otras acciones, no debe asumirse nada acerca del estado del objeto cuando el control retorna al punto desde donde se levant el evento. { ButtonClickHandler onClickHandler; protected void DoClick() { // Paint button in indented state. PaintDown(); try { // Call event handler. OnClick(); } finally { // Window might be deleted in event handler. if (windowHandle != null) // Paint button in normal state. PaintUp(); } } protected virtual void OnClick(ClickEvent e) { Ejemplo: public class Button
Pgina 22 de 36
if (onClickHandler != null) onClickHandler(this, e); } } REC Utilizar o extender la clase System.ComponentModel.CancelEventArgs Class para permitir al programador controlar los eventos de un objeto. Por ejemplo, el control TreeView control levanta el evento BeforeLabelEdit cuando el usuario edita un nodo del rbol. Ejemplo: Este ejemplo muestra cmo puede utilizarse este mtodo para prevenir la edicin de un nodo. public class Form1: Form { TreeView treeView1 = new TreeView(); void treeView1_BeforeLabelEdit(object source, NodeLabelEditEventArgs e) { e.CancelEdit = true; } } En este caso, el usuario no recibe un mensaje de error, sino que la etiqueta no queda habilitada para su edicin Los eventos Cancel no son apropiados en los casos donde el programador debe cancelar la operacin y devolver una excepcin. En esto casos, debe levantarse la excepcin dentro del event handler. Por ejemplo, el usuario quiz desee incluir cierta lgica de validacin en el control cuando se edita, por ejemplo: public class Form1: Form { EditBox edit1 = new EditBox(); void TextChanging(object source, EventArgs e) { throw new RuntimeException("Invalid edit"); }
Guas para el uso de Mtodos

Fuente de esta informacin: [MSDN - Method Usage Guidelines].
Pgina 23 de 36
OBL - Nombrar los Mtodos de acuerdo a las convenciones de nomenclatura indicadas en la seccin [Convenciones de nomenclatura] de este documento. OBL - No utilizar nomenclatura Hngara (hungarian notation). REC - En forma predeterminada, los mtodos no son virtual. Es recomendable mantener esta premisa en todas las situaciones en las cuales no sea expresamente necesario proveer mtodos virtuales. Ms informacin: [MSDN - Base clase usage methods]
REC Uso de overloading. El overloading ocurre cuando una clase contiene dos mtodos con el mismo nombre, pero diferentes signatures. En esta gua incluimos las recomendaciones ms importantes para su uso: Utilizar overloading para proveer diferentes mtodos que hacen semnticamente lo mismo. 1.7. REC - Utilizar overloading en lugar de default arguments. Los argumentos predeterminados (default arguments) no son totalmente compatibles en esta versin del lenguaje y no estn permitidos en el Common Language Specification (CLS). Ejemplo: El siguiente ejemplo muestra el uso del mtodo String.IndexOf con overloading. int String.IndexOf (String name); int String.IndexOf (String name, int startIndex); Los argumentos predeterminados (default arguments) no son totalmente compatibles en esta versin del lenguaje y no estn permitidos en el Common Language Specification (CLS). 1.8. REC - Los valores predeterminados deben utilizarse correctamente. En una familia de mtodos overload, el mtodo complejo debe utilizar nombres de parmetros que indiquen el cambio del estado asumido por defecto en el mtodo simple. Por ejemplo, en el siguiente cdigo, el primer mtodo asume que la bsqueda no es casesensitive. El segundo mtodo utiliza el nombre ignoreCase en lugar de caseSensitive para indicar como cambia el comportamiento predeterminado. Ejemplo // Method #1: ignoreCase = false. MethodInfo Type.GetMethod(String name); // Method #2: Indicates how the default behavior of method #1 is being // changed. MethodInfo Type.GetMethod (String name, Boolean ignoreCase); 1.9. Utilizar un orden y una nomenclatura consistente para los parmetros. Es comn proveer un conjunto de mtodos overloaded con una cantidad incremental de parmetros para permitir al programador especificar el nivel de informacin que necesite segn las circunstancias. Cuantos ms parmetros se especifiquen, mayor cantidad de opciones poseer el programador. En el siguiente ejemplo, el mtodo Execute est overloaded y posee un orden y una nomenclatura consistente en sus diferentes opciones. Cada variante del mtodo Execute utiliza la misma semntica para el conjunto compartido de parmetros. public class SampleClass {
readonly string defaultForA = "default value for a"; readonly int defaultForB = "42"; readonly double defaultForC = "68.90"; public void Execute() { Execute(defaultForA, defaultForB, defaultForC); } public void Execute (string a) { Execute(a, defaultForB, defaultForC); } public void Execute (string a, int b) { Execute (a, b, defaultForC); } public void Execute (string a, int b, double c) { Console.WriteLine(a); Console.WriteLine(b); Console.WriteLine(c); Console.WriteLine(); } } Nota: Observar que el nico mtodo en el grupo que debe ser virtual es el que posee la mayor cantidad de parmetros y solo cuando lo que se necesita es extensibilidad. 1.10. REC Si un mtodo debe poseer la posibilidad de ser sobreescrito (override), slo debe implementarse la versin ms completa como virtual, y definir las dems operaciones en funcin de esa implementacin. Ejemplo: public class SampleClass { private string myString; public MyClass(string str) { this.myString = str; } public int IndexOf(string s) { return IndexOf (s, 0);
Pgina 25 de 36
} public int IndexOf(string s, int startIndex) { return IndexOf(s, startIndex, myString.Length - startIndex ); } public virtual int IndexOf(string s, int startIndex, int count) { return myString.IndexOf(s, startIndex, count); } } REC Uso de mtodos con cantidad variable de argumentos Algunas veces es deseable exponer un mtodo que tome una cantidad variable de argumentos. Un ejemplo clsico puede ser el mtodo print de C. Ejemplo: void Format(string formatString, params object [] args) Nota: No debe utilizarse VarArgs o parntesis (), pues la Common Language Specification no lo soporta.
Guas para el uso de Constructores

Fuente de esta informacin: [MSDN - Method Usage Guidelines]. REC Proveer un constructor privado predeterminado si solo existen mtodos estticos o propiedades en la clase. En el siguiente ejemplo, el constructor privado impide que la clase sea creada desde el exterior. public sealed class Environment { // Private constructor prevents the class from being created. private Environment() { // Code for the constructor goes here. } } REC Minimizar el trabajo que realice el constructor Los constructors no deben hacer ms que capturar los parmetros necesarios. Esto disminuye el costo de performance en las siguientes operaciones hasta que el usuario utilice una instancia especfica de la clase. REC Proveer un constructor para todas las clases. En el caso de un tipo, utilizar un constructor private. Si no se especifica un constructor, muchos lenguajes de programacin (tales como C#) implcitamente agregan un constructor pblico, y si es una clase abstracta agregan en constructor protected.
Debe tomarse cuidado si se agrega un constructor no predefinido a una clase en una versin posterior, pues ser eliminado el constructor implcito y esto causar un error en los clientes de esa clase. Por esto mismo, la mejor prctica es proveer siempre explcitamente el constructor de la clase, an cuando sea el predefinido y sea pblico. REC Proveer un constructor protected que pueda ser utilizado por tipos en una clase derivada. REC NO debe proveerse un constructor sin parmetros para un struct. Muchos compiladores no permiten que un tipo struct posea constructor sin parmetros. En este caso, si el programador lo implementa, el runtime inicializa todos los campos del struct en cero. REC Utilizar parmetros en constructors como forma rpida de asignar propiedades. No hay diferencia alguna en invocar primero el constructor y luego asignar las propiedades, o invocar al constructor pasando los valores directamente. Ejemplo: Los tres ejemplos a continuacin son equivalentes: // Example #1. Class SampleClass = new Class(); SampleClass.A = "a"; SampleClass.B = "b"; // Example #2. Class SampleClass = new Class("a"); SampleClass.B = "b"; // Example #3. Class SampleClass = new Class ("a", "b");
Guas para el uso de Atributos

Fuente de esta informacin: [MSDN - Method Usage Guidelines]. REC No utilizar atributos public o protected. Evitando el uso de atributos expuestos directamente al programador, las clases pueden ser actualizadas con ms facilidad pues el atributo no debe ser transformado en propiedad, manteniendo as la compatibilidad binaria. La recomendacin es que siempre se implementen los mtodos Get y Set en lugar de declarar los atributos como pblicos. El siguiente ejemplo muestra el uso correcto de atributos privados y propiedades con mtodos Get y Set. { private int xValue; private int yValue;
Ejemplo: public struct Point
public Point(int x, int y) { this.xValue = x; this.yValue = y; } public int X { get { return xValue; } set { xValue = value; } } public int Y { get { return yValue; } set { yValue = value; } } REC - Utilizar una protected property que retorne el valor del atributo para exponerlo a una clase derivada. { private int handle; protected int Handle { get {
Ejemplo:
public class Control: Component
return handle; } } } REC - Utilizar atributos public static read-only para instancias predefinidas de los objetos de la clase. Debe utilizarse nomenclatura Pascal, pues los atributos son pblicos. El siguiente ejemplo muestra el uso correcto de los atributos declarados como public static read-only. public struct Color { public static readonly Color Red = new Color(0x0000FF); public static readonly Color Green = new Color(0x00FF00); public static readonly Color Blue = new Color(0xFF0000); public static readonly Color Black = new Color(0x000000); public static readonly Color White = new Color(0xFFFFFF); public Color(int rgb) { // Insert code here.} public Color(byte r, byte g, byte b) { // Insert code here.} public byte RedValue { get { return Color; } } public byte GreenValue { get { return Color; } } public byte BlueValue { get {
return Color; } } }
Guas para el uso de Parmetros

Fuente de esta informacin: [MSDN - Method Usage Guidelines]. REC - Verificar la validez de los parmetros que se pasan como argumentos. Se recomienda utilizar la clase System.ArgumentException Class, o una clase derivada de System.ArgumentException. Es importante destacar que la validacin que se realiza en este ejemplo, no necesariamente tiene que ocurrir en los mtodos public o protected en s mismos, sino que puede realizarse en un nivel ms bajo que incluya procedimientos privados. El punto clave es que la interfaz de trabajo que se exponga al programador verifique la validez de los argumentos. { public int Count { get { return count; } set { // Check for valid parameter. if (count < 0 || count >= MaxValue) throw newArgumentOutOfRangeException( Sys.GetString( "InvalidArgument","value",count.ToString())); } } public void Select(int start, int end) { // Check for valid parameter. if (start < 0) throw new ArgumentException( Sys.GetString("InvalidArgument","start",start.ToString())); // Check for valid parameter. if (end < start)
Ejemplo: class SampleClass
throw new ArgumentException( Sys.GetString("InvalidArgument","end",end.ToString())); } } Diferencias entre argumentos pasados por valor o por referencia. Cuando se pasan parmetros por valor, slo se realiza una copia del valor, y por lo tanto no tiene efecto sobre el valor original. Ejemplo: public void Add(object value){} Cuando un parmetro es pasado por referencia, lo que se est transmitiendo es la ubicacin en memoria del valor, por lo tanto el valor original es alterado. Ejemplo: public static int Exchange(ref int location, int value){} Un parmetro de salida (output parameter) representa la misma ubicacin en memoria que la variable especificada encomo argumento en la invocacin del mtodo, como resultado los cambios se realizarn slo en el parmetro de salida. Ejemplo: [DllImport("Kernel32.dll"] public static extern bool QueryPerformanceCounter(out long value)
Pgina 31 de 36
TIPOS DE DATOS
Esta seccin describe el uso de tipos para la definicin de variables y atributos. En esta primera versin slo se describe el uso de los tipos struct y enum. REC Utlizacin de tipos struct Es recomendable la utilizacin de tipos struct cuando el tipo de dato cumple alguno de los siguientes criterios: { public const int MinValue = -2147483648; public const int MaxValue = 2147483647; public static string ToString(int i) { // Insert code here. } public string ToString(string format, IFormatProvider formatProvider) { // Insert code here. } public override string ToString() { // Insert code here. } public static int Parse(string s) { // Insert code here. return 0; } public override int GetHashCode() { // Insert code here. return 0; } public override bool Equals(object obj)
Acta como un tipo primitivo Tiene un tamao de instancia menor a 16 bytes. Es esttico. Es deseable que los valores conserven una determinada semntica. Ejemplo:
public struct Int32: IComparable, IFormattable
{ // Insert code here. return false; } public int CompareTo(object obj) { // Insert code here. return 0; } } OBL No debe proveerse un constructor para un tipo strct. C# no permite que un tipo struct posea un constructor predeterminado. El runtime inserta un constructor que inicializa todos los valores a estado cero. Esto permite que los arrays de strcts se creen sin necesidad de ejecutar el constructor en cada instancia. REC Recomendaciones para el uso de enums No debe utilizarse el sufijo enum para los tipos definidos como enum. Es recomendable utilizar tipos enum para parmetros, propiedades y valores de retorno que debe ser fuertemente tipados. Siempre deben definirse valores enumerados utilizando enum si son usados en un parmetro o propiedad. Esto permite que las herramientas de desarrollo conocer los posibles valores para las propiedades o parmetros. { Append, Create, CreateNew, Open, OpenOrCreate, Truncate } REC Utilizar tipos enum en lugar de constants estticas No utilizar tipos enum para conjuntos de valores abiertos. Ejemplo: public enum FileMode
Pgina 33 de 36
ESTILO DE CODIFICACIN
Las preferencias en el estilo de codificacin causa generalmente controversias entre los desarrolladores, pues muchas veces se enfrentan preferencias personales. Sin embargo, establecer un estilo uniforme de codificacin dentro de un centro de desarrollo aporta claridad y genera bibliotecas de cdigo entendible y de fcil mantenimiento. Esta seccin describe el estilo de codificacin que se aplica dentro del departamento de Desarrollo de Infocorp, con el objetivo de crear aplicaciones cuyo cdigo sea claro, consistente y fcil de entender por todos los programadores. REC Las secciones public, protected y private de una clase, deben ser declaradas en ese orden. Si bien C# no posee el mismo concepto que C++ en cuanto al acceso a las regiones de cdigo, ser entendido como un estndar la definicin de las secciones en el orden que se indica. Las variables privadas deben ser declaradas al principio de la clase (preferiblemente cerca su propia #region). Las clases anidadas deben definirse al final de la clase. OBL Uso de operadores Esta regla abarca el uso de los siguientes operadores: Unarios: & * + - ! Incrementales y decrementales: -- ++ Llamadas a funciones y operaciones embebidas: () [] Acceso: . No es permitido agregar espacios en blanco entre estos operadores y sus operandos. No es permitido separar los operadores unitarios de sus operandos con una nueva lnea. Ejemplo: a = -- b; // mal a = --c; // bien a = -b c; // bien REC Utilizar Tabs de 4 espacios Esta medida puede personalizarse en Visual Studio. REC No crear lneas de cdigo de ms de 80 caracteres
Pgina 34 de 36
APNDICE 1 TABLA DE PALABRAS RESERVADAS

Esta tabla resume las palabras reservadas de C#. AddHandler As ByRef Catch CDec CLng CStr Default Each Erase False Friend Handles Inherits Lib Mod MyClass Nothing Option Overrides Protected Region Select Single Structure To Until WithEvents instanceof AddressOf Assembly Byte CBool CDbl CObj CType Delegate Else Error Finalize Function If Integer Like Module Namespace NotInheritable Optional ParamArray Public REM Set Static Sub True volatile WriteOnly package Alias Auto ByVal CByte Char Const Date Dim ElseIf Event Finally Get Implements Interface Long MustInherit New NotOverridable Or Preserve RaiseEvent RemoveHandler Shadows Step SyncLock Try When Xor var
Pgina 35 de 36
And Base Call CChar CInt CShort Decimal Do End Exit Float GetType Imports Is Loop MustOverride Next Object Overloads Private ReadOnly Resume Shared Stop Then TypeOf While eval
Ansi Boolean Case CDate Class CSng Declare Double Enum ExternalSource For Goto In Let Me MyBase Not On Overridable Property ReDim Return Short String Throw Unicode With extends
Pgina 36 de 36

Estandar de COdificación C#

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Estandar de COdificación C#

Caricato da

Copyright:

Formati disponibili

Desarrollo Infocorp www.infocorp.com.uy desarrollo@infocorp.com.

Archivo: Pginas: Fecha: Autor: Contacto: Versin

109933590.doc 36 9/5/2012 15:20:00 a9/p9 Silvia Nane silvian@infocorp.com.uy 3

Condiciones de uso de este documento

Convenciones utilizadas en este documento

Trminos claves Siempre Nunca No hacer Evitar Intentar Razn

Fuentes de informacin consultadas

Debe tener el prefijo I. Ejemplo: IDerivable

Utilizar verbo o verbo-objeto. Ejemplo: ToString

No utilizar prefijos. No utilizar Get / Set como prefijos. Ejemplo: BackColor

Utilizar solo Private fields. No utilizar notacin Hngara (Hungarian Notation).

Notas Ejemplo: _listItem

Constant Static field Read-only

Ejemplo: _maximunItems Utilizar slo atributos Private. Ejemplo: _redValue

Utilizar PascalCase tambin para las opciones. Ejemplo: ErrorLevel

Delegate Event Inline variable Parameter

P P c c Ejemplo: ValueChange Evitar caracteres nicos y tipos enumerados. Ejemplo: typeName

Cdigo Condiciones ternarias (Ternary conditions) For each Condicionales (Conditionals)

Manejos de excepciones (Exception Handling)

Eventos (Events) Bloqueo (Locking)

Dispose() / Close() Finalizers

Guas genricas de nomenclatura

Ejemplo: IsIncludedInList(); CanInsert();

COMENTARIOS Y DOCUMENTACIN EMBEBIDA

Guas para la escritura de comentarios

Guas para la escritura de documentacin embebida

CICLO DE VIDA DE LOS OBJETOS

Guas para la declaracin e inicializacin de variables

Guas para la utilizacin de destructors de clases

Ejemplo: public class IpcPeer

Ejemplo: public class ResourceHolder : IDisposable

Guas para el uso de variables dentro de sentencias loop

Guas para el uso de sentencias de control

GUAS PARA LA PROGRAMACIN DE CLASES

Acerca del uso de propiedades y mtodos

Guas para el uso de Propiedades

Guas para el uso de Eventos

Guas para el uso de Mtodos

Guas para el uso de Constructores

Guas para el uso de Atributos

Ejemplo: public struct Point

public class Control: Component

Guas para el uso de Parmetros

Ejemplo: class SampleClass

public struct Int32: IComparable, IFormattable

APNDICE 1 TABLA DE PALABRAS RESERVADAS

Potrebbero piacerti anche