Este documento presenta una introducción a los fundamentos básicos del lenguaje de programación C#. Explica los conceptos clave de C# como tipos de datos, clases, interfaces, herencia y namespaces. También describe las herramientas disponibles para el desarrollo en C#, incluido el compilador C# y Visual Studio .NET. Finalmente, brinda un ejemplo simple de cómo crear y usar un componente de software en C#.

1. FundamentosFundamentos
básicos delbásicos del
lenguajelenguaje C#C#

2. Parte 1
Introducción a C#

3. Sistemas Orientados a Componentes
• Com
Modelo de componentes exitoso
Plataforma comercial de componentes viable
Permite la integración y el “re uso” de
componentes en una organización

4. Sistemas Orientados a Componentes
• Sin embargo:
COM está mostrando signos de envejecimiento
DCOM no funciona como se espera en Internet
Mayor uso de componentes = mayor “infierno de DLLs”
Aún con herramientas maduras las implementaciones
no son fáciles
COM no es totalmente “agnóstico” del lenguaje
Hace algunas asunciones respecto del formato binario
Soporta el menor común denominador

5. Concepto de Componentes en .NET
• Se tomo lo mejor de COM+
 Interfaces como contratos abstractos
 Los componentes implementan y exponen interfaces
 Exploración dinámica de las capacidades de los
componentes
 Comportamiento según atributos (transacciones,
“Pooling”, ...)
• Y le agrega
 Verdadera orientación a objetos
 Modelo de eventos nativos
 Re uso de componentes entre lenguajes
 Extensible a todo nivel

6. Porque C# ?
• Primer lenguaje orientado a componentes
Basado en la experiencia de COM+
Soporte nativo para
Namespaces
Versionamiento
Desarrollo basado en atributos
• El poder de C con la facilidad de VB
• Curva de aprendizaje mínima
• Mucho más limpio que C++
• Más estructurado que VB

7. Sección 2:
Elementos de C#
• Forma y estructura
• Entendiendo los tipos del sistema
• Entendiendo el lenguaje C#

8. Forma y Estructura
• No hay archivos de encabezamiento (.H)
No es necesario “declarar” las clases y los tipos
• La declaración y el código están en un solo
lugar
Hace que el código sea más consistente y
mantenible
Facilita la colaboración a nivel equipo de
desarrollo
Declaraciones accesibles: Metadata
• Compilación condicional pero
sin macros

9. Tipos definidos por el Sistema
• Construido sobre el Common Type System
• Conceptos básicos:
 Todo es un objeto
Todo tiene herencia implícita de System.Object
 Distinción entre valores y referencias
Por valor: tipos simples, enumeradores, estructuras
Por referencia: interfaces, clases, vectores

10. Tipos Simples
• Enteros
 byte, sbyte (8bit), short, ushort (16bit)
 int, uint (32bit), long, ulong (64bit)
• IEEE Floating Point
 double (precisión de 15-16 dígitos)
 float (precisión de 7 dígitos)
• Numéricos exactos
 Decimal (28 dígitos significativos)
• Cadenas de caracteres
 char
 string (referencia)
• Boolean
 bool (no es intercambiable con int)

11. Enums
• Colección de elementos nombrados
• Fuertemente tipeados
• Mejor usar "color.Azul" que "3"
 Mas legibilidad del código
 Tan liviano cómo un int
• Ejemplo:
enum Color
{
Rojo,
Verde,
Azul,
Amarillo
};

12. Vectores
• Inician en cero, vinculados por tipo
• Basadas en la clase System.Array de .NET
• Declaración con tipo y forma, pero sin límite
 int[] SingleDim;
 int[,] TwoDim;
 int [][] Jagged;
• Creación utilizando new con límites o inicializadores
 SingleDim = new int[20];
 TwoDim = new int[,]{{1,2,3},{4,5,6}};
 Jagged = new int[1][];
Jagged[0] = new int[]{1,2,3}

13. Interfaces
• Declaración del contrato semántico entre partes
 Permite la orientación a componentes
• Define la estructura y la semántica para propósitos
específicos
• Definición de métodos y propiedades abstractos
• Soporta herencia (múltiple)
• Ejemplo: interface IPersonaEdad
{
int AnioDeNacimiento {get;
set;}
int Edad();
}

14. public class Persona :
IPersonaEdad
{
private int iAnio;
public Persona()
{
}
public int AnioDeNacimiento
{
get { return iAnio;};
set { iAnio = value;};
}
public int Edad()
{
return Today()-
AnioDeNacimiento
};
}
public class Persona :
IPersonaEdad
{
private int iAnio;
public Persona()
{
}
public int AnioDeNacimiento
{
get { return iAnio;};
set { iAnio = value;};
}
public int Edad()
{
return Today()-
AnioDeNacimiento
};
}
Clases
• Implementación de código
y datos
• Implementa interfaces
• Herencia simple
• Las clases contienen:
 Campos: variables miembro
 Propiedades: valores accedidos
