Autor Tema: Referenciar Variables Sin Código Inseguro (unsafe) (Leído 3630 veces)

Scherzo · « **en:** Miércoles 29 de Agosto de 2007, 12:51 »

Hola, lo primero presentarme como nuevo usuario del foro. Soy programador de C# desde no hace mucho tiempo, por lo que todavía hay algunas cosas en las que estoy verde. Una de ellas es la que me ha llevado hasta vosotros (desde Google).

En el código que estoy haciendo me encuentro en la situación en la que tengo 5 variables (int) que son contadores. Cada vez que realizo una determinada acción con una tabla incremento el contador correspondiente. El problema es que el contador que he de incrementar viene determinado por la tabla en la que he hecho el proceso, lo que me lleva a realizar en múltiples partes del código consultas sobre la tabla en la que he actuado y así incrementar el contador correspondiente, es decir, algo así (en pseudocódigo):

Código: Text

switch (tabla)
{
    case CENTROS :
        intContadorCentros++;
    case TIENDAS :
        intContadorTiendas++;
    case LOCALES :
        intContadorLocales++;
...
}
 

Bien, no sé si me he sabido explicar. Entonces, lo que quisiera hacer es meter este switch en un único punto y tener una única variable contador que lo que haga sea apuntar al contador real que quiero incrementar, así podría simplemente incrementar este contador 'referencia' y automáticamente se incrementaría el contador real al que esté apuntando, sin necesidad de tener que estar comprobando antes a ver qué contador tengo que incrementar.

En resumen, que mi intContadorReferencia sea una especie de puntero al contador correspondiente.

El problema con el que me encuentro es que C# parece que sólo admite punteros si es mediante código inseguro. La duda que tengo es ¿no hay forma de hacer algo como lo que necesito sin necesidad de tener que meter código inseguro?

Espero no haber sido demasiado brasas para ser el primer mensaje, pero es que no consigo encontrar info por Google y ya no sé si es que no se puede hacer o es que soy demasiado torpe.

Un saludo y muchas gracias por vuestro tiempo/ayuda.

PD: sé que esto se podría hacer mediante una función a la que llame cada vez que necesite incrementar un contador, pero si se puede hacer en plan punteros, lo preferiría, aunque si no queda más remedio, pues lo haría con una función.

Neopro

Veo que utilizas Visual Studio 2005, la opcion para poder admitir eso es :

1.- Permite las llamadas a codigo menos seguro, utilizadas en VS.NET 2003
En el Form1:

Código: Text

           
            CheckForIllegalCrossThreadCalls = false;
 

No se si entendí bien, pero la otra opcion es la siguiente :
2.- Permite la llamada a codigo no seguro (que es lo que creo que necesitas)

Habilitar la opcion en Proyecto->Propiedades de (... nombre del software)

Pestaña Generar Luego Marcar Permitir Código no seguro.

Y despues en tu codigo la parte no segura dejarla como sigue :

Código: Text

unsafe
{
   //Acá Tu código
}
 

Suerte.

Scherzo

Hola, gracias por la rápida contestación.

He visto lo que me has indicado en las opciones de compilación de un proyecto normal, pero en mi caso estoy desarrollando un Web Service y parece que esa opción no aparece entre las opciones de los Web Service, ¿puede ser que no sea posible utilizar código "unsafe" en un servicio web?.

Por otro lado, salvo aplicando la solución que has propuesto, ¿sabes si es posible hacerlo sin utilizar código "unsafe" o no queda más remedio que utilizar código "unsafe"?

Saludos y gracias nuevamente

Neopro

Tienes razon, la opcion es para aplicaciones normales y no web.

Y si la única forma es hacerlo dentro de unsafe o declarar una funcion completa como unsafe.

No se si admite al compilador depurar eso, se debe hacer agregando /unsafe si complicas por consola, pero no se como se hace con WebService.

Suerte.

Mollense

Yo no te entiendo muy bien. ¿Podrías explicarte un poquito mejor?¿Como quisieras hacerlo?

Scherzo

Hola de nuevo, perdona, quizá me expliqué un poco atropelladamente por las prisas.

Mi idea es simular el concepto de un puntero, pero dentro de C# y sin usar código unsafe (que parece ser que es la única forma de poder utilizar punteros). Es decir, cuando yo tengo un objeto y lo igualo a otro, realmente este primer objeto está apuntando al segundo (lo que llaman referenciar), no está copiando su contenido. Entonces sería intentar hacer lo mismo pero con variables de tipo value, las cuales cuando una se iguala a otra sí que copia su contenido.

He intentado representar gráficamente mi idea, espero que así se vea más clara (te adjunto la imagen porque parece ser que todavía no tengo permisos para poder incluir enlaces en los mensaje --la había subido a ImageShack--):

¿Se ve más claro con el esquema?

Saludos y gracias

Neopro

Aaaaaaaaaaaahh...

Cambia la cosa, o sea es manejo de punteros, lo puedes hacer de forma muy parecida a C++ y tambien lo puedes hacer utiliazndo las palabras reservadas REF y OUT.

Ejemplo Descripción
int* p p es un puntero a un entero
int** p p es un puntero a un puntero o a un entero
int*[] p p es una matriz unidimensional de punteros a enteros
char* p p es un puntero a un valor char
void* p p es un puntero a un tipo desconocido

