Marcos de DesarrolloDiseño e implementación de aplicaciones Web con .NET

Objetivos

Conocer las características del lenguaje de programación C# Aprender a programar utilizando C# Aprender a documentar código en C#

Contenido Introducción Compilador C# Namespaces Sistema de tipos unificado Tipos predefinidos Operadores Entrada / Salida por Consola Sentencias Clases

Estructuras (struct) Enumeraciones (enum) Interfaces Modificadores de acceso Excepciones Sentencia using Generics Anexo I. Documentación XML 

en .NET

Introducción C# es un lenguaje OO usado para desarrollar aplicaciones en la 

plataforma .NET

Diseñado por Microsoft para combinar la potencia de C/C++, Java y la productividad de Visual Basic

El objetivo de C# (y de la plataforma .NET) es reducir el tiempo de desarrollo Permitiendo a los desarrolladores invertir su tiempo trabajando en la lógica de 

negocio en lugar de detalles de programación de bajo nivel

Introducción En C# todo es un objeto

Todo hereda de System.Object

Es posible declarar un tipo primitivo (long) y trabajar con él de forma eficiente. Además, es posible asignarlo a un objeto y entonces será tratado como tal Incluye mecanismos transparentes de boxing y unboxing (se ilustra más 

adelante) Los tipos primitivos sólo se tratan como objetos cuando la situación lo 

requiere, mientras tanto pueden aplicárseles optimizaciones específicas

