---

---

P: ¿Qué es .NET Framework?

R: El .NET Framework es un entorno de ejecución de aplicaciones informáticas sobre el que se ejecuta cualquier programa desarrollado en .NET en cualquiera de sus lenguajes (VB.NET, Visual C++ .NET, Visual C# .NET, Visual J#, NetCOBOL, etc.).

Forma parte de Microsoft .NET que incluye además herramientas de programación (Visual Studio .NET), servidores (Windows 2003 Server o SQL Server), software cliente (Windows XP, Windows CE, Office XP), etc.)

Además, ofrecen un entorno de ejecución común, su instalación es transparente, se acabó el fin de las incompatibilid ades de DLL y otros componentes y las capacidades son las mismas en todos los lenguajes .NET (<< Leer más >>).

P: ¿Qué significa VB?

R: Es Visual Basic, un lenguaje de programación.

P: ¿Cómo debo pronunciar C#?

R: Se lee "c sharp" (en inglés), aunque en castellano, muchísimo menos frecuente, "c almohadilla".

P: Me gusta la idea de aprender un lenguaje .NET, ¿cuál me recomiendas? No conozco ningún lenguaje de programación.

R: C#, sin duda alguna. Lo primero es productivo (rápido y eficiente), potente y moderno. Esta modernidad ha conseguido que actualmente sea el lenguaje de moda, y por ello, es uno de los que más salida tiene en el mercado profesional. Además, te resultará más fácil aprender otros lenguajes como C,C++, Java o Perl.

P: Me gusta la idea de aprender un lenguaje .NET, ¿cuál me recomiendas? Conozco Visual Basic 6.

R: Bien, entonces te recomiendo aprender VB.NET, pero desde 0. Te resultará más cómodo que estar aprendiendo las diferencias que hay con respecto a la versión .NET del lenguaje. Una vez que hayas aprendido a trabajar .NET con VB, te recomiendo que aprendas C# por lo que he comentado antes, y además, ya que una vez conocido como trabaja el .NET Framework te será fácil aprenderlo.

P: Me gusta la idea de aprender un lenguaje .NET, ¿cuál me recomiendas? Conozco C, C++, Java, Delphi o similares.

R: C# será el mejor lenguaje que podrás aprender si conoces alguno de los anteriores. Te sentirás cómodo a la hora de programar pues la sintaxis, que no la semántica, es muy similar. Sin duda, la mejor opción.

P: He decidido aprender C#, ¿por dónde empiezo?

R: Hay un excelente curso para todos los públicos sobre C# en esta misma sección para aprenderlo (próximamente).

P: He terminado de programar mi aplicación, ¿cómo genero el archivo ejecutable?

R: Para crear el archivo ejecutable final de tu programa, debes ejecutar la orden Generar solución (Build solution en la versión inglesa) del menú Generar (Build). El archivo ejecutable se encontrará en el directorio bin\release de tu solución.

P: ¿Cómo convierto código en C# a Visual Basic .NET?

R: Hay una herramienta online desde donde se puede traducir C# a VB .NET, aunque la mejor manera es conociendo los dos lenguajes, pues los resultados de esta no siempre son fiables: Traducir código C# a VB .NET.

P: ¿Y viceversa?

R: La misma herramienta nos proporciona este resultado: Traducir código VB.NET a C#.

P: ¿Qué significa WPF?

R: Son las siglas de Windows Presentation Foundation.

P: ¿Qué es Windows Presentation Foundation?

R: Es el subsistema de Windows (librerías integradas en el sistema operativo), orientado a unificar los mecanismos de creación y gestión de interfaces de usuario.

P: ¿Qué significa XAML?

R: Es un acrónimo inglés: eXtensible Application Markup Language, Lenguaje Extensible de Formato para Aplicaciones en español.

P: ¿Cómo debo pronunciar XAML?

R: Se lee "xammel" (en inglés ).

P: ¿Qué es XAML?

R: Es un lenguaje declarativo basado en XML que define los objetos y sus propiedades usando esquemas XML.

P: ¿Qué es Microsoft Expresion Studio?

R: En su última versión, la dos, esta suite de Microsoft está compuesta por cinco aplicaciones de distinta temática: Expresion Web (el Dreamweaver de Microsoft, para la creación de tus sites web), Expresion Blend (herramienta que nos facilitará la creación de código XAML), Expresion Design (el Photoshop de Microsoft, pero orientado a WPF, podrás importar tus diseños a XAML), Expresion Media (para organizar nuestros archivos digitales), y Expresion Encoder (para la codificación digital de nuestros archivos de audio y vídeo). En está sección se hablará sobre Expresion Blend fundamentalmente.

P: ¿Qué es Microsoft Expresion Blend?

R: Se trata de una herramienta orientada hacia desarrolladores basada en WPF y que genera código en XAML. Nos permite crear interfaces gráficas de una forma visual, clara y sencilla; ofreciendo soporte para ClearType, widgets con gráficos 2D y 3D, etc. Esta herramienta es la clave en la mejora de la productividad entre diseñadores y desarrolladores, pues permite a los primeros generar la visualización de una aplicacióne en ella, mientras que los segundos podrán recoger dichos ficheros y completar la funcionalidad necesaria, como pueden ser los manejadores para los eventos de los controles escogidos por los diseñadores previamente. Os muestro un pantallazo de la aplicación :

P: He decidido empezar a utilizar estas tecnologías, ¿por dónde empiezo?