Operador/instrucción Uso
* Para realizar el direccionamiento indirecto de puntero.
-> Para tener acceso a un miembro de una estructura a través de un puntero.
[] Para indizar un puntero.
& Para obtener la dirección de una variable.
++ y -- Para incrementar y reducir punteros.
+ y - Para realizar aritmética de punteros.
==, !=, <, >, <= y >= Para comparar punteros.
stackalloc Para asignar memoria en la pila.
fixed (Instrucción) Para hacer que una variable sea temporalmente fija para que pueda encontrarse su dirección.

en C# no siempre el manejo de punteros significa que sea codigo no seguro.

Y ante cualquier eventualidad, lo ideal es que cuando hagas esos llamados, sean mediante try catch, solo como sugerencia.

Suerte.

Un enlaces utiles :

Enlace

REF

OUT

Scherzo

Gracias por la respuesta, pero leyéndola me surge de nuevo una duda que no me queda del todo clara.

Todo lo que he podido leer (y probar) me da a entender que la única forma de usar punteros es mediante código unsafe. Bien, como lo que quiero hacer quisiera hacerlo sin usar código unsafe, la pregunta del millón sería, ¿se puede hacer lo que necesito sin usar punteros (en el caso que de verdad requieran código unsafe)?, o lo que me valdría igualmente, ¿se pueden usar punteros sin usar código unsafe?. Si es así, ¿sabríais cómo?

Saludos y muchas gracias

Neopro

La opcion es usar valores por referencia con REF u OUT como te indicaba anteriormente, parecido al manejo en Pascal, alli no es necesario unsafe.

No hay mas alternativa.

Scherzo

Oks, gracias, entiendo por lo tanto que eso implica el uso de funciones, ya que para poder usar REF y OUT he de hacerlo en el paso de parámetros.

Saludos y gracias por los comentarios, han sido muy clarificadores.

Mollense

Ahora entiendo

.

Otra cosa que podrías hacer es crearte una clase con atributos estáticos que vendrían siendo los contadores y una función estática que actúe como una especie de Indizador (Ya que no se puede declara un indizador estático), algo así:

Código: Text

class claseContador
    {
        private static int contadorClientes = 0;
        private static int contadorProveedores = 0;
        private static int contadorEmpleados = 0;
 
        public static int incrementar(string nombreTabla)
        {
            switch (nombreTabla.ToUpper())
            {
                case &#34;CLIENTE&#34;:
                    return ++claseContador.contadorClientes;
                break;
                case &#34;PROVEEDOR&#34;:
                    return ++claseContador.contadorProveedores;
                break;
                case &#34;EMPLEADO&#34;:
                    return ++claseContador.contadorEmpleados;
                break;
                default:
                    return -1;
                break;
            }
        }
    }
 

De esta forma podrías incrementar cualquier contador desde cualquier parte del código sin siquiera instanciar un objeto de esta clase.

Ejemplo:

Código: Text

MessageBox.Show(&#34;cliente: &#34; + claseContador.incrementar(&#34;cliente&#34;).ToString());
MessageBox.Show(&#34;cliente: &#34; + claseContador.incrementar(&#34;cliente&#34;).ToString());
 
MessageBox.Show(&#34;proveedor: &#34; + claseContador.incrementar(&#34;proveedor&#34;).ToString());
MessageBox.Show(&#34;proveedor: &#34; + claseContador.incrementar(&#34;proveedor&#34;).ToString());
MessageBox.Show(&#34;proveedor: &#34; + claseContador.incrementar(&#34;proveedor&#34;).ToString());
 
MessageBox.Show(&#34;empleado: &#34; + claseContador.incrementar(&#34;empleado&#34;).ToString());
MessageBox.Show(&#34;empleado: &#34; + claseContador.incrementar(&#34;empleado&#34;).ToString());
 

Podrías agregarle otras funciones estáticas como ser: decrementar, valorActual, etc-

Un saludo y espero que sirva.

Scherzo

Gracias por la sugerencia, es un planteamiento interesante el montarlo como una clase en lugar de como una colección de variables-contadores independientes. Permitiría dejar un código más limpio y manejable, con la posibilidad de añadir de forma sencilla futuras funcionalidades en caso de necesidad (como métodos que generen estadísticas de uso, etc).

Por cierto, y ya que hemos estado tratando el tema del código inseguro. ¿Conoceis algún buen enlace donde haya alguna explicación técnica de las implicaciones que tiene el uso de código inseguro frente al código normal?. Es que los he podido encontrar se limitan a comentar muy por encima lo que es, pero no profundiza a nivel técnico.

Saludos y gracias nuevamente.

SoloCodigo

Autor Tema: Referenciar Variables Sin Código Inseguro (unsafe) (Leído 3630 veces)

Scherzo

Referenciar Variables Sin Código Inseguro (unsafe)

Neopro

Re: Referenciar Variables Sin Código Inseguro (unsafe)

Scherzo

Re: Referenciar Variables Sin Código Inseguro (unsafe)

Neopro

Re: Referenciar Variables Sin Código Inseguro (unsafe)

Mollense

Re: Referenciar Variables Sin Código Inseguro (unsafe)

Scherzo

Re: Referenciar Variables Sin Código Inseguro (unsafe)

Neopro

Re: Referenciar Variables Sin Código Inseguro (unsafe)

Scherzo

Re: Referenciar Variables Sin Código Inseguro (unsafe)

Neopro

Re: Referenciar Variables Sin Código Inseguro (unsafe)

Scherzo

Re: Referenciar Variables Sin Código Inseguro (unsafe)

Mollense

Re: Referenciar Variables Sin Código Inseguro (unsafe)

Scherzo

Re: Referenciar Variables Sin Código Inseguro (unsafe)