Hola Mundo1. using System;2.3. namespace Es.Udc.DotNet.CSharpTutorial4. {5. /*6. * Class HellowWorld7. * Description: simple C# example8. */9. class HelloWorld10. {11. #region Test code. Uncomment for testing12.13. /* entry point */14. public static void Main()15. {16. Console.WriteLine("Hello World!");17. Console.ReadLine();18. }19.20. #endregion21. }22. }

Hola Mundo La línea "using System;" significa que accederemos a miembros del 

namespace System

Static es un modificador que indica que se trata de un método de clase

Main() es lo que es denomina el punto de entrada de la aplicación Necesita del modificador static para evitar que para llamarlo haya que 

crear algún objeto de la clase donde se haya definido. Si necesita recibir parámetros: 

public static void Main(string args[])

C# es sensible a las mayúsculas Los métodos y nombres de clases siguen sitáxis PascalCase (e.g., 

FindByUserIdentifier(…)) Los atributos siguen sitáxis camelCase (e.g., firstName)

Introducción Sólo se admite herencia simple

Se admite implementación de múltiples interfaces public class ClaseBase { … } public interface IInterfaz { … } public class ClaseDerivada : ClaseBase, IInterfaz { … }

La clase System.Object Todos los tipos heredan de System.Object

public class Object{

public Object();

public virtual bool Equals(object obj);public static bool Equals(object objA, object objB);public virtual int GetHashCode();public Type GetType();protected object MemberwiseClone();public static bool ReferenceEquals(object objA, object objB);public virtual string ToString();

}

Compilador C# Ubicación Compilador C#

C:\windows\Microsoft.NET\Framework\vn.n.nnn\csc.exe

Sintaxis csc [opciones] fich1.cs [, fich2.cs]

Opciones /out:ficheroSalida

/t:winexe (Interfaz gráfica de ventanas) /t:library

/r:librería.dll (Por defecto se referencia a  mscorlib.dll) /main:clase

Todo esto se puede hacer desde el Visual Studio

Namespaces Declaración:

namespace <NombreEspacio> {

<Definición tipos>}

Anidación de namespaces NmbEspacio1.NmbEspacio2.NmbEspacio3;

Referencia a namespaces externos using

Alias: evita conflictos entre namespaces using <alias> = <NombreCompletoTipo>;

Namespaces

¿A qué namespace pertenece?

using System;using System.Text;using SC = System.Collections;using SIO = System.IO;

static void Main(string[] args){

string filename;

SC.ArrayList namesCollection;

filename = SIO.Path.Combine( ... );

using System;using System.Text;using System.Collections;using System.IO;

static void Main(string[] args){

string filename;

ArrayList namesCollection;

Sistema de Tipos UnificadoTipos valor y referencia

Valor Primitivos int i; Enumeraciones enum State { Off, On } Estructuras struct Point { int x, y; }

Referencia Raíz object String string Clases class Foo : Bar, IFoo {...} Interfaces interface IFoo : IBar {...} Arrays string[] a = new string[10];

Sistema de Tipos UnificadoBoxing & Unboxing

Los tipos valor (struct, enum, int…) pueden ser convertidos en tipos referencia (y viceversa) de forma automática mediante Boxing (y Unboxing)

Boxing:  Encapsulación de tipo valor en tipo referencia Ej: la siguiente sentencia “envuelve” el valor 3 en un objeto

int i = 3;object obj = i;

Unboxing Proceso inverso al boxing. Tratamiento de tipo referencia como tipo valor Ej.: la siguiente sentencia “desenvuelve” el valor

int x = (int) obj;

Tipos predefinidos C# 

Reference object, string Signed sbyte, short, int, long Unsigned  byte, ushort, uint, ulong Character char Floating‐point float, double, decimal Logical bool

Importante: realmente se trata de alias a tipos proporcionados por el sistema

int es un alias a System.Int32 Válido: 

int entero = 100; entero.ToString();

Tipos predefinidos

Tipos predefinidosSufijos Problema:

public static void Foo(int x){...} public static void Foo(long x){...} ¿Llamada Foo(100)?

Tipo del literal entero es el primero que permita almacenarlo: int, uint, long, ulong Foo(100) llama al primer método

Sufijos L (long, ulong), U (int, uint), UL (ulong) F (float), D (double), M (decimal)

Ejemplo Foo(100L) llama al segundo método

Operadores Aritméticos

+, -, *, /, %

Asignación +=, -=, *=, /=, %=, ++, --

Comparación ==, !=, <, >, <=, >=

Lógicos &, &&, |, ||, ~, !, ^

Operadores Obtención de información sobre tipos

typeof(Type t) Obtiene el objeto System.Type para un tipo

<expression> is <type> as

Similar a proceso de casting, pero devuelve null en lugar de InvalidCastException

<expression> as <type> == if (<expression> is <type>) { (<type>) <expression> } else { null }

Type t = typeof(SampleClass);// Alternatively, you could use// SampleClass obj = new SampleClass();// Type t = obj.GetType();

Entrada / Salida por Consola System.Console

Entrada Console.Read(); Console.ReadLine(); Console.ReadKey();

Salida Console.Write(); Console.WriteLine();

Salida con formato Opción 1

Console.Write("Text {n0[:format]}", var0); n0 representa las variables (comienzan en 0) format representa el formato (ver sgte. diapositiva)

Ej: Console.Write("Current Balance: {0}.", balance) Console.Write("Current Balance: {0:C}.", balance)

Opción 2 Console.Write("Text " + var0.ToString("format"))

Si no se especifica formato, puede obviarse la llamada a ToString()

Ej: Console.Write("Current Balance: " + balance.ToString("C")); Console.Write("Current Balance: " + balance);

Salida con formato Formatos numéricos predefinidos

C MonedaD DecimalF Punto FijoP PorcentajeH Hexadecimal

Formatos de fecha predefinidos

d Short Date 6/26/2004 D Long Date Saturday, June 26, 2004 t Short time 8:11 PM T Long Time 8:11:04 PM f Full date/short time Saturday, June 26, 2004 8:11 PM F Full Date Saturday, June 26, 2004 8:11:04 PM

Sentencias Condicionales

if switch

Iterativas while do for foreach

Sentencias condicionalesif Sintaxis General

if (condition)<statementsIF>

else<statementsELSE>

Sentencias condicionalesswitch Sintaxis General

¡Obligatorio incluir break al final de cada rama!

switch (i) {case 1:statements;break;

case 2:statements;break;

default:statements;break;

}

switch (str) {case "ABC":statements;break;

case "XYZ":statements;break;

default:statements;break;

}

Sentencias iterativas while Sintaxis General

while (condition) {<statements>

}

Puede incluir instrucciones break y/o continue

Sentencias iterativasdo...while Sintaxis General

do {<statements>

} while(condition)

Puede incluir instrucciones break y/o continue

Sentencias iterativasfor Sintaxis General

for (initialize-statements; condition; increment-statements)

{statements;

}

Ejemplosfor (int = i; i<10; i++) for(int i=0, j=0;i<5;i++,j++){}{ {

<<statements>> <<statements>>} }

Puede incluir instrucciones break y/o continue

Sentencias iterativasforeach Sintaxis General

foreach (<Type> <e> in <collection>) {<statements>

}

Ejemplo

String[] daysOfWeek = { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" }; // Print the days of the week foreach (string day in daysOfWeek) { Console.WriteLine(day); } 

Clases Las clases C# son similares a las clases Java C# permite los siguientes miembros de clase (entre otros)

Constructores Destructores Campos Propiedades Métodos

ClasesConstructores Toda clase tiene un constructor. 

Sin embargo, no es obligatorio definirlo.  Caso de no definir ningún constructor, el compilador crea uno sin parámetros ni instrucciones (constructor por defecto)

Los constructores no se heredan.

La llamada al constructor de una clase hija desencadena llamada a constructor sin parámetros de la clase padre. A continuación se ejecuta el constructor de la clase hija.

Se puede llamar a otro constructor de la clase padre con el inicializador base.

public MyDerivedClass(int x, string s) : base (s, x){

<<class contents>>}

Inicializador del constructor

ClasesConstructores

Es posible sobrecargar los constructores.

Desde el código de un constructor puede llamarse a otros constructores de la misma clase, con el inicializador this.

public MyClass(int x) : this(x, "Using Default String"){

<<class contents>>}

Inicializador del constructor

ClasesConstructores

Ejemplo (1 de 3) class SuperClass { private string argument1; public SuperClass() : this("<Default arg1>") { } public SuperClass(string arg1) { this.argument1 = arg1; Console.WriteLine("Arguments: " + argument1); } public static void Main() { // Creating a SuperClass instance SuperClass sc = new SuperClass(); /* Shows: * Arguments: <Default arg1> */ Console.ReadLine(); } } 

ClasesConstructores

Ejemplo (2 de 3) class ChildClass : SuperClass { private string argument2; public ChildClass() : this("<Default arg2>") { } public ChildClass(string arg2) { this.argument2 = arg2; Console.WriteLine("Arguments: " + argument2); } public ChildClass(string arg1, string arg2) : base(arg1) { this.argument2 = arg2; Console.WriteLine("Arguments: " + argument2); } }

ClasesConstructores

Ejemplo (3 de 3)

public static void Main() { SuperClass sc = new SuperClass(); ChildClass cc = new ChildClass(); ChildClass cc2 = new ChildClass("1", "2"); Console.ReadLine(); }

/* Shows:* Arguments: <Default arg1>*/

/* Shows:* Arguments: <Default arg1>* Arguments: <Default arg2>*/

/* Shows:* Arguments: 1* Arguments: 2*/

ClasesConstructores

Permiten inicialización de código, que se realizará una única vez para la clase

Garantizan la ejecución antes de:a) La creación de la primera instancia de la claseb) El acceso a cualquier miembro estático

Un único constructor estático por clase

No pueden tener parámetros

Equivalente a bloque static de Java

ClasesConstructores estáticos

Llamada automática al acceder por primera vez a la clase

public class LogManager { private static FileStream logFile; // Static Constructor opens the file static LogManager() { logFile = File.Open("logFile.dat", FileMode.Create); } public LogManager() { logFile.WriteLine(System.DateTime.Now.ToString() + " Instance created"); } } 

ClasesConstructores estáticos

Llamado automáticamente por Garbage Collector cuandodetecta que no existen referencias a ese objeto

GC se ejecuta automáticamente. También puede llamarse explícitamente: System.GC.Collect() No garantiza borrado de memoria

Los destructores no se heredan

public class LogManager { ~LogManager() { logFile.WriteLine(System.DateTime.Now.ToString() + " Instance Disposed"); logFile.Close(); } } 

ClasesDestructores

Se evalúan en tiempo de compilación

Son implícitamente estáticas (error si se usa staticexplícitamente)

Deben ser inicializadas al ser declaradas

Ejemplo

Ejemplo de acceso desde código externo:

public const string VERSION = "1.0.0";public const string URI = "http://" + "www.google.es";public const double PI = 3.14159265358979;

public const double UNO = Math.Cos(0); //ERROR

MyClass.URI

ClasesCampos constantes

Similares a las constantes, pero…

Se inicializan en tiempo de ejecución

Pueden ser estáticas o por instancia

Deben ser inicializadas al ser declaradas o en un constructor

Una vez inicializadas, no pueden modificarse

Ejemplo:

public readonly double UNO = Math.Cos(0);public static readonly double CERO = Math.Sin(0);

ClasesCampos de sólo lectura

Frecuentemente, en una clase, se declara un atributo como privado y se proporcionan métodos GetXXX / SetXXX para acceder a él. Es un tipo de encapsulación Buena práctica de programación Los atributos no son accesibles desde fuera de la clase Es necesario utilizar los métodos GetXXX / SetXXX

.NET proporciona un mecanismo para encapsular atributos, denominado Properties

ClasesProperties

Ej. Encapsulación sin properties. Definición:/* Traditional Encapsultation Without Properties */class CircleWithGetSet { private double radius; public double GetRadius() { return radius; } public void SetRadius(double radius) { this.radius = radius; } << ... >> }

ClasesProperties

Ej. Encapsulación sin properties. Acceso:

public static void Main() { CircleWithGetSet circle = new CircleWithGetSet(); // Set circle.SetRadius(1); // Get Console.WriteLine("Radius: " + circle.GetRadius()); }

ClasesProperties

Ej. Encapsulación con properties. Definición:

/* Encapsulating Type State with Properties */class CircleWithProperties { private double radius; public double Radius { get { return radius; } /* NOTE: 'value' is a C# reserved word. */ set { radius = value; } } << ... >> } 

ClasesProperties

Ej. Encapsulación con properties. Acceso:

public static void Main() { CircleWithProperties circle = new CircleWithProperties(); // Set circle.Radius = 1; // Get Console.WriteLine("Radius: " + circle.Radius); }

ClasesProperties

Pueden ser de sólo lectura / sólo escritura Para ello bastará con definir únicamente el método de acceso get / set

Son “Pascal Case”

Externamente son accedidas como si de un campo público se tratase, pero internamente es posible asociar código a ejecutar en cada asignación o lectura de su valor

ClasesProperties

C# 3.0 incorpora Automatic Properties No es necesario declarar explícitamente el atributo privado ni las operaciones de asignación y retorno El compilador los generará automáticamente

Para el ejemplo anterior, bastaría escribir:

Es obligatorio definir ambos métodos de acceso (get y set). Sin embargo pueden construirse properties de sólo lectura / solo escritura utilizando el modificador de acceso private

public string Radius { get; set; }

public string Radius { private get; set; }

ClasesProperties

Si se desea incorporar comportamiento, es necesario utilizar las propiedades “tradicionales”

public double Radius{ private get { return radius; } set { if (value < 0) { this.radius = 0; } else { this.radius = value; } } } 

ClasesProperties

NOTA: VS permite crear fácilmente propiedades, definiendo primero el atributo privado y a continuación, sobre el atributo:  Refactor > Encapsulate Field

Genera el código base de una propiedad "tradicional"

Es posible definir propiedades abstractas

Y también formando parte de una Interfazpublic interface IAnInterface { public string APropertie { get; set; } << ... >> }

public abstract class AnAbstractClass{ public abstract string AbstractProp { get; set; } << ... >> }

ClasesProperties

Los métodos, por defecto, no pueden redefinirse son sealed

Para poder redefinir un método Definirlo como virtual En la redefinición del método indicar override

ClasesMétodos

Redefinición de métodos: virtual & override public class Product { public virtual String GetReference() { return barCode; } } public class Book : Product { public override String GetReference() { return ISBN; } } 

ClasesMétodos

Clases Abstractas Una clase abstracta es aquella que forzosamente se ha de derivar si se 

desea que se puedan crear objetos de la misma

Puede contener métodos para los que no se dé directamente una implementación sino que se deje en manos de sus clases hijas darla (métodos abstract)

Una clase abstracta puede no contener métodos abstractos, pero si una clase contiene un método abstracto, ésta debe ser abstracta Los métodos abstractos no pueden contener implementación

Todo método definido como abstract es implícitamente virtual Es necesario incluir el modificador override para darle implementación

En una clase que extiende a una clase abstracta, es obligatorio implementar todos los métodos No puede ser sealed

Clases Abstractas abstract class Person { protected string firstName, lastName; // constructor method... public Person(string firstName, string lastName) { this.firstName = firstName; this.lastName = lastName; } // force derived classes to implement the Greet method by... // marking it abstract... abstract public void Greet(); } class Woman : Person { public Woman(string fName, string lName) : base(fName, lName) { } public override void Greet() { Console.WriteLine("Hello Ms. " + lastName + "!"); } }

Clases Abstractas class Man : Person { public Man(string fName, string lName) : base(fName, lName) { } public override void Greet() { Console.WriteLine("Hello Mr. " + lastName + "!"); } } class Test { public static void Main() { Man m = new Man("Joe", "Bloogs"); m.Greet(); // displays "Hello Mr. Bloggs!" Woman w = new Woman("Jane", "Doe"); w.Greet(); // displays "Hello Ms. Doe!" } }

Clases Sealed Es posible evitar que una clase sea extendida marcándola como clases sealed

Las clases sealed no pueden ser abstractas

// prevent derivation...sealed class Person{

// ...}

Estructuras (struct) Son un tipo especial de clase “ligera”

Son tipos valor.  Se crean en la pila en tiempo de ejecución

Se elimina la sobrecarga de usar referencias 

No pueden extender ningún tipo (pero puede implementar interfaces)

Ningún tipo puede heredar de ellas

La mayoría de los tipos básicos (excepto string y object) están implementados como structs

Ejemplos: Complex, Point, Color

Estructuras (struct) public struct Point { public int X, Y; public Point(int x, int y) { this.X = x; this.Y = y; } } public static void Main() { Point p = new Point(10, 10); Point p2 = p; p2.X = 100; Console.WriteLine("p.X: " + p.X); //Shows "p.X: 10" }  

Enumeraciones (enums) Estructuras con explicitación de elementos

Evitan el uso de números mágicos

obj.ShowMessage(1); vs. obj.ShowMessage(MessageType.WARNING)

Facilitan legibilidad del código

Participan en el mecanismo de comprobación de tipos 

Enumeraciones (enums) Declaración 

Uso

enum MessageType {INFO, WARNING, ERROR }

// Info = 0 Warning = 1 Error = 2

public enum FontSize : int // : int es opcional{

SAMLL = 6,NORMAL = 10,HUGE = 16

}

MessageType messageType = MessageType.WARNING;

Enumeraciones (enums) Los literales de una enumeración son constantes públicas y estáticas

El tipo por defecto de las constantes que forman una enumeración es int, aunque puede dárseles cualquier otro tipo básico entero:  int, byte, sbyte, short, ushort, uint, long, ulong

Si no se especifica valor inicial para cada constante, el compilador les dará por defecto valores que empiecen desde 0 y se incrementen en una unidad para cada constante según su orden de aparición en la definición de la enumeración

Interfaces Similar a la definición de un contrato

Pueden incluir métodos, propiedades, eventos No pueden incluir campos, operadores, constructores o destructores Cualquier implementación de la interfaz debe dar soporte a todas las partes 

del contrato Miembros de una interfaz son por defecto public y abstract

Proporcionan polimorfismo Diferentes clases y estructuras pueden implementar la misma interfaz

No contienen implementación

Interfaces Declaración

Implementación

public interface IUserProfileDAO{

// Interface methodsvoid Create(...);void Delete(...);// Interface propertiesUserProfile LastUser { get; set; }

}

public class UserProfileDAO : IUserProfileDAO{ ... }

public class ArrayList : IList, ICollection, IEnumerable, ICloneable{ ... }

Modificadores de acceso La accesibilidad declarada de un tipo (o miembro de tipo) puede ser:

private:

Solamente puede obtener acceso al tipo o miembro código de la misma clase o struct

protected:

Solamente puede obtener acceso al tipo o miembro código de la misma clase o struct o de una clase derivada

internal:

Puede obtener acceso al tipo o miembro cualquier código del mismo ensamblado

protected internal:

Puede obtener acceso al tipo o miembro cualquier código del mismo ensamblado o cualquier clase derivada de otro ensamblado. Es equivalente a protected + internal

public:

Puede obtener acceso al tipo o miembro cualquier otro código del mismo ensamblado o de otro ensamblado que haga referencia a éste

Modificadores de acceso No todos los tipos o miembros pueden utilizar todos los modificadores de acceso en todos los 

contextos

Si la declaración de un miembro no incluye modificador de acceso, el contexto determina la accesibilidad por defecto

Los namespaces tienen accesibilidad public implícita. No son permitidos los modificadores de acceso.

Las clases, structs, interfaces y enumeraciones (enums) declaradas directamente en un namespacepueden ser public o internal (por defecto) Los miembros de clase pueden declararse con cualquiera de los cinco tipos de acceso (por defecto private) Los miembros de struct no pueden declararse como protected porque los structs no admiten la herencia (ni, 

por lo tanto, protected internal) Los miembros de interfaz tienen accesibilidad public implícita. No son permitidos los modificadores de 

acceso. Los miembros de enumeración tienen accesibilidad public implícita. No son permitidos los modificadores de 

acceso.

La accesibilidad de un miembro nunca puede ser mayor que la de su tipo contenedor. E.g. un método público declarado en un tipo interno sólo tiene accesibilidad interna

Los destructores no pueden tener modificadores de accesibilidad. 

Excepciones Las excepciones son los mecanismos C# para gestionar errores 

inesperados

Mejor que devolver valor de estado No pueden ser ignoradas No tienen porque gestionarse en el punto en el que ocurren Pueden usarse incluso donde no se devuelven valores (e.g. en el acceso a 

una propiedad) Se proporcionan excepciones estándar

En C# no es posible indicar las excepciones que lanza un método (no existe la sentencia throws) Es una buena práctica documentarlas (lo veremos más adelante)

Excepciones Sentencia try...catch...finally

Bloque try contiene código que podría lanzar una excepción

Bloque catch gestiona la excepción Puede haber varios bloques catch para gestionar diferentes tipos de 

excepciones

Bloque finally contiene código que se ejecutará siempre

Excepciones Sentencia throw lanza una excepción

Una excepción se representa como una instancia de System.Exception o una clase derivada Contiene información sobre la excepción Propiedades

Message StackTrace InnerException

Es posible relanzar una excepción, o capturarla y lanzar otra

Excepcionestry { Console.WriteLine("try"); throw new Exception("Message"); } catch (ArgumentNullException e) { Console.WriteLine("Caught null argument"); } catch (Exception e) { Console.WriteLine("catch"); Console.WriteLine("Message: " + e.Message); Console.WriteLine("StackTrace: " + e.StackTrace); } finally { Console.WriteLine("finally"); } 

Sentencia using Objetos que deben limpiarse una vez usados, deberían implementar la 

interfaz System.IDisposable Único método: Dispose()

Sentencia using permite crear una instancia, emplearla y asegurar que tras ello se llama al método Dispose()

Sentencia usingpublic class MyResource : IDisposable{ public void MyResource() { // Acquire valuable resource } public void Dispose() { // Release valuable resource } public void DoSomething() { // Do something } } <<...>> static void Main() { using (MyResource r = new MyResource()) { r.DoSomething(); } // r.Dispose() is called }

Generics Característica de CLR, que permite que las clases, estructuras, 

interfaces y métodos tengan parámetros de tipo genérico para los tipos de datos que almacenan y manipulan Los tipos genéricos son una forma de tipos parametrizados

Generics Uso de una lista implementada sin Generics

List intList = new List(); intList.Add(1); // Argument is boxed intList.Add(2); // Argument is boxed intList.Add("Three"); // Should be an error int i = (int)intList[0]; // Cast required 

Generics Uso de una lista implementada utilizando Generics

List<int> intList = new List<int>(); intList.Add(1); // No boxing intList.Add(2); // No boxing //intList.Add("Three"); // Compile-time error int i = intList[0]; // No cast required 

Generics ¿Por qué utilizar Generics?

Comprobación de tipos en tiempo de compilación Rendimiento (no boxing, no downcasts) Reduce la complejidad del código

Generics Los tipos genéricos pueden aplicarse a 

Clases, estructuras, interfaces, … 

class Dictionary<KeyType, ValueType> {...}struct Pair<FirstType, SecondType> {...}interface IComparer<T> {...}

<< ... >>

Dictionary<string, Customer> customerLookupTable;Dictionary<string, List<Order>> orderLookupTable;Dictionary<int, string> numberSpellings;

Generics Los tipos genéricos pueden aplicarse a 

… y métodos

class Array {public static T[] Create<T>(int size) {

return new T[size];}

public static void Sort<T>(T[] array) {...

}}

<< ... >>

string[] names = Array.Create<string>(3);names[0] = "Jones";names[1] = "Anderson";names[2] = "Williams";Array.Sort(names);

Marcos de DesarrolloDiseño e implementación de aplicaciones Web con .NET

Documentación XML en .NET Comentarios XML que emplean conjunto de etiquetas predefinidas 

Etiquetas de uso genérico <summary> <remarks> <see> <seealso> <permission>

Etiquetas relativas a excepciones <exception>

Etiquetas relativas a métodos <param> <paramref> <returns>

Etiquetas relativas a formato <example> <code> <c> <para>

Etiquetas relativas a propiedades <value>

Etiquetas XMLEtiquetas de uso genérico

<summary> Indica un resumen sobre el significado del elemento al que precede Se puede emplear junto con la etiqueta <remarks> para añadir 

información complementaria sobre el propio elemento.

///<summary>/// Esta clase es de muestra para la documentación///</summary>///<remarks> Esta clase no realiza ninguna acción, sólo /// sirve de muestra</remarks>public class Documentacion{

public Documentacion(){

// TODO: Add constructor logic here}

}

Etiquetas XMLEtiquetas de uso genérico <see>

Indica hipervínculos a otros elementos de la documentación

<seealso> Indica un elemento cuya documentación guarda relación con la del elemento al que 

precede 

Ambas etiquetas carecen de contenido y el nombre del elemento al que remiten se indica en su atributo cref.

/// <summary>/// Muestra por la salida estándar el mensaje ¡Hola!./// Si no sabe como se escribe en pantalla puede consultar la/// documentación del método <see cref="System.Console.WriteLine"/>./// </summary>/// <seealso cref="System.Console"/>public static void Saluda(){

Console.WriteLine("¡Hola!");}

Etiquetas XMLEtiquetas de uso genérico

<permission> Indica qué permiso necesita un elemento para poder funcionar Suele usarse atributo cref para indicar el tipo del permiso

/// <summary> Método para guardar en disco </summary>/// <permission /// cref="System.Security.Permissions.FileIOPermission">/// Debe de tener permisos de escritura en la /// ruta especificada /// </permission>public void SaveSomething(String path){ ... }

Etiquetas XMLEtiquetas relativas a excepciones <exception>

Especifica qué excepciones se pueden producir en un método

NOTA: para el desarrollo de la práctica, se considerá el uso de esta etiqueta obligatorio!

/// <exception cref="ConfigurationErrorsException"> Se produce esta /// excepción cuando el parámetro especificado no está definido/// </exception>public String GetParameter(String paramName){

try{

String paramValue = ConfigurationManager.AppSettings["nombreParametro"];

<< ... >>}catch (ConfigurationErrorsException ex){

throw ex;}

}

Etiquetas XMLEtiquetas relativas a métodos <param>

Documenta el significado de un parámetro de un método  <paramref>

Referencia a parámetros de métodos <returns>

Especifica el valor de retorno de un método

/// <summary>/// Método que muestra por pantalla un texto con un determinado color/// </summary>/// <param name="texto"> Texto a mostrar </param>/// <param name="color">/// Color con el que mostrar el <paramref name="texto"/> indicado/// </param>/// <returns> Indica si el método se ha ejecutado con éxito o no </returns>Boolean MuestraTexto(string texto, Color color) { ... }

Etiquetas XMLEtiquetas relativas a formato <example>

Ejemplo sobre cómo usar el elemento al que precede

<code> Se emplea dentro de etiquetas <example> Delimita textos que han de ser considerados fragmentos de código fuente

<c> Indica que el texto dentro de una descripción debe ser marcado como código

<para> Ayuda a separar la sección que se esté escribiendo en párrafos.

Etiquetas XMLEtiquetas relativas a formato

///<summary>/// <para>Crea una nueva instancia de la clase Cliente</para>/// <para>Otro parrafo</para>///</summary>///<example> Ejemplo de cómo realizar la instancia del objeto/// <c>Cliente</c>/// <code>/// Cliente objCliente = new Cliente();/// </code>///</example>

Etiquetas XMLEtiquetas relativas a propiedades

<value> En el caso de las propiedades, este elemento proporciona una descripción del valor 

que se está estableciendo o recuperando

/// <summary>/// Almacena la edad de una persona./// </summary>/// <value> Edad de la persona representada </value>public int Edad{

set { edad = value; }get { return edad; }

}

¿Dónde se almacena la documentación generada? Se puede indicar en VS: 

Solution Explorer > Properties > Build > Output > XML documentation file

Existen herramientas para transformar la documentación XML a otros formatos (.html, .pdf, …)

¿Dónde se almacena la documentación generada? Se puede indicar en VS: 

Solution Explorer > Properties > Build > Output > XML documentation file

Existen herramientas para transformar la documentación XML a otros formatos (.html, .pdf, …) SandCastle

Bibliografía Recomendada:

F. Grimes, Microsoft. Net for Programmers, Manning, 2002.

Complementaria:  Solis, D. Illustrated C# 2010. Apress. 2010.

C# Programming Guide. Disponible en: http://msdn.microsoft.com/en‐us/library/67ef8sbd.aspx

XML Documentation Comments (C# Programming Guide). Disponible en: http://msdn.microsoft.com/en‐us/library/b2s063f7.aspx