R: Lo primero que debes hacer es aprender XAML. Una vez que has hecho ésto el uso de Expresion Blend te facilitará la creación de las interfaces en tus aplicaciones WPF. Toda la información para empezar la encontrarás en este subforo.

P: ¿Dónde consigo las herramientas necesarias para empezar?

R: En este tema encontrarás todas las herramientas para empezar.


P: Sigo sin aclarar mi duda, ¿qué hago ahora?

R: Lo primero que debes hacer es buscar en Google, si no encuentras información sobre tu duda, entonces pregunta en esta misma sección.

---

A medida que se me vayan ocurriendo más preguntas iré actualizando la FAQ (se aceptan sugerencias). Espero que sea de su agrado.

Salu2

Herramientas de desarrollo

Para desarrollar bajo la tecnología .Net necesitarás tener instalado en tu ordenador al menos uno de los siguientes programas, cuya recopilación es Visual Studio:


Actualmente hay tres versiones disponibles:

• Express (Gratuita)

• Standard (De pago)

• Professional (De pago)

• Team System (De pago)

Para descargar la versión gratuita de Visual Studio deberás acceder a este sitio, donde podrás descargar los entornos de desarrollo por separado, o en su defecto, la versión completa (Visual Studio).

Al descargar cualquiera de ellos, descargas la ayuda Express, pero si deseas tener la ayuda completa, de manera gratuita, deberás acceder a aquí.

Si deseas probar la versión de prueba de Visual Studio 2008 durante 90 días pulsa sobre la imagen:


Para descargar el Framework 3.5 pulsa sobre la imagen:


Para poder desarrollar juegos con Visual C++ 2008 pulsa sobre la imagen para descargar el plugin "The Game Creator GDK":


No cabe decir que desde los links proporcionados, puedes descargarte todo el material en español (a excepción de este último plugin).

Salu2

Bueno, el código está hecho en C# y corre perfectamente bajo VS 2008. Utiliza el famoso algoritmo de cifrado AES.

Namespaces utilizados:

• System;
• System.Security.Cryptography;

Argumentos:

• PlainText: Texto a cifrar.
• Password: Nuestra contraseña.
• hashAlgorithm: El algoritmo para generar el hash, puede ser MD5 o SHA1.
• SaltValue: Puede ser cualquier cadena.
• InitialVector: Debe ser una cadena de 16 bytes, es decir, 16 caracteres.
• PasswordIterations: Con uno o dos será suficiente.
• KeySize: Puede ser cualquiera de estos tres valores: 128, 192 o 256.

Esta función cifra:

public static string Encrypt(string PlainText, string Password, string SaltValue, string hashAlgorithm, int PasswordIterations, string InitialVector, int KeySize)
        {
            try
            {
                byte[] InitialVectorBytes = Encoding.ASCII.GetBytes(InitialVector);
                byte[] saltValueBytes = Encoding.ASCII.GetBytes(SaltValue);
                byte[] plainTextBytes = Encoding.UTF8.GetBytes(PlainText);
 
                PasswordDeriveBytes password = new PasswordDeriveBytes(Password, saltValueBytes, hashAlgorithm, PasswordIterations);
 
                byte[] keyBytes = password.GetBytes(KeySize / 8);
 
                RijndaelManaged symmetricKey = new RijndaelManaged();
 
                symmetricKey.Mode = CipherMode.CBC;
 
                ICryptoTransform encryptor = symmetricKey.CreateEncryptor(keyBytes, InitialVectorBytes);
 
                MemoryStream memoryStream = new MemoryStream();
 
                CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write);
 
                cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
 
                cryptoStream.FlushFinalBlock();
 
                byte[] cipherTextBytes = memoryStream.ToArray();
 
                memoryStream.Close();
                cryptoStream.Close();
 
                string cipherText = Convert.ToBase64String(cipherTextBytes);
 
                return cipherText;
            }
            catch 
            {
                MessageBox.Show("The typed information is wrong. Please, check it.", "FoS TeaM", MessageBoxButtons.OK, MessageBoxIcon.Stop);
                return null;
            }
        }

Y esta descifra:

 public static string Decrypt(string PlainText, string Password, string SaltValue, string HashAlgorithm, int PasswordIterations, string InitialVector, int KeySize)
        {
            try
            {
                byte[] InitialVectorBytes = Encoding.ASCII.GetBytes(InitialVector);
                byte[] saltValueBytes = Encoding.ASCII.GetBytes(SaltValue);
 
                byte[] cipherTextBytes = Convert.FromBase64String(PlainText);
 
                PasswordDeriveBytes password = new PasswordDeriveBytes(Password, saltValueBytes, HashAlgorithm, PasswordIterations);
 
                byte[] keyBytes = password.GetBytes(KeySize / 8);
 
                RijndaelManaged symmetricKey = new RijndaelManaged();
 
                symmetricKey.Mode = CipherMode.CBC;
 
                ICryptoTransform decryptor = symmetricKey.CreateDecryptor(keyBytes, InitialVectorBytes);
 
                MemoryStream memoryStream = new MemoryStream(cipherTextBytes);
 
                CryptoStream cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read);
 
                byte[] plainTextBytes = new byte[cipherTextBytes.Length];
 
                int decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
 
                memoryStream.Close();
                cryptoStream.Close();
 
                string plainText = Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount);
 
                return plainText;
            }
            catch
            {
                MessageBox.Show("The typed information is wrong. Please, check it.", "FoS TeaM", MessageBoxButtons.OK, MessageBoxIcon.Stop);
                return null;
            }
        }

