Código inseguro

Concepto de código inseguro

    Código inseguro es todo aquél fragmento de código en C# dentro del cual es posible hacer uso de punteros.

    Un puntero en C# es una variable que es capaz de almacenar direcciones de memoria. Generalmente suele usarse para almacenar direcciones que almacenen objetos, por lo que en esos casos su significado es similar al de variables normales de tipos referencia. Sin embargo, los punteros no cuentan con muchas de las restricciones de éstas a la hora de acceder al objeto. Por ejemplo, al accederse a los elementos de una tabla mediante un puntero no se pierde tiempo en comprobar que el índice especificado se encuentre dentro de los límites de la tabla, lo que permite que el acceso se haga más rápidamente.

    Aparte de su mayor eficiencia, también hay ciertos casos en que es necesario disponer del código inseguro, como cuando se desea hacer llamadas a funciones escritas en lenguajes no gestionados cuyos parámetros tengan que ser punteros.

    Es importante señalar que los punteros son una excepción en el sistema de tipos de .NET, ya que no derivan de la clase primigenia System.Object, por lo que no dispondrán de los métodos comunes a todos los objetos y una variable object no podrá almacenarlos (tampoco existen procesos similares al boxing y unboxing que permitan simularlo)

Compilación de códigos inseguros

    El uso de punteros hace el código más proclive a fallos en tanto que se salta muchas de las medidas incluidas en el acceso normal a objetos, por lo que es necesario incluir ciertas medidas de seguridad que eviten la introducción accidental de esta inseguridad

    La primera medida tomada consiste en que explícitamente hay que indicar al compilador que deseamos compilar código inseguro. Para ello, al compilador de línea de comandos hemos de pasarle la opción /unsafe, como se muestra el ejemplo:


 csc códigoInseguro.cs /unsafe

  

    Si no se indica la opción unsafe, cuando el compilador detecte algún fuente con código inseguro producirá un mensaje de error como el siguiente:

 códigoInseguro(5,23): error CS0277: unsafe code may only appear if compiling with /unsafe

    En caso de que la compilación se vaya a realizar a través de Visual Studio.NET, la forma de indicar que se desea compilar código inseguro es activando la casilla View à Property Pages à Configuration Properties à Build à Allow unsafe code blocks

Marcado de códigos inseguros

    Aparte de forzarse a indicar explícitamente que se desea compilar código inseguro, C# también obliga a que todo uso de código inseguro que se haga en un fichero fuente tenga que ser explícitamente indicado como tal. A las zonas de código donde se usa código inseguro se les denomina contextos inseguros, y C# ofrece varios mecanismos para marcar este tipo de contextos.

    Una primera posibilidad consiste en preceder un bloque de instrucciones de la palabra reservada unsafe siguiendo la siguiente sintaxis:


unsafe <instrucciones>

    En el código incluido en <instrucciones> podrán definirse variables de tipos puntero y podrá hacerse uso de las mismas. Por ejemplo:



 public void f()
 {
  unsafe
  {
   int *x;
  }
 }

    Otra forma de definir contextos inseguros consiste en añadir el modificador unsafe a la definición de un miembro, caso en que dentro de su definición se podrá hacer uso de punteros. Así es posible definir campos de tipo puntero, métodos con parámetros de tipos puntero, etc. El siguiente ejemplo muestra cómo definir dos campos de tipo puntero. Nótese sin embargo que no es posible definir los dos en una misma línea:

 
 struct PuntoInseguro
 {
  public unsafe int *X;   //   No es válido hacer public unsafe int *X, Y;
  public unsafe int *Y;   //  Tampoco lo es hacer public unsafe int *X, *Y;
 }

    Obviamente, en un método que incluya el modificador unsafe no es necesario preceder con dicha palabra sus bloques de instrucciones inseguros.

    Hay que tener en cuenta que el añadido de modificadores unsafe es completamente inocuo. Es decir, no influye para nada en cómo se haya de redefinir y si un método Main() lo tiene sigue siendo un punto de entrada válido.

    Una tercera forma consiste en añadir el modificador unsafe en la definición de un tipo, caso en que todas las definiciones de miembros del mismo podrán incluir código inseguro sin necesidad de añadir a cada una el modificador unsafe o preceder sus bloques de instrucciones inseguras de la palabra reservada unsafe. Por ejemplo:

 
 unsafe struct PuntoInseguro
 {
  public int * X, *Y;
 }

 

Código inseguro
José Antonio González Seco

José Antonio es experto en tecnologias Microsoft. Imparte cursos y conferencias en congresos sobre C# y .NET en Universidades de toda España (Sevilla, Barcelona, San Sebastián, Valencia, Oviedo, etc.) en representación de grandes empresas como Microsoft.
Fecha de alta:04/12/2006
Última actualizacion:04/12/2006
Visitas totales:13305
Valorar el contenido:
Últimas consultas realizadas en los foros
Últimas preguntas sin contestar en los foros de devjoker.com
16/07/2007
7
5995
01/12/2009
2
791
18/05/2007
18
7211
14/09/2007
7
5290