a través de get/set
 Métodos: funcionalidad
 Especiales: eventos,
Indexadores, Delegates

15. Estructuras
• Un grupo de código y datos
 Similar a las clases pero:
No permite herencia
Siempre son pasadas por valor
 Clases vs. Estructuras
Estructuras  Contenedor de datos liviano, por valor
Clases  objetos, tipo referenciados
• Desarrolladores C++!
 struct no es un class donde todo es público
• Ejemplo: struct Point
{
double X;
double Y;
void MoveBy(double dX, double dY)
{ X+=dX; Y+=dY; }
}

16. Propiedades
• Mezcla entre campos y métodos
• Uso de propiedades para:
Implementación de miembros sólo lectura
(omitiendo set)
Validación en asignación
Valores calculados o compuestos
Exposición de valores en las interfaces
• Ejemplo: string Name
{
get { return name; }
set { name = value; }
}

17. Indexadores
• Forma consistente de construir
contenedores
• Basados en las propiedades
• Permite el acceso indexado a objetos
contenidos
• El índice puede ser de cualquier tipo
• Ejemplo: object this[string index]
{
get { return
Dict.Item(index); }
set { Dict.Add(index,value); }
}

18. Delegates y Eventos
• Delegate
 Similar a los punteros a funciones de C, C++
 Fuertemente tipeados
 delegate void Clicked(Element e, Point p);
• Eventos
 Modelo de eventos intrínseco al lenguaje (por fin)
 Declaración y llamada en la clase fuente del evento
Button.OnClick += MyClickHandler;
event Click OnClick;
...
OnClick(this,PointerLocation);

19. Atributos
• Similar a los atributos existentes de IDL
• Acceso declarativo a funcionalidad
• Extensible: atributos “Custom”
[Transaction(TransactionOption.Required)]
class MyBusinessComponent { ... }
[PersonFirstName] String Vorname;
[PersonFirstName] String PrimarioNome;

20. Instrucciones
• Muy “C”: control de flujo
 if (<bool expr>) { ... } else { ... };
 switch(<var>) { case <const>: ...; };
 while (<bool expr>) { ... };
 for (<init>;<bool test>;<modify>) { ... };
 Do { ... } while (<bool expr>);
• No muy “C”:
 lock(<object>){ ... };
Secciones críticas
 checked {...}; unchecked { ...};
Protección de sobrecarga de enteros

21. Foreach
• Iteración de colecciones y vectores
• Pueden ser utilizados en clases propias
• Acceso sólo lectura
• Ejemplo:
Point[] Points = GetPoints();
foreach( Point p in Points )
{
MyPen.MoveTo(Point.x,Point.y);
}

22. Sobrecarga de Operadores
• Casi todos los operadores pueden ser
sobrecargados
• No hay sobrecarga para
Asignaciones
Operadores especiales
(sizeof, new, is, typeof)
• Ejemplo:
Total operator +(int Amount, Total t)
{
t.total += a;
}

23. Acceso a los miembros
• Adopción del modelo C++
public  todos pueden acceder
protected  sólo miembros de la herencia
private  sólo miembros de la clase
• Expande el modelo C++:
sealed  no puede ser utilizado como clase
base
internal  acceso público solamente en el
assembly

24. Punteros, necesito punteros
• C# soporta
 Tipo string intrínseco
 Modelo rico de colecciones
 Parámetros por referencia
void increment(ref int value, int by)
 Parámetros de salida
bool add(int a, int b, out int c)
• Eliminación de la mayoría de las causas
• Pero, aún disponible: unsafe
unsafe void crypt(byte[] arr)
{
byte * b = arr;
...
}

25. Manejo de Excepciones
• Muy similar a C++, SEH
• Se debe leer así:
 try ejecutando este código ...
 ... Si se genera un error, catch lo que puedo llegar a
manejar ...
 ...finally permítame hacer alguna limpieza manual
• Ejemplo: try
{
//... código
}
catch(SomeException e)
{
//... Control de error
}
finally
{
//...salida “correcta”
}

26. Namespaces
• Forma de agrupar LÓGICAMENTE clases
Un namespace puede contener a clases y a
otros namespace
Similar al concepto de COMPONENTE COM
Pero desacoplado de la definición física
• Se declaran con namespace
• Referenciados con using