Salu2

Bien, el bueno de SmartGenius me pidió una pequeña guía para buscar archivos con Visual Basic .NET y aquí os la dejo como regalo de reyes.

Lo primero que vamos a hacer será crear un proyecto del tipo Windows Forms y una interfaz similar a ésta:


Una vez echo esto, empezemos a codear. Lo primero de todo que vamos a escribir es el código del evento Click de nuestro botón para añadir el directorio correcto a buscar.

Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
	Dim Directorio As New FolderBrowserDialog
	If Directorio.ShowDialog = Windows.Forms.DialogResult.OK Then
		TextBox3.Text = Directorio.SelectedPath
	End If
End Sub

Cómo podéis ver creamos un nuevo control FolderBrowserDialog y preguntamos si el usuario ha pulsado el botón Aceptar en él. Si hace esto, el directorio seleccionado será el contenido del cuadro de texto deseado.

Bien, ahora viene lo realmente interesante. Antes que nada os sugiero que importéis el namespace System.IO:

Imports System.IO

Vayamos al control Click de nuestro botón buscar. En nuestra miniaplicación se podrá buscar tanto por el nombre del fichero tanto por el contenido de éste. Para ello, preguntamos que RadioButton está seleccionado.

If RadioButton1.Checked = True Then
	' Buscar por nombre
Else
	' Buscar por contenido
End If

Empezemos por la segunda opción, la de buscar por contenido. Antes que nada, borramos todos los items de nuestro ListBox por si se encuentran otros resultados de búsquedas anteriores.

ListBox1.Items.Clear()

Por si surge algún error, utilizaremso la sentencia Try...Catch. En caso de que aparezca una excepción se creará un nuevo item en nuestro Listbox con la información del error.

Try
Catch ex As Exception
	ListBox1.Items.Add(ex.Message)
End Try

Lo primero que debemos hacer es declarar una variable que contendrá todos los archivos del directorio especificado. Para ello, gracias al método FindInFiles de la clase FileSystem lograremos dicha tarea.

Dim Archivos As System.Collections.ObjectModel.ReadOnlyCollection(Of String)
Archivos = My.Computer.FileSystem.FindInFiles(TextBox3.Text, TextBox2.Text, True, FileIO.SearchOption.SearchAllSubDirectories)

En los parámetros de este método hemos especificado el directorio, el contenido a buscar, si distingue entre mayúsculas y minúsculas y si buscará en los subdirectorios, respectivamente.

Ahora sólo nos falta recorrer la colección y mostrar los resultados en nuestro Listbox.

For Each Archivo As String In Archivos
	ListBox1.Items.Add(Archivo)
Next

El código deberá quedar así:

If RadioButton1.Checked = True Then
	' Buscar por nombre
Else
	' Buscar por contenido
	ListBox1.Items.Clear()
	Try
		Dim Archivos As System.Collections.ObjectModel.ReadOnlyCollection(Of String)
		Archivos = My.Computer.FileSystem.FindInFiles(TextBox3.Text, TextBox2.Text, True, FileIO.SearchOption.SearchAllSubDirectories)
 
		For Each Archivo As String In Archivos
			ListBox1.Items.Add(Archivo)
		Next
	Catch ex As Exception
		ListBox1.Items.Add(ex.Message)
	End Try
End If

Bien, ya sólo nos falta que logre buscar por el nombre del archivo. Para que logre buscar también los subdirectorios del directorio especificado, crearemos un método recursivo, es decir, que se llamará así mismo tantas veces como subdirectorios existan. Tendrá un argumento que será el directorio donde buscará.

Creamos dos variables, una para almacenar el directorio actual y otra para el archivo actual.
A continuación escribimos otro bloque Try..Catch con la misma intención que antes. Esta vez, recorremos todos los elementos de la colección que devuelve el método GetDirectories de la clase Directory pasandole como argumento el directorio deseado. Para no consumir todos los recursos del sistema, utilizaremos el método DoEvents de la clase Application, aunque perfectamente para esta tarea podríamos crear un hilo o hebra. Haríamos un proceso análogo para los archivos del directorio con el método GetFiles de la clase Directory, y esta vez, añadiríamos cada archivo a nuestro ListBox. Al final, debería quedarnos una cosa así:

Private Sub BuscarDirectorio(ByVal sDirectorio As String)
	Dim Directorio As String, Archivo As String
	Try
		For Each Directorio In Directory.GetDirectories(sDirectorio)
			Application.DoEvents()
			For Each Archivo In Directory.GetFiles(Directorio, TextBox1.Text)
				ListBox1.Items.Add(Archivo)
			Next
			BuscarDirectorio(Directorio)
		Next
	Catch ex As System.Exception
		ListBox1.Items.Add(ex.Message)
	End Try
End Sub

Ahora, en el evento click de nuestró botón buscar, debemos llamar al método anterior. Nos quedaría tal que así:

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
If RadioButton1.Checked = True Then
	ListBox1.Items.Clear()
	BuscarDirectorio(TextBox3.Text)
Else
	ListBox1.Items.Clear()
	Try
		Dim Archivos As System.Collections.ObjectModel.ReadOnlyCollection(Of String)
		Archivos = My.Computer.FileSystem.FindInFiles(TextBox3.Text, TextBox2.Text, True, FileIO.SearchOption.SearchAllSubDirectories)
 
		For Each Archivo As String In Archivos
			ListBox1.Items.Add(Archivo)
		Next
 
	Catch ex As Exception
		ListBox1.Items.Add(ex.Message)
	End Try
