jueves, 14 de noviembre de 2013

Capítulo 1 de libro examen para certificación 70-536 en español

El Examen 70-536 de nombre TS: Microsoft .NET Framework - Application Development Foundation de Microsoft, liberado el 21 de Marzo del 2008, y que actualmente no está vigente, pero sin embargo, es uno de los mejores libros (a mi gusto) donde están los fundamentos de la programación en .Net, específicamente del Framework 2.0 y por ende una sólida base para los que trabajamos con las siguientes versiones del Framework como la versión 4.0 o 4.5.

Cuando estudié para esta certificación que finalmente no di (de flojo), lo hice con el libro oficial MCTS Self-Paced Training Kit (Exam 70-536): Microsoft® .NET Framework Application Development Foundation, Second edition que en Amazon está en 43,54 dolares unos 21 mil, más el envío a Chile dan un costo total aproximado calculo de unos 28 mil, pero que pillas en Google fácilmente con la palabra clave "70-536 pdf", bueno cuando estudié, realizaba la traducción/transcripción del libro ya que para mí me salía más fácil entender. Este es el primer capítulo, lecciones 1, 2, 3 y 4 traducido al español y que quiero compartir con ustedes ya que lo tenía botado en mi viejo baúl en dropbox:

Leyenda
F: Framework

CAPÍTULO 1 : Fundamentos del Framework

Lección 1: Tipos por Valor

  • String no es por Valor, sino por Referencia.
  • Al usarse una variable por valor en un procedimiento, se hace una copia de esta, por lo que si se hacen cambios adentro, no se ve afectado la variable al salir
  • Son valores chicos, usan 16 bytes o menos cada uno. Son altamente performantes
  • Tipos de datos numéricos y bool son tipos por valor
  • Son datos datos que están directos en memoria, en una zona llamada "Pila"
  • Hay 3 tipos:

