Fundamentos
básicos del
lenguaje C#
Daniel A. Seara
Director Regional MSDN
Buenos Aires - ARGENTINA
NDSoft
Parte 1
Introducción a C#
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
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
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
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
Sección 2:
Elementos de C#
• Forma y estructura
• Entendiendo los tipos del sistema
• Entendiendo el lenguaje C#
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
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
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)
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
};
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}
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();
}
Clases
• Implementación de código
y datos
• Implementa interfaces
• Herencia simple
• Las clases contienen:
public class Persona :
IPersonaEdad
{
private int iAnio;
public Persona()
{
}
public int AnioDeNacimiento
{
get { return iAnio;};
set { iAnio = value;};
 Campos: variables miembro
}
 Propiedades: valores accedidos
public int Edad()
{
return Today()AnioDeNacimiento
};
a través de get/set
 Métodos: funcionalidad
 Especiales: eventos,
Indexadores, Delegates
}
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; }
}
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; }
}
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); }
}
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);
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;
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
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);
}
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;
}
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
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;
...
}
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”
}
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
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()
{
}
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”
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
Ejemplos
namespace Consola
{
using System;
public class Class1
{
public Class1()
{
}
• “Hola mundo”
public static int Main(string[] args)
{
Console.WriteLine("Hola, mundo");
Console.Read();
return 0;
}
}
}
Ejemplos – Comentarios XML
using System;
/// <summary>
/// Muestra en pantalla la frase "hola, mundo"
/// </summary>
Parte 2
Desarrollo de Componentes
• Contenido
 Introducción a componentes .NET
 Interoperabilidad con COM+
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
Ejemplo de Componente .NET
en C#
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());
}
}
}
Componentes .NET
•
•
•
•
Jerarquía de herencia
Definición de Namespaces
Implementación física
Implementación de interfaces
Jerarquía de Herencia
• Independiente de los Namespaces
• Independiente de la implementación
física
Definición de NameSpaces
• Sirve para ordenar las clases (repaso)
• Es una agrupación lógica
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
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
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
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
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
¿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
Finalmente...
• Muchas gracias
Daniel A. Seara
Director Regional MSDN
Buenos Aires - ARGENTINA
Descargar

Document