End If
End Sub

Ya para terminar, podemos hacer que en el evento SelectedIndexChanged de nuestro ListBox ocurra lo siguiente:

Private Sub ListBox1_SelectedIndexChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ListBox1.SelectedIndexChanged
	System.Diagnostics.Process.Start(ListBox1.SelectedItem.ToString())
End Sub

Con ello conseguiremos que al dar click sobre un item de la lista se abra dicho archivo.

Lo bueno siempre termina, y esto no es una excepción . Espero que les haya gustado, y disfruten del día de hoy.

Salu2

Todos sabemos que los atajos del teclado son realmente útiles y nuestra productividad aumenta si los utilizamos. Visual Studio 2008 posee un atajo para casi todas las tareas, por lo que puede llegar a ser muy difícil recordar todos. Aquí os dejo unos posters que recogen todos y ademas son bien chulos . También uno del FrameWork 3.5 con los tipos y Namespaces más utilizados. Unos posters de lujo :8):.

Póster Visual Basic 2008

Póster Visual C# 2008

Póster Visual C++ 2008

Póster Framework 3.5 

Salu2

Conceptos de la arquitectura .NET Framework

El .NET Framework es un entorno de ejecución de aplicaciones informáticas sobre el que se ejecuta cualquier programa desarrollado en .NET en cualquiera de sus lenguajes (VB.NET, Visual C++ .NET, Visual C# .NET, Visual J#, NetCOBOL, etc.).
Forma parte de Microsoft .NET que incluye además herramientas de programación (Visual Studio .NET), servidores (Windows 2003 Server o SQL Server), software cliente (Windows XP, Windows CE, Office XP), etc.)

Además, ofrecen un entorno de ejecución común, su instalación es transparente, se acabó el fin de las incompatibilidades de DLL y otros componentes y las capacidades son las mismas en todos los lenguajes .NET

Arquitectura de .NET Framework


El entorno común de ejecución (Common Language Runtime, CLR) administra el código en tiempo de ejecución y proporciona los servicios básicos (administración de memoria, control de excepciones, control de hilos de ejecución).

Biblioteca de clases base (Base Class Library, BCL) es una colección de código OO que puede ser empleado desde cualquier lenguaje .NET. Contiene los tipos básico, clases para entrada/salida, seguridad, etc.
Al tener definidos los tipos de datos para todos los lenguajes, facilita el intercambio de datos entre aplicaciones desarrolladas en distintos lenguajes.

La capa de datos y XML gestiona el acceso a los datos y el tratamiento de datos XML. Los datos los gestiona mediante ADO.NET y gran parte de la información de .NET (configuración, estructura de archivos y de aplicaciones) se gestiona mediante XML.
También aporta facilidad para importar, exportar y tratar datos de/hacia XML.

ASP.NET utiliza Web Forms (para aplicaciones Web basadas en ASP) y los servicios Web. Windows Forms proporciona un conjunto de componentes de interfaz para desarrollar aplicaciones cliente basadas en Windows.

Common Language Runtime


El cargador de clases (Class Loader) llama al puntero de inicio del procedimiento, establece su entorno de memoria y mantiene la ejecución bajo control.

El control de recursos: recolector de basura, control de la pila, administrador de códigos.

El control de excepciones, el control de seguridad y el  compilador de código nativo interaccionan con el sistema operativo(NOTA; el código intermedio debe compilarse a código nativo).

Las clases base definen el entorno de trabajo sobre el que se apoya el código.

Especificación del lenguaje común (CLS)

El CLS es un conjunto de directivas proporcionadas por Microsoft para el desarrollo de lenguajes compatibles con .NET.
Fijan las características comunes a los lenguajes y los fabricantes pueden ampliarlas o modificarlas.
Una aplicación no debería hacer uso de las características ampliadas cuando se comunique con otros componentes .NET.

Actualmente están desarrollados o en fase de desarrollo más de 50 lenguajes .NET.

Los lenguajes .NET son más parecidos entre si que otros lenguajes clásicos. Por lo tanto, su velocidad de ejecución es bastante similar. La elección de un lenguaje u otro no dependerá de la velocidad de ejecución.
También se garantiza la interoperabilidad entre lenguajes. Todos utilizan los mismos tipos basados en el Sistema de tipo común (Common Type System, CTS) y la posibilidad de crear una aplicación con componentes desarrollados en distintos lenguajes.
Por todo ello, la curva de aprendizaje para un nuevo lenguaje .NET es menor.

Como muestra de ello, un mismo ejemplo del clásico "Hola mundo" en distintos lenguajes .NET

En VB.NET:

Public Class MiPrograma
   Shared Sub main()
      System.Console.WriteLine("¡Hola mundo!")
      System.Console.ReadLine()
   End sub
End Class
 

En C#:

public class MiPrograma{
   static void main(){
      System.Console.WriteLine("¡Hola mundo!");
      System.Console.ReadLine();
   }
}

En J#:

public class MiPrograma{
   public static void Sub main(Strings args[]){
      System.Console.WriteLine("¡Hola mundo!");
      System.Console.ReadLine();
   }
}

Lenguaje intermedio de Microsoft (MSIL)