1. Build-in: los da el Framework
A. Numéricos: optimizado para Int32, UInt32 y Double
    System.Sbyte -128 a 127
    System.Byte 0 a 255
    System.Int32 / Int C#, Integer en VB –2147483648 a 2147483647   -> Int32 es una estructura y no una clase (ya que esta ultima es un tipo de dato por referencia)
    System.UInt32 0 a 4294967295
    Int64 –9223372036854775808 a 9223372036854775807
    Single –3.402823E+38 a 3.402823E+38
    Double –1.79769313486232E+308 a 1.79769313486232E+308   (más preciso)
    Decimal: –79228162514264337593543950335 a 79228162514264337593543950335   (cientifico/estadistico)
            IntCtr permite que el largo lo defina el SO por ej. Windows 32 o 64 bits, puede ser mas largo o mas corto que el numero que que lo del int
      B. Otros
      System.Char letras unicode
      System.Boolean true/false
      System.IntPr         puntero a memoria
      System.DateTime      momentos en el tiempo

      - Se autodeclaran, tienen implícito un constructor, no requieren new. El constructor le asigna un nulo o 0, pero siempre se debe inicializar. Ejemplo: Bool test = false;
      - C# es case-sensitive, Visual Basic no.
      - Declarar un objeto nulo cuando no se quiere inicializar, se puede usar la sentencia Nullable:
         Nullable b = null;   
         //en C# permite igual   
         bool? b = null;   
         //o también
         int? i = null;
      
      - Para ver si un objeto nullable tiene valor, usar HasValue:
         if (b.HasValue)
      

      2. User-defined
      - Son Estructuras o structs, contienen otros tipos de datos, por ej:
         System.Drawing.Point p = new System.Drawing.Point(20, 30);   // Point es Value Type
      
      - Se pueden crear con la palabra "struct", estas SOLO tienen tipos por VALOR
          struct Cycle
          { 
           int _val, _min, _max;
       
           public Cycle(int min, int max)
           {
           _val = min;
           _min = min;
           _max = max;
           }
      
      - Se puede convertir a tipo por Referencia cambiando Struct por Class, se puede tener 2 variables apuntando a la misma dirección de memoria, quedando en una zona llamada HEAP de la memoria.
      - Al hacer esto se almacena fuera de los 12 bytes de la pila.
      - Usualmente las estructuras son mas eficientes que las clases. Deberías definir estructuras si el tipo anda mejor como tipo por valor que por referencia.
      - Se debe escoger una estructura SOLO si: Lógicamente es como tener un simple valor, tiene un tamaño menor a 16 bytes, no cambiara luego de su creación, no usa tipos por referencia SOLO por Valor.

      3. Enumeraciones
         public enum Genders : int { Male, Female };
         public Genders gender;
      

      Lección 2: Tipos por Referencia

      -La mayoría de los tipos del F son por referencia.
      -Se guarda la dirección de los datos en memoria, no los datos en si, un "puntero" en la pila, en una zona llamada HEAP.
      -El F maneja lo que esta en el HEAP con el Garbaje collector o GC, este escanea la memoria en busca de valores no referenciados.
      -El GC se gatilla cuando el F lo necesita o cuando se ejecuta GC.Collect.
      -Al tener una variable por referencia, si tengo otra que le asigno el valor, en verdad es la copia de la dirección no del valor. Ejemplo:
        struct Numbers
        {
         public int val;
         public Numbers(int _val)
         { val = _val; }
         public override string ToString()
         { return val.ToString(); }
        }  
        Numbers n1 = new Numbers(0);   // -> Numerse es una variable por referencia
        Numbers n2 = n1;
        n1.val += 1;
        n2.val += 2;
        Console.WriteLine("n1 = {0}, n2 = {1}", n1, n2);  // -> N1: 1  N2: 2
        
        Si lo cambiamos a Clase: 
        
        // C#
        Class Numbers
        {
        ... 
      
      La salida es ----> N3: 3 N2: 3 ya que ambos apuntan a la misma dirección no al valor en si. La modificar la referencia, se modifican todas las copias de la referencia.
      Weak refference: es una referencia débil o que puede ser eliminada por el Garbaje Collector a pesar de usar usada y no asignada a null que es cuando el garbaje collector debería eliminarla.
      - Hay 2500 tipo por referencia build-in en el F. No todos derivan del System.ValueType.
      - Tipos por referencia mas comunes: System.Object, System.String, Systen.Text.TextBuilder, System.Array, System.IO.Stream, System.Exception.
      - No todos los tipo de objetos que derivan de System.Object son tipo de objetos por referencia. Puede derivar objeto de tipo por Valor.
      - Strings y String Builders: proveen manipulación de datos.
      - Es mejor usar StringBuilder en vez de String cuando se quiere armar un gran string con pedazos de string mas chicos. No así cuando se quiere buscar o reemplazar.
      -String soporta 32,767 bytes.
         string s = "this is some text to search";  
         s = s.Replace("search", "replace");
      
      -Los string son inmutables en .Net, es decir, cualquier cambio en ellos genera un nuevo string y el viejo pasa a ser marcado como listo para eliminar por el GC. Ejemplo:
         // C#
         string s;
         s = "wombat"; // "wombat"
         s += " kangaroo"; // "wombat kangaroo"
         s += " wallaby"; // "wombat kangaroo wallaby"
         s += " koala"; // "wombat kangaroo wallaby koala" 
      - Solo el último vale y tiene una referencia, los otros se eliminaran por el GC.
      - No tener esos string intermedios ayuda al performance ya que evita que el GC trabaje.
      - Para evitar string intermedios, se puede usar:
      - Métodos Concat, Join o Format de la clase String.
      - Usar clase StringBuilder para trabajar con varios "mutables" strings.
         System.Text.StringBuilder sb = new System.Text.StringBuilder(30);
         sb.Append("wombat"); // Build string.
         sb.Append(" koala");
         string s = sb.ToString(); // Copy result to string.
      
      -La clase String permite sobreescribir operadores de System.Object:
         suma vb + o &  C# +
         igualdad vb =  C# ==
         no igualdad vb <>  c# !=
         asignación vb y c# =
      
      - Como crear y ordenar Arreglos:
         int[] ar = { 3, 1, 2 };   
         Array.Sort(ar);   
         //mostramos los resultados:  
         Console.WriteLine("{0}, {1}, {2}", ar[0], ar[1], ar[2]);
      

      Como crear y usar Streams
      - Los streams se usan para escribir datos en el disco o enviar paquetes por red.
      - El tipo base es System.IO.Stream de otros tipos.
      - Tipos stream para red se ubican en System.Network.Sockets
      - Stream encriptados estan en System.Security.Cryptography namespace.
      - Tipos stream comunes: FileStream, MemoryStream, StreamReader, StreamWriter.
      - StreamReader y StreamWriter te permite escribir y leer archivos del disco.
         use namespace System.IO
         // Escribe en un txt
         StreamWriter sw = new StreamWriter("text.txt");
         sw.WriteLine("Hello, World!");
         sw.Close();   
         // Lee un archivo y muestra
         StreamReader sr = new StreamReader("text.txt");
         Console.WriteLine(sr.ReadToEnd());
         sr.Close();
      

      Como lanzar y capturar Excepciones
      - Las excepciones son "eventos" inesperados que interrumpen la normal ejecución de un assembly.
      - Las excepciones no evitan que un software se caiga sino que sirve para uno se adelante y las capture y maneje
      - Ejemplo:
         use namespace System.IO
         try
         {
          StreamReader sr = new StreamReader(@"C:\boot.ini");
          Console.WriteLine(sr.ReadToEnd());
         }
         catch (Exception ex)
         {
          // If there are any problems reading the file, display an error message
          Console.WriteLine("Error reading file: " + ex.Message);
      
          //Este caso puede arrojar error: file not found error, insufficient privileges error
          //o un error al leer el archivo. Y la ejecucion "salta" al Catch.
         }
      
      - La clase base Exception es muy útil ya que contiene el mensaje de error y mas datos de la aplicación.
      - Uno puede hacer Excepciones propias derivando de System.ApplicationException.
      - Se pueden tener múltiples clases Exceptions para responder diferente a algún tipo de error, el F ejecutara el primer bloque Catch que coincida con el tipo de Exception definido.
      - Se deben ordenar las excepciones desde las mas especificas a la mas global, generalmente Exception.
         Try
          Dim sr As StreamReader = New StreamReader("text.txt")
          Console.WriteLine(sr.ReadToEnd)
          Catch ex As System.IO.FileNotFoundException
           Console.WriteLine("The file could not be found.")
          Catch ex As System.UnauthorizedAccessException
           Console.WriteLine("You do not have sufficient permissions.")
          Catch ex As Exception
           Console.WriteLine("Error reading file: " + ex.Message)
         End Try
      

      -El bloque try/catch soporta un bloque Finally que se ejecuta bien caiga o no en algún Catch. Se usa para cerrar Streams, o limpiar algún objeto.
         StreamReader sr = new StreamReader("text.txt");
         try
         {
          Console.WriteLine(sr.ReadToEnd());
         }
         catch (Exception ex)
         {
          // If there are any problems reading the file, display an error message
          Console.WriteLine("Error reading file: " + ex.Message);
         }
         finally
         {
          // Close the StreamReader, whether or not an exception occurred
          sr.Close();
         }
      

      - Fijarse que el primer bloque StreamReader sr ... se movió afuera del bloque try esto porque el bloque Finally NO pueda acceder a variables declaradas dentro del bloque Try.
      - En general se declaran la variables afuera del bloque try y en el bloque try se programa todo el codigo.
      - Usar un bloque try/catch tiene una baja penalidad en performance pero la tiene.
      - Ejemplo obtener tipo con IF (Object.GetType().IsValueType)
         SByte a = 0;
         Byte b = 0;
         Int16 c = 0;
         Int32 d = 0;
         Int64 e = 0;
         string s = "";
         Exception ex = new Exception();
         object[] types = { a, b, c, d, e, s, ex };
         foreach ( object o in types )
         {
          string type;
          if (o.GetType().IsValueType)
           type = "Value type";
          else
           type = "Reference Type";
          Console.WriteLine("{0}: {1}", o.GetType(), type );
         }
      

      - Unir elementos de un arreglo de string con espacio:
         string s = "Microsoft .NET Framework 2.0 Application Development Foundation";
         string[] sa = s.Split(' ');
         x = string.Join(" ", sa); -> vuelve a estar como antes.
      

      Lección 3: Construyendo clases

      ¿Qué es un Herencia?

      - La consistencia de clases se hace gracias a la herencia e interfaces.
      - La herencia sirve para crear clases a partir de otras o crear nuevos tipos a partir de otros.
      - Por ejemplo la clase Bitmap herada Image pero la extiende, por lo que tiene mas funcionalidades.
      - Puedes crear tu propia Excepcion heredando de System.ApplicationException.
      - Ejemplo obtener tipo con IF (Object.GetType().IsValueType)
         class DerivedException : System.ApplicationException
         {
           public override string Message
           {
             get { return "An error occurred in the application."; }
           }
         }
      
         //Puedes lanzar la exepcion con throw new 
         // C#
         try
         {
            throw new DerivedException();
         }
         catch (DerivedException ex)
         {
            Console.WriteLine("Source: {0}, Error: {1}", ex.Source, ex.Message);
         }
      
      - La nueva excepción tiene .Source por ejemplo ya que aunque no este implementado, al heredar de System.ApplicationException la tiene.
      - La herencia permite el intercambio de clases, por ejemplo si tenemos 5 clases que heredan de System.Drawing.Brush, si el método Graphics.DrawRectangle requiere un objeto System.Drawing.Brush, se le debe pasar alguno de los que heredan y no el padre.

      ¿Que es una interface?

      - Interfaces o "contrato" definen un conjunto común de miembros que todas las clases que la implementan deben proveer.
      - Por ejemplo la interfaz IComparable define el método CompareTo el cual permite comparar 2 clases. Entones todas las clases que implementen la interface IComparable, ya sean clases propias del F o clases tuyas, pueden ser comparadas por la igualdad.
      - La interfaz "IDisposable" es una interface que solo provee un método Dispose.
      - Permite que otros assemblys creen una instancia de tu clase y puedan liberar cualquier recurso que la instancia haya consumido.
      - Usa interface para definir un conjunto de miembros que DEBEN ser implementados por tipos asociados.
      - Permite a uno escribir código para liberar manualmente los recursos.
      - Ejemplo:
         class BigClass : IDisposable
         {
         }
      
      - Luego con Visual Studio, coloca el boton derecho en IDisposable -> Implement Interface -> Implement Interface y Visual Studio automáticamente coloca el código:
         public void Dispose()
         {
            throw new NotImplementedException();
         }
      
      - Otras interfaces muy usadas IComparable, IDisposable, IConvertible, ICloneable, IEquatable, IFormattable.
      - puedes crear tus propias interfaces por si quieres crear múltiples clases que tengan un comportamiento similar.
      - Ejemplo interfaz con 3 miembros:
         // C#
         interface IMessage
         {
         // Send the message. Returns True is success, False otherwise.
         bool Send();
         // The message to send.
         string Message { get; set; }
         // The Address to send to.
         string Address { get; set; }
         }
      
      - Si quieres implementar esa interfaz en tu clase, Visual Studio genera el siguiente template:
         class EmailMessage : IMessage 
         {
          public bool Send()
          {
          throw new Exception("The method or operation is not implemented.");
          }
          public string Message
          {
          get
          {
          throw new Exception("The method or operation is not implemented.");
          }
          set
          {
          throw new Exception("The method or operation is not implemented.");
          }
          }
          public string Address
          {
          get
          {
          throw new Exception("The method or operation is not implemented.");
          }
          set
          {
          throw new Exception("The method or operation is not implemented.");
          }
          }
         }
      
      - Visual Studio permite extraer o armar una Interfaz a partir de los métodos de una clase, con el 2do. botón sobre la clase dada (que puede o no heredar de una interfaz) -> Refactor -> Extract Interface -> seleccionas que miembro quieres extraer, ok
      - Las clases pueden implementar diferentes interfaces a la vez por ejemplo las interfases IComparable, IDisposable:
         class EmailMessage : IMessage, IComparable, IDisposable

      Clases Parciales
      - Son nuevas en .Net 2.0.
      - Permiten dividir una clase en múltiples archivos, con el beneficio de esconder detalles y enfocarse en los aspectos claves.
      - Un Windows form tiene una clase parcial ya que tiene el código generado por el diseñador en la clase media oculta form.Designer.cs. En Visual Basic hay que escoger View All files, en C# esta enable por defecto.
      - Las Clases parciales no son parte del examen.

      ¿Qué es Generics?

      - Son tipos partes del F, permite definir un tipo dejando detalles sin especificar.
      - En vez de especificar los tipos de parámetros o tipos de miembros en clases, puedes dejar que el código lo haga. Esto permite al consumidor de código especificar el tipo que el requiera.
      - Es nuevo en .Net 2.0 y hay muchas preguntas de estas en el examen.
      - Hay clases genéricas por defecto en el namespace de System.Collections.Generic. Incluyendo: Dictionary, Queue, SortedDictionary, y SortedList.
      - Hay tipos genéricos: Nullable y EventHandler (Boolean y Point no lo son).
      - Estas clases funcionan similar a aquellas no genéricas de System.Collections, pero tiene mejoras en performance y son de tipo seguro (safe type), esto quiere decir que no tiene que ver con seguridad, sino que siempre se accede a los objetos asignados de forma compatible.

      ¿Por qué usar Generic?
      - F 1.0 y 1.1 no soportan generic, en vez de eso se usan clases Object para parámetros y miembros que debías castear a otra Clase.
      - Tiene 2 ventajas:
        A. Reduce errores de runtime: el compilador no puede detectar errores si se usa la clase object, por ejemplo si se castea un string a Object y luego de ese Object a int, el compilador no hara catch del error, sino que el runtime lanzará una excepción. Al usar Generic, el compilador detecta el error antes de iniciarse. Adicionalmente puede escribir constraint para limitar el número de clases que usan generic.
        B. Mejora de Performance: Usar Casting requiere lo que se llama "Boxing" o "Unboxing" lo que hace trabajar al procesador y baja el performance, al usar Generic no se usa casting.
      NOTA del autor del libro: En la vida real, en pruebas hechas no hay mejoras sustanciales en performance, bajo 100.000 iteraciones. y son de pocos segundos, por lo que se recomienda usar generic no tanto por performance, pero si por ser "safe type".
      - Ejemplo de clase que usa Object y otra que usa Genérica.
         // C#
         class Obj
         {
          public Object t;
          public Object u;
          public Obj(Object _t, Object _u)  // -> tiene 2 tipos Object
          {
           t = _t;
           u = _u;
          }
         }
         class Gen     // -> tiene los tipos T y U
         {
          public T t;
          public U u;
          public Gen(T _t, U _u)
          {
           t = _t;
           u = _u;
          }
         }
      
      - El código que consume determina si es T y U es Entero o String.
      - Hay una limitante: el código solo funciona si el desarrollo esta hecho para cada instancia de Generic, int o string ya que estamos limitados a la clase Object, igualmente se puede llamar a ToString() o GetHashCode métodos dentro de la clase pero no + o >.
      - Consumir un tipo Generico: aqui se debe especificar el tipo:
         // Add two strings using the Obj class
         Obj oa = new Obj("Hello, ", "World!");
         Console.WriteLine((string)oa.t + (string)oa.u);
         // Add two strings using the Gen class
         Gen ga = new Gen("Hello, ", "World!");
         Console.WriteLine(ga.t + ga.u);
         
         // Add a double and an int using the Obj class
         Obj ob = new Obj(10.125, 2005);
         Console.WriteLine((double)ob.t + (int)ob.u);
         // Add a double and an int using the Gen class
         Gen gb = new Gen(10.125, 2005);
         Console.WriteLine(gb.t + gb.u);
      
      
      Si lo ejecutas la clase con Gen es un poco mas rapido ya que no requiere Box/Unbox de la clase Object.
      - Los errores surgen en compilación y no en run-time. Es mas fácil determinar errores de compilación que errores de ejecución:
         // C#
         // Add a double and an int using the Gen class
         Gen gc = new Gen(10.125, 2005);
         Console.WriteLine(gc.t + gc.u);
         // Add a double and an int using the Obj class
         Obj oc = new Obj(10.125, 2005);
         Console.WriteLine((int)oc.t + (int)oc.u);   // aqui hay error en (int)oc.t ya que es double, al compilar no se da cuenta
      

      Como usar constraint en Generic
      -Interface: permite solo tipos que implementen interfaces especificas para usar en tu generic.
      -Class: permite solo tipos que implementen clases especificas para usar en tu generic.
      -Constructor: permite decir que requiere tipos que usen genéricos para implementar un constructor con parámetros.
      -Tipo por valor o referencia: Requiere que los tipos que usan tu generic sean de tipo valor o referencia.
      - Se puede usar la clausula where para aplicar la constraint. Por ejemplo la constraint para X interfaz:
         // C#
         class CompGen
         where T : IComparable
         {
          public T t1;
          public T t2;
          public CompGen(T _t1, T _t2)
          {
           t1 = _t1;
           t2 = _t2;
          }
          public T Max()
          {
           if (t2.CompareTo(t1) < 0)
            return t1;
           else
            return t2;
          } 
         }
      
      - Si estas creando un clase genérica y necesitas hacer dispose de los objetos genéricos: Usar una Constraint que requiera un tipo Genérico que implemente la interfaz IDisposable. Y no implementar la interfaz IDisposable directamente.

      Eventos
      - La mayoría de las aplicaciones no son lineales, tienen eventos.
      - Un evento es un mensaje que envía un objeto en señal de una acción, que puede ser un clic del mouse, o gatillado por algún otro programa.
      - El objeto que gatilla el evento se llama event sender y el que captura el evento event receiver y lo maneja (lo que se conoce como handle).
      - El objeto que envía no sabe que objeto recibe (handle) el evento por lo que el F provee un guía o puntero entre quien envía y quien recibe, se llama Delegado.
      - Un Delegado es una clase que tiene el control de la referencia. A diferencia de otras clases, una clase delegado tiene una firma o "signature" y esta puede referenciar solo a métodos que coinciden con dicha firma.
      - Una firma o signature en C# es el nombre del método + el tipo del método + Valor/Referencia/Resultado de Parámetros. Ejemplo:
         interface ITest
         {
            void F();                     // F()
            void F(int x);                // F(int)
            void F(ref int x);            // F(ref int)
            void F(int x, int y);         // F(int, int)
            int F(string s);              // F(string)
         }
      
      - Un delegado es el equivalente a una función type-safe o a un callback.
      - Una declaración del delegado es suficiente para definir un clase delegada, esta declaración reemplaza la firma del delegado y el Common Language Runtime provee la implementación.
      - Ejemplo de una declaración de delegado:
         // C#
         public delegate void AlarmEventHandler(object sender, EventArgs e);
      
      - La firma estándar de un delegado que manejada eventos es definir un método que no retorne valor dado, entonces se usa "void" y donde el primer parámetro es la instancia que gatilla el evento, como no sabemos es tipo "Object", y el segundo es de tipo "EventArgs" que mantiene los datos del evento. Si el evento gatillado no tiene datos de evento, el segundo parámetro solo seria una instancia de EventArgs.
      - El delegado EventHandler es predifinido para los casos que se quiere un manejador de eventos que no genera datos de evento.
      - Para asociar al evento con el método que gatillo el evento, agrega una instancia del delegado en el evento. El event handler sera llamado si el evento ocurre a menos que remuevas el delegado.
      - Como responder a un evento: Se debe hacer 2 cosas: A. Crear un método que responda al evento. Este método debe coincidir con al firma del Delegado. Típicamente retorna un "void" y acepta 2 parámetros un "Objeto" y un "EventAgrs" o (clase derivada)
         // C#
         private void button1_Click(object sender, EventArgs e)
         {
           // Method code
         }
      
      B. Agregar el manejador de eventos (en este caso usamos button1_Click) que indica que método debería recibir el evento (apunta al método anteriormente creado):
         // C#
         this.button1.Click += new System.EventHandler(this.button1_Click);
      
      - NOTA: el .NET Framework 2.0 incluye una nueva version generica del tipo "EventHandler".
      - Cuando el evento ocurre, el método especificado se ejecutara.

      Como lanzar un evento
      - Crear un delegado:
         public delegate void MyEventHandler(object sender, EventArgs e);
      - Crear un miembro de un Evento de tipo que coincida con el Delegado creado:
         public event MyEventHandler MyEvent;
      - Invocar el delegado dentro del método cuando lanzas el evento, con VB es muy simple, C# no tanto:
         'VB
          Dim e As EventArgs = New EventArgs
          RaiseEvent MyEvent(Me, e)
          // C#
          MyEventHandler handler = MyEvent;
          EventArgs e = new EventArgs();
          if (handler != null)
          {
           // Invokes the delegates.
           handler(this, e);
          }
          // Note that C# checks to determine whether handler is null.
          // This is not necessary in Visual Basic
      

      Atributos
      - describen un tipo, método, propiedad/miembro con la idea de programar la técnica de Reflection.
      - algunos usos comunes de los atributos son:
      A. especificar privilegios de seguridad que requiere una clase
      B. especificar privilegios para reducir los riesgos de seguridad
      C. declarar capacidades, como soportar serialización -> transformar una clase a ciertos bytes con un formato determinado, por ejemplo transformar a XML. Solo se serializa métodos puplicos.
      D. describe un assembly dándole un titulo, descripción y copyright.
      - Los atributos derivan de Systenm.Attribute.
      - Los atributos se especifican <> en VB o con [] con C#.
      Ejemplo:
         // C# - AssemblyInfo.cs
         [assembly: AssemblyTitle("ch01cs")]
         [assembly: AssemblyDescription("Chapter 1 Samples")]
         [assembly: AssemblyConfiguration("")]
      
      - Visual Studio automáticamente genera atributos como el titulo, descripción, compañía y versión. Deberías editar esos valores en los proyectos que generes.
      - Otro atributo es definir si la clase es serializable, con el atributo Serializable:
         ' VB
          Class ShoppingCartItem
         End Class
         // C#
         [Serializable]
         class ShoppingCartItem
         {
         }
      
      - Sin el atributo Serializable, la clase no se puede serializar.
      - El siguiente código indica que la clase requiere leer el archivo C:\boot.ini, ya con esto, si hay un error (de privilegio u otro), el runtime puede lanzar una excepción ANTES de ejecutar el bloque de código.
      - Ejemplo:
         // C#
         using System;
         using System.Security.Permissions;
         [assembly:FileIOPermissionAttribute(SecurityAction.RequestMinimum, Read=@"C:\boot.ini")]
         namespace DeclarativeExample
         {
          class Class1
          {
           [STAThread]
           static void Main(string[] args)
           {
            Console.WriteLine("Hello, World!");
           }
          }
         }
      

      ¿Qué es el Type Forwarding (Tipo forwardng)?
      - Es nuevo de F 2.0.
      - Es un atributo (implementado en TypeForwardedTo) que te permite mover el tipo de un assembly (Assembly A) a otro (Assembly B), sin necesidad de recompilar los clientes que consumen el assembly A.
      - Luego que un componente (assembly) viaja y es usado por una aplicación, puedes usar Type Forwarding para mover un tipo de una componente a otro assembly y enviar la componente actualizada y las clientes no necesitan ser recompiladas.
      - Type Forwarding: Es utilizado para cuando por ejemplo, tienes una clase en una dll, pero con el paso del tiempo re estructuras tu aplicación y resulta que esa clase ya no queda en esa dll sino en otra. ¿entonces tienes que ir en cada uno de tus clientes a reinstalar la aplicación? No, entonces puedes utilizar TypeForwarding para indicarle al CLR que busque esa clase en otra dll diferente de la dll original.
      - Para mover el tipo de una class library a otro:
      A. Agrega el atributo TypeForwardedTo a la clase de origen.
      B. Corta de la definición del tipo de la source class library.
      C. Pega la definición del tipo en class library destino.
      D. Recompila ambas librerías.
      - Ejemplo: El siguiente código muestra el atributo que es usado para mover TypeA de la class library a un DestLib:
         // C#
         using System.Runtime.CompilerServices;
         [assembly:TypeForwardedTo(typeof(DestLib.TypeA))]
      

      Lección 4: Conversion entre tipos

      Conversiones en VB y C#

      - Por defecto, VB permite conversión implícita, C# no ya que pierde precisión.
      - Para desactivar la conversión implícita en VB agrega "Option Strict On" en casa archivo o en las propiedades del proyecto en VS.
      - Tanto VB y C# permiten conversión implícita si el tipo destino coincide o se acomoda con el tipo de origen. A esto se le conoce como "widening conversion", ej:
         // C#
         int i = 1;
         double d = 1.0001;
         d = i; // Conversion allowed.
      
      - Si el rango del origen excede en precision al tipo destino, esta operación es llamada "narrowing conversion", requiere una conversión explicita.
      - Métodos de conversiones Explicitas:
         
         Tipo System          VB        C#         Convert
         System.Convert                            entre tipos que implmenten IConvertible
                              Ctype    (type)cast 
         type.ToString()
         type.Parse 
         type.TryParse,                            -> nuevo en F 2.0
         type.TryparseExact                        -> nuevo en F 2.0
                             CBool, Cint, CStr, etc  
                             DirectCast
                             TryCast               -> nuevo en F 2.0
      
      - Las conversiones narrowing fallan si el rango del tipo de origen excede el rango del tipo de destino, por lo que se recomienda usar bloques try, o usar TryParse/TryCast para validar la salida.

      Boxing y UnBoxing
      - Hay que tratar de evitarlos si tiene un código que se repite mucho y usas Boxing/UnBoxing.
      Boxing: Convertir un tipo por valor a uno por referencia.
      - Se debe evitar para no tener overhead o "costo de tiempo extra".
      - Boxing se gatilla igualmente mucho llamas métodos virtuales cuya estructura herede de "System.Object", como "ToString".
         // C#
         int i = 123;
         object o = (object) i;
      
      UnBoxing: Convertir un tipo por referencia a uno por valor.
         // C#
         object o = 123;
         int i = (int) o;
      
      - Para evitar este uso:
        -implementar versiones especificas de procedimientos que acepten ese especifico tipo de dato. La mejor opción es crear métodos sobrecargados que uno que acepte el parámetro OBJECT.
        -usar generics en lo posible en vez de usar parámetros Objects.
        -sobreescribe los miembros virtuales "ToString", Equals y GetHash cuando se definan las estructuras.

      Como implementar la Conversión en Tipos Custom.
      A. Definir operadores de conversión para simplificar las conversiones narrowing y widering.
        - Te permite asignar directamente asignar desde un tipo por valor a tu tipo custom.
        - Usa la clausula Widening/implicit úsala para conversiones que no pierdan precisión.
        - Usa la clausula Narrowing/explicit úsala para conversiones que pueden perder precisión.
      B. Sobreescribir ToString() para proveer conversiones PARA string y sobreecribe Parse para proveer conversión DESDE string.
      C. Implementar System.IConvertible para permitir la conversión a través de System.Convert. Usa esta técnica para permitir conversiones de la cultura.
      D. Implementa una clase TypeConverter para permitir una conversión en tiempo de diseño para ser utilizada en la ventana de Propiedades de VS. Conversiones en tiempo de diseño esta fuera del examen.
      Operadores de Conversión
      - Es nuevo en F 2.0.
      - Por ejemplo asignacion DESDE Enteros y HASTA Enteros usando implicit/explicit, sobreescribiendo ToString y evitando hacer boxing:
       // C#
       struct TypeA
       {
        public int Value;
        // Allows implicit conversion from an integer.
        public static implicit operator TypeA(int arg)
        {
         TypeA res = new TypeA();
         res.Value = arg;
         return res;
        }
        // Allows explicit conversion to an integer
        public static explicit operator int(TypeA arg)
        {
         return arg.Value;
        }
        // Provides string conversion (sin boxing).
        public override string ToString()   // -> To sobreescribimos String, evitamos Boxing
        {
         return this.Value.ToString();   // retornamos algo diferente al nombre del tipo (type name).
        }
       }
       //Ahora podemos asignar Enteros directamente:
       // C#
       TypeA a; int i;
       // Widening conversion is OK implicit.
       a = 42; // Rather than a.Value = 42
       // Narrowing conversion must be explicit.
       i = (int)a; // Rather than i = a.Value
       Console.WriteLine("a = {0}, i = {0}", a.ToString(), i.ToString());
      
      - Para implementar la interface "System.IConvertible":
      - Agrega la interfaz "IConvertible" a la definicion del tipo.
      - Con VS hazlo automáticamente y VS insertara 17 declaraciones de miembros, incluyendo "GetTypeCode", "ChangeType" y "ToType" para cada tipo base.
      - No es necesario implementar todos los métodos como "ToDateTime".
      - Para métodos inválidos solo lanza una excepcion "InvalidCastException"
      - Luego de implementar la Interfaz "IConvertible", el tipo custom puede ser convertido usando el estandar "System.Convert":
         // C#
         TypeA a; bool b;
         a = 42;
         // Convert using ToBoolean.
         b = Convert.ToBoolean(a);
         Console.WriteLine("a = {0}, b = {1}", a.ToString(), b.ToString());
      

      Términos importantes del capítulo


      - boxing: Convertir un tipo por valor a uno por referencia. "overhead" o "costo de tiempo extra".
      cast
      constraint
      contract
      exception
      filtering exceptions
      garbage collection
      generic type
      heap
      interface
      narrowing: Conversión con perdida de precisión. Por ejemplo de Int32 a Int16.
      nullable type
      signature: Es una "firma" que consiste en nombre del método + el tipo del método + Valor/Referencia/Resultado de Parámetros. Ejemplo void F(int x); int X(ref int z)
      stack
      structure
      unboxing: Convertir un tipo por referencia a uno por valor.
      widening: Conversión sin perdida de precisión. Por ej de Int16 a Int32.

      Fin Traducción capítulo 1 del libro MCTS Self-Paced Training Kit (Exam 70-536): Microsoft® .NET Framework Application Development Foundation, Second edition

      No hay comentarios:

      Publicar un comentario