27. Comentarios XML
• Forma consistente de crear
documentación en el código
• ///: Todo lo comentado así va a parar a
la metadata
• Ejemplo:
///<summary>
/// Esta función permite calular el monto
/// final incluyendo todos los impuestos
/// </summary>
public decimal GetTotalValue()
{
}

28. Sección 3: Las Herramientas
• Framework SDK – herramientas básicas
C# Compiler
Visual Debugger
NMake
• VisualStudio.NET agrega
Ambiente visual
Asistentes y plantillas
Ayuda “Inteligente”

29. Framework SDK
• Contiene al compilador C# (y VB, C++,
JScript)
Se ejecuta desde la línea de comando
• Visual Debugger – GuiDebug
Acceso completo al runtime y los metadatos
• Herramientas
NMake, Security, Configuration, IL
Disassembler, ...
• Gratis para todos

30. Ejemplos
• “Hola mundo”
namespace Consola
{
using System;
public class Class1
{
public Class1()
{
}
public static int Main(string[] args)
{
Console.WriteLine("Hola, mundo");
Console.Read();
return 0;
}
}
}
namespace Consola
{
using System;
public class Class1
{
public Class1()
{
}
public static int Main(string[] args)
{
Console.WriteLine("Hola, mundo");
Console.Read();
return 0;
}
}
}

31. Ejemplos – Comentarios XML
using System;
/// <summary>
/// Muestra en pantalla la frase "hola, mundo"
/// </summary>

32. Parte 2
Desarrollo de Componentes
• Contenido
Introducción a componentes .NET
Interoperabilidad con COM+

33. 1. Introducción a Componentes
.NET
• Grupo de clases que están típicamente bajo
un Namespace común
• Las clases que sean públicas se expondrán
hacia fuera del componente
• Todo elemento “público” de cada clase se ve
fuera de ella
• No se registra el componente en ningún lado

34. Ejemplo de Componente .NET
en C#

35. Ejemplo de Componente .NET en C#
namespace Componente1
{
using System;
/// <summary>
/// MiCOmponente.
/// </summary>
public class MiComp1
{
public MiComp1()
{
}
public System.String MiFunc()
/// <summary>
/// Devuelve la hora actual.
/// </summary>
{
return(System.DateTime.Now.ToString());
}
}
}
namespace Componente1
{
using System;
/// <summary>
/// MiCOmponente.
/// </summary>
public class MiComp1
{
public MiComp1()
{
}
public System.String MiFunc()
/// <summary>
/// Devuelve la hora actual.
/// </summary>
{
return(System.DateTime.Now.ToString());
}
}
}

36. Componentes .NET
• Jerarquía de herencia
• Definición de Namespaces
• Implementación física
• Implementación de interfaces

37. Jerarquía de Herencia
• Independiente de los Namespaces
• Independiente de la implementación
física

38. Definición de NameSpaces
• Sirve para ordenar las clases (repaso)
• Es una agrupación lógica

39. Ejemplo de Definición de Namespaces
• MSDNLatam
• MSDNLatam.Nucleo
• MSDNLatam.Nucleo.Datos
• MSDNLatam.Nucleo.Datos.SQL
• MSDNLatam.Nucleo.Datos.ADO
• MSDNLatam.Aplicacion
• MSDNLatam.Aplicacion.Interfaz
• MSDNLatam.Aplicacion.Reglas
• MSDNLatam.Aplicacion.Datos

40. Implementación Física
• DLLs
• Una DLL puede implementar uno o
más Namespaces
• Varias DLLs pueden implementar un
Namespace
• Nada que ver con COM
• Las DLLs no se bloquean
• Puedo tener varias versiones en una
máquina

41. Implementación Física -
Assembly
• Unidad de instalación y versionamiento
• Colección de archivos físicos
• Tiene un número de versión con
formato XX.YY.Xx.yy
• XX e YY tienen que ser exactamente
los mismos que tenga registrados los
clientes

42. Servicio de Componentes -
(Framework .NET)
• Provee:
• Transacciones (DTC, TIP, XA, COMTI)
• Auto Completion
• Activación “Just in time”
• Pooling de objetos
• Colas
• Eventos
• Seguridad basada en roles

43. Servicio de Componentes
• Basados en COM+
• Componentes .NET se “hostean” dentro
de aplicaciones COM+
• Tienen la capacidad de auto registrarse
en COM y dentro de una aplicación

44. ¿Cómo seguimos?
• Encontrará varios “ejercicios” de código
junto a esta presentación
• Cuando los haya realizado, podrá
acceder a la siguiente presentación de
C#
• No olvide, los grupos de noticias están
allí... Para que compartamos
información