Los compiladores .NET no producen código nativo (código binario ejecutable directamente por el procesador), si no que producen código intermedio (MSIL o simplemente IL).
Se trata de una especie de lenguaje máquina asociado a un procesador virtual que no corresponde a ninguna CPU disponible en la actualidad.

El compilador de código nativo (compilador JIT, Just-In-Time) de la CLR es el que se encargará de compilar "al vuelo" el código IL a lenguaje nativo de la plataforma donde se ejecute la aplicación.
Esta característica permitirá que el código de una aplicación .NET pueda ejecutarse en otra plataforma distinta sin ningún cambio (siempre y cuando exista un CLR para esa plataforma).


Ensamblados, manifiestos y metadatos

Un ensamblado es la unidad de instalación de una aplicación .NET. Está compuesto de uno o más archivos de recursos y de archivos ejecutables MSIL (módulos administrados).
Los módulos administrados contienen código IL y metadatos que describen los tipos del módulo.
Un ensamblado tendrá un archivo ejecutable portable (PE) que se generará al compilar la aplicación a MSIL. Este archivo será .exe o .dll y no podrá ejecutarse si no está contenido en un manifiesto de ensamblado.

Los ensamblados crean un límite de seguridad, pues es la unidad donde se solicitan y conceden los permisos.
También, crean un límite de tipos, la referencia a un tipo incluye el nombre del ensamblados en que reside.
Además, del límite de tipos, también existe un límite de ámbito de referencia.
El manifiesto del ensamblado contiene metadatos para resolver los tipos: especifica que tipos se exponen fuera del ensamblado y enumera los tipos de ensamblado de los que depende.
En adición, forma un límite de versión, por lo que todos los recursos de un ensamblado pertenecen a la misma versión.
Por otra parte, crean la unidad de implementación. Al arrancar una aplicación sólo deben estar presentes los ensamblados a los que llama la aplicación inicialmente. El resto se recuperan a petición.

Este es el fin al problema de versiones. Las aplicaciones Win32 requieren que los componentes que utiliza estén especificados como entradas del registro. Dos aplicaciones distintas pueden usar el mismo componente, pero con versiones distintas.

Los ensamblados son autodescriptivos, es decir, no dependen de las entradas del registro. La instalación de aplicaciones se simplifica, ya que sólo es necesario copiar los directorios donde están contenidos los recursos a los que llama el ensamblado.
Con éste se instala siempre la versión adecuada de los componentes.

Modelo de ejecución


.NET Framework no es un interprete de bytecode como la máquina virtual Java, pues no traduce las instrucciones una a una, ya que compila todo el método a la vez.
El tiempo de carga inicial es despreciable, porque no carga toda la aplicación a la vez. Además, no necesita utilizar técnicas de optimización de bajo nivel.

El compilador Just-in-Time


El compilador JIT estándar realiza una compilación completa, optimizando el código y verificando su integridad.

El EconoJIT está diseñado para aplicaciones en el que la velocidad de descarga es importante (aplicaciones ASP.NET) o cuando se ejecuta  en dispositivos con recursos ilimitados (Windows CE).
Además, no realiza una optimización del código y permite el rechazo de código.

El generador de imágenes nativas (NGEN) genera código en tiempo de instalación y mejora de rendimiento en casos especiales.

Además, no implica la utilización de código nativo de forma directa.

La biblioteca de clases

La biblioteca de clases (BCL) es un conjunto de clases que permiten a todos los lenguajes .NET realizar tareas comunes (entrada/salida, acceso a BBDD, interfaz de usuario, etc.)

Su forma de acceso es común a todos los lenguajes. Mantiene la interoperabilidad entre lenguajes que se ajustan al CLS. También permite su modificación mediante herencia.

Espacios de nombre

Los espacios de nombres o Namespaces organizan la infinidad de clases de la BCL. Para utilizar los tipos de la BCL de un espacio de nombres concreto se utiliza la notación de punto.
Esto permite agrupar espacios de nombres y clases relacionadas bajo una raíz común.
Por ejemplo, System.Data guarda las clases relacionadas con el acceso a datos, System.Windows.Forms guarda las clases de interfaz para las aplicaciones basadas en formularios Windows...

Cada espacio de nombres se puede guardar en una o varias DLL. La ubicación física no tiene porqué guardar correspondencia con la organización lógica de los Namespaces.

El concepto de espacios de nombres permite ampliar la biblioteca con clases propias de una forma coherente.

Para crear nuevos Namespaces em VB.NET, por ejemplo, se utiliza la declaración Namespace...End Namespace

Namespace CPH
    Namespace MiProyecto
        Class MiClase
        ...
        End Class
    End Namespace
End Namespace

Para utilizar un espacio de nombres ya creado y no usar el nombre completamente cualificado, en VB.NET, se utiliza la declaración Imports. Esta declaración, no importa nada, simplemente añade el Namespace cuando no se utiliza un nombre completamente cualificado.

Imports CPH.MiProyecto
...
Dim xxx As New MiClase()
'Sería lo mismo que utilizar New CPH.MiProyecto.MiClase()

El ensamblado CPH (una biblioteca de clases) incluye 3 espacios de nombres:

'En el ensamblado CPH
Namespace MiProyecto1
    Public Class MiClase
 
    End Class
 
    Public Class MiClase2
 
    End Class
End Namespace
 
Namespace MiProyecto2
    Public Class MiClase3
 
    End Class
End Namespace
 
Namespace MiProyecto3
    Public Class MiClase4
 
    End Class
End Namespace

La aplicación importa 2 Namespaces, por lo que no tiene que utilizar el nombre cualificado para las clases Clase3 y Clase4:

Imports CPH.MiProyecto1
Imports CPH.MiProyecto2
 
Module Modulo1
    Sub Main()
        Dim a As Class1
        Dim b As Class2
        Dim c As MisClases.Class3
        Dim d As MisClases.Class4
    End Sub
End Module

---

---

En este artículo he descrito algunos de los conocimientos que hay que conocer a la hora de trabajar sobre .NET. Cualquier duda o crítica sobre el artículo, háganla aquí por favor.

Salu2

La tecnología .NET de Microsoft ofrece importantes ventajas frente a J2EE de Sun

En junio de 2000 la firma de Redmond presentó un entorno independiente del lenguaje concebido para facilitar el desarrollo de aplicaciones para Windows capaces de trabajar y comunicarse de forma segura y sencilla. Ocho años después el 70% de los desarrolladores españoles utiliza .NET

Las cifras no engañan. En la actualidad la presencia de este entorno de programación de Microsoft en el mercado de las herramientas de desarrollo de aplicaciones para Windows es abrumadora. Y es que esta plataforma se ha consolidado como una alternativa eficaz a J2EE (Java 2 Platform Enterprise Edition) de Sun (http://www.sun.com/java) que, además, proporciona importantes ventajas a la hora de diseñar aplicaciones distribuidas. ¿La clave? Sus dos pilares esenciales: las herramientas y los servicios web.

En las entrañas de .NET

Los componentes que conforman este entorno de desarrollo se denominan .NET Framework y consisten en el CLR (Common Language Runtime) o lenguaje común en tiempo de ejecución, una jerarquía de librerías de clases y soporte para diferentes tipos de aplicaciones, entre las que contempla herramientas modeladas con la arquitectura cliente-servidor tradicional, así como aplicaciones y servicios web. Además, .NET proporciona librerías que facilitan el acceso a bases de datos y código de gestión de XML, no en vano este metalenguaje se ha posicionado en esta plataforma como un estándar de facto para la interoperabilidad de aplicaciones.


El CLR se encuentra en el corazón del entorno, de hecho es una máquina virtual encargada de proporcionar una capa de abstracción entre el bytecode de .NET y la plataforma hardware sobre la que se ejecuta (por ejemplo, la arquitectura x86 y compatibles). Esta capa, equivalente a la máquina virtual de Java en el entorno J2EE, tiene implicaciones serias en lo que al desarrollo y la seguridad de las aplicaciones se refiere. En esencia, el CLR evita que el desarrollador acceda a bajo nivel a la plataforma, siendo este componente el único que puede, por ejemplo, acceder a la memoria y gestionar directamente los punteros. Además, el código desarrollado para la plataforma .NET se ejecuta bajo ciertos roles de seguridad configurables que varían si es de confianza (trusted) y también en función de su procedencia (la intranet, Internet, etc.).

Muchos de los ataques que han sufrido los sistemas operativos Windows han comenzado a desaparecer (entre ellos, el consabido e infame desbordamiento de buffer) debido a que ahora el programador no tiene acceso a la gestión nativa de la memoria de manera directa. Es evidente que tener esta capacidad, esta capa extra que abstrae de la manipulación directa del hardware (igual que ocurre en el entorno Java), tiene su coste en el tiempo de ejecución, máxime si las aplicaciones que escribimos son distribuidas. Cualquier compilador que genere código para la plataforma .NET debe hacerlo en un lenguaje intermedio conocido como IL (Intermediate Language), que a su vez se ajusta a una especificación que aglutina las pautas que deben cumplir los lenguajes .NET (CLS o Common Language Specification). El IL obtenido se traducirá a código nativo usando estrategias just-in-time, por lo que la sobrecarga de tiempo sufrido por esta capa intermedia no resulta excesiva.

Una plataforma plurilingüe

Como mencionamos antes, el Framework .NET es independiente del lenguaje utilizado, lo que significa que los que escojamos para nuestras aplicaciones deben ser traducidos a un lenguaje binario comprensible por la plataforma. Por esta razón, los desarrolladores que utilizan los servicios de esta plataforma pueden emplear varios lenguajes de alto nivel y hacerlos operar entre sí. Microsoft ha creado compiladores para Visual Basic, C++ y C#, aunque también existen compiladores para esta plataforma que no han sido creados por Microsoft.

La neutralidad del lenguaje ha incrementado mucho el atractivo de la tecnología .NET, en especial cuando se considera el coste que es necesario afrontar para migrar desde otras plataformas. De hecho, la migración desde J2EE es prácticamente inmediata, ya que una aplicación Java puede convertirse sin mucho esfuerzo en un programa .NET utilizando compiladores cruzados. Es más, cualquier grupo de desarrolladores Java puede adoptar C# como lenguaje sin graves consecuencias.

C# es el lenguaje abanderado por Microsoft como estandarte para los programadores .NET y, a la par, la herramienta con la que persigue la captación de desarrolladores de otras plataformas. No en vano, para atraer programadores procedentes del entorno Java, Microsoft creó una iniciativa denominada JUMP (Java Users Migration Path), que significa algo así como «el camino que debe seguir un desarrollador Java para programar en .NET». En cualquier caso, Java y C# son dos lenguajes similares, sobre todo a nivel semántico, una capacidad que permite la existencia de aplicaciones que facilitan la conversión entre ambos lenguajes.

¿Es más seguro .NET que J2EE/Java?

La plataforma .NET es, sin lugar a dudas, un marco de ejecución mucho más seguro que el entorno estándar que proporcionaba Windows. Esto no quiere decir que no exista la posibilidad de que se den agujeros de seguridad; de hecho, hay muchos problemas de esta índole a los que se deben enfrentar los desarrolladores. Aun así, es justo decir que carece de muchos fallos de seguridad que Java sí sufrió. Es más, es evidente que Microsoft ha aprendido de los errores que cometió Sun en sus inicios, aunque esto también puede ser contraproducente porque no ha iniciado su camino desde cero, y esa falta de experiencia puede ser también motivo de desconfianza.

Por muy cuidado que esté el desarrollo de la plataforma .NET, y, de hecho, lo está, se puede llegar a la conclusión de que realmente el responsable de las potenciales situaciones de peligro es el propio desarrollador, que en muchas ocasiones ignora los principios básicos de la programación segura. Aquellos programadores que crean aplicaciones web poco seguras con VBScript y ASP a buen seguro escribirán aplicaciones potencialmente inseguras cuando desarrollen con Visual Basic en ASP.NET (un componente del Framework .NET que hace posible la existencia de aplicaciones y servicios web). El CLR no proporciona protección contra el código que contiene defectos o que expone de manera innecesaria información privada o comprometedora. Las librerías de clases de .NET están dotadas de numerosas características de seguridad que se emplean para garantizar que las aplicaciones serán lo más seguras y robustas posible.

En el ámbito de las utilidades web un ejemplo de estas capacidades es la posibilidad de codificar en HTML todos los datos para evitar los ataques XSS o cross-site scripting (que aprovechan las vulnerabilidades del sistema de validación del HTML empotrado), y proporcionar métodos simples pero seguros a la hora de construir consultas SQL dinámicas para evitar ataques por inyección de SQL. Además, el control y la gestión de las sesiones en ASP.NET se han hecho omnipresentes. De esta forma, además del control proporcionado, también se permite el escalado o crecimiento de aplicaciones web desde un servidor a un conjunto de ellos, almacenando las variables de sesión en máquinas de bases de datos SQL-Server.

SOAP y los servicios web

Una característica clave de la plataforma .NET es el soporte de XML como medio para la interacción entre aplicaciones y servicios web. Estos últimos exponen fragmentos de la lógica de negocio de la aplicación fuera de los cortafuegos, aunque normalmente hacen uso de SOAP (Simple Object Access Protocol), un protocolo que facilita el intercambio de datos codificados en XML y la realización de llamadas a procedimientos remotos (invocación de funciones o métodos de otras aplicaciones, ya sean locales o remotas).

El entorno .NET proporciona librerías que aseguran el transporte de los datos a través de un protocolo (como por ejemplo HTTP) y su seguridad empleando certificados digitales y facilitando así la creación de servicios web. El CLR, por su parte, garantiza la robustez de la aplicación que procesa los datos recibidos a través de un servicio web. No obstante, utilizar SOAP para comunicar un componente .NET con otro J2EE no garantiza que este proceso se lleve a cabo sin dificultades. La organización para la Interoperabilidad de Servicios Web (WSI) trabaja para resolver estos inconvenientes, un problema sobre el que es necesario reflexionar a la hora de portar un servicio web a .NET.

Afrontando la migración

Cuando se transporta una aplicación de considerables dimensiones de una plataforma a otra, a buen seguro habrá problemas con el código. En algunos casos el código con el que han sido desarrollados los componentes usados por la aplicación a migrar no está disponible o incluso el hardware al que pretendemos migrar impondrá sus propias condiciones, haciendo que en numerosos casos no sea posible. Las aplicaciones que usan código de bajo nivel para comunicarse con otros componentes de la lógica no pueden ser portadas al entorno gestionado o managed que ofrece el CLR. Por esta razón, Microsoft ha incluido cierta funcionalidad en este último componente que le permite, en determinadas circunstancias, ejecutar código no gestionado (unmanaged) precedido por la sentencia unsafe. Esta palabra clave es muy interesante desde el punto de vista de la seguridad.

Supongamos que una aplicación web gestiona la petición y entrada de datos de los usuarios con C# (código gestionado). Tras ser procesada, esta información es transmitida a un código no gestionado que accede a la memoria compartida de un componente desarrollado por terceros. Este elemento se encarga de la comunicación con el servidor de la empresa. Bajo este escenario el código que se ejecuta en la sección unmanaged puede contener errores, por lo que un usuario del sistema podría dar al traste con toda la aplicación e, incluso, ejecutar código arbitrario. Por esta razón, la palabra clave unsafe debe ser evitada en la medida de lo posible, pues cancela todas las opciones de seguridad que la plataforma y el CLR ofrecen a las aplicaciones.

El Framework .NET también se ve perjudicado por la tentación de empaquetar aplicaciones completas desarrolladas en C++ con esta palabra clave y proclamar que han sido portadas, abriendo enormes agujeros de seguridad injustamente atribuidos a .NET. Esta técnica es popular entre los desarrolladores que andan justos de tiempo para cumplir los plazos impuestos por los clientes.

Previniendo ataques

Cuando se desarrolla código que ha de ejecutarse en el cliente es importante recordar que el usuario puede manipular e interrumpir la ejecución independientemente del lenguaje en que se haya escrito (Java, un lenguaje .NET, C++, C, etc.). Con paciencia y tiempo el código puede ser sometido a técnicas de ingeniería inversa que muestran detalles relevantes, por lo que se recomienda no obviar los consejos de codificación segura y adoptar criterios sensatos, como no incluir en los ejecutables información sensible, en especial contraseñas.

Tanto los bytecodes de Java como los ensamblados de .NET pueden ser fácilmente sometidos a técnicas de este tipo, incluso de manera más sencilla que los ejecutables de una plataforma nativa. Esto se debe a que tanto .NET como Java poseen una capa abstracta intermedia que se apoya en una especificación sencilla y limpia, por lo que «entender» los ejecutables para estas plataformas (existen herramientas como dotfuscator para dificultar estas prácticas) es más sencillo que «descompilar» los ejecutables nativos (que se ejecutarán directamente en los procesadores).

Desde la perspectiva de la seguridad del cliente, un usuario puede establecer reglas que otorguen diferentes privilegios a distintas porciones del código. El que se ejecuta en un entorno restringido y controlado se dice que se procesa en un sandbox o cajón de arena. Un usuario puede elegir ejecutar automáticamente código que ha sido firmado digitalmente por ciertas compañías y, de esta forma, otorgar todos los privilegios sobre su máquina a cualquier código que provenga de la intranet de esas firmas.

De este modo, toda aplicación que provenga de un entorno no identificado será etiquetada como código hostil y su ejecución se llevará a cabo en un entorno restringido y muy controlado. No obstante, se han documentado muchos ataques cuyo origen se atribuye a errores de implementación en los sandbox de varios distribuidores de máquinas virtuales de Java que suelen estar íntimamente relacionados con los cargadores de clases. Y es que si se puede ocultar o falsear la identidad del cargador que proporciona el código a ejecutar en el cliente, entonces es posible permitir que el código de un proveedor no autorizado pueda hacerse pasar por código de un proveedor de confianza, logrando así el acceso a todos los privilegios en el sistema del usuario. Por ahora no se han dado este tipo de ataques en la plataforma .NET.

Un crecimiento imparable

El entorno de desarrollo de Microsoft proporciona muchas mejoras en la seguridad y facilita sensiblemente la implementación de aplicaciones distribuidas. A pesar de que la plataforma de desarrollo J2EE de Sun es bastante más madura que el Framework .NET, los de Redmond están apostando fuerte y se están haciendo con apoyos clave de terceros, muy importantes en el sector. Las ventajas de ejecutar código gestionado son innegables y el CLR ha aprendido de los ataques sufridos por Java, evitando de esta forma una gran parte de las debilidades conocidas hasta la fecha. Sin embargo, es importante recordar que los defectos y errores en la implementación de cada desarrollador son indetectables, y quizás los atacantes estén más interesados en explotar estas debilidades para acceder a los datos de la empresa que en lograr acceso al servidor en el que se está ejecutando la aplicación.

Un artículo más que interesante para decidir entre Java o .NET, o la inmigración del lenguaje de Sun hacia el de Microsoft, aunque con ambos podemos alcanzar una calidad alta en nuestros proyectos .

Salu2

---

Texto adaptado por Mace Windu
Texto original: PCA nº206

using System;
 
namespace CuadradoMagico
{
    class ProgramaAPP
    {
        static void Main(string[] args)
        {
            Console.ForegroundColor = ConsoleColor.Green;
            Console.Title = "Magic Square Builder :P";
            int n = 0;
            do
            {
                Console.Clear();
                Console.Write("Orden del cuadrado mágico (impar): ");
 
                try
                {
                    n = Int32.Parse(Console.ReadLine());
                    if (CuadradoMagico.esPar(n))
                    {
                        Console.WriteLine("El orden debe ser impar.");
                        Console.ReadKey(true);
                    }
                }
                catch(Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    Console.ReadKey(true);
                }
            }
            while (CuadradoMagico.esPar(n));
 
            CuadradoMagico cm = new CuadradoMagico(n);
            cm.Crear();
 
            Console.WriteLine("\n\nEL cuadrado mágico de orden " + n + " es:\n\n");
            cm.Mostrar();
 
            Console.ReadKey(true);
        }
    }
 
    class CuadradoMagico
    {
        private int[,] cm;
        private int n;
 
        public CuadradoMagico(int orden)
        {
            n = orden;
            cm = new int[n, n];
        }
 
        public static bool esPar(int n)
        {
            if (n % 2 == 0) return true;
            else return false;
        }
 
        public void Crear()
        {
            int fil = 0, col = n / 2, fil_ant = 0, col_ant = n / 2, cont = 1;
 
            cm[fil, col] = cont++;
 
            while (cont <= n * n)
            {
                fil--;
                col++;
 
                if (fil < 0) fil = n - 1;
                if (col > n - 1) col = 0;
                if (cm[fil, col] != 0)
                {
                    col = col_ant;
                    fil = fil_ant + 1;
                    if (fil == n) fil = 0;
                }
 
                cm[fil, col] = cont++;
                fil_ant = fil;
                col_ant = col;
            }
        }
 
        public void Mostrar()
        {
            for (int i = 0; i < n; i++)
            {
                Console.Write("\t");
                for (int j = 0; j < n; j++) Console.Write(cm[i, j] + "\t");
                Console.WriteLine();
            }
        }
    }
}

Crea cuadrados mágicos de cualquier orden impar. Ejemplo:


Salu2