• Miércoles 28 de Julio de 2021, 19:17

Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Temas - E.Baley

Páginas: [1]
1
C# / Propiedades dinámicas
« en: Miércoles 25 de Febrero de 2009, 15:31 »
Una preguntilla cuya respuesta no encuentro, seguramente porque no sé cómo se llama en realidad  a lo que pregunto.
Pretendo definir propiedades de un objeto de forma dinámica, es decir, una vez que ha sido instanciado en run-time. La filosofía es la misma que los "extension methods", pero para propiedades.
¿Alguien sabe si se puede hacer / cómo se hace / dónde buscar ?
Muchas gracias por cualquier orientación o ayuda.

2
C# / consultar propiedades
« en: Miércoles 28 de Enero de 2009, 13:40 »
Usando el Visual Studio ¿ Hay alguna forma de consultar el valor de variables o propiedades de objetos cuando está corriendo una aplicación ?
Cuando pones un punto de interrupción y corres en modo Debug, sí se puede. Simplemente añades la referencia del objeto en la ventana "Inspección" y exploras sus propiedades etc.
Pero si no pones un punto de interrupción, no veo cómo consultar el valor de algunas cosas, aparte de andar con mensajitos (System.Diagnostics.Debug.WriteLine etc...)
Este proceso es muy incómodo.
Por ejemplo, tengo un botón que actualiza parámetros en un objeto. Si quiero consultarlos, tengo que poner un punto de interrupción y parar la aplicación momentáneamente, y explorar desde el inspector.
Entonces, hay otra forma de hacerlo ? podría consultar un objeto sin necesidad de poner puntos de interrupción ?

gracias

3
C# / Problema con archivo binario
« en: Viernes 23 de Enero de 2009, 18:45 »
Hola, a ver si alguien me puede echar una manita por favor:
Tengo un archivo binario que quiero leer. El archivo contiene bloques de 40 bytes que se repiten hasta el final.
Por cada bloque tengo 5 datos de 8 bytes cada uno.

Es decir, tengo:
[dato1, dato2, dato3, dato4, dato5] --> 40 bytes, 8bytes cada uno, y vuelta a empezar con otros 40, etc ...
El primero es un Long que representa una fecha.
Los otros 4 son Doubles.

Bueno, pues necesito leerlos y no puedo.
El problema viene (creo) porque fueron creados en una aplicación Java. En Java, un byte es un sbyte de C#, por tanto lo que tengo es un Stream de sbytes. Lo único que se me ocurre hacer es crear un BinaryReader, y leer todos los sbytes en un Array. A partir de ahí no me sale bien.

Una muestra:

Código: Text
  1.  
  2.     BinaryReader br = new BinaryReader(new FileStream(pathArchivo, FileMode.Open, FileAccess.Read));
  3.  
  4.     // Leo los primeros 40 sBytes
  5.     sbyte[] prueba = new sbyte[40];
  6.     for (int i = 0; i < 40; i++) {
  7.         sbyte sb = br.ReadSByte();
  8.         prueba[i] = sb;
  9.     }
  10.     // Intento recuperar los datos
  11.     Recupera(prueba, 0);
  12.    
  13.     // -----------------------------------------------
  14.     public void Recupera(sbyte[] arr, int offset) {
  15.  
  16.         _time = getLong(arr, offset);
  17.         _d1= getDouble(arr, offset+ 1 * 8);
  18.         _d2= getDouble(arr, offset+ 2 * 8);
  19.         _d3= getDouble(arr, offset+ 3 * 8);
  20.         _d4= getDouble(arr, offset+ 4 * 8);
  21.     }
  22.     // -----------------------------------------------
  23.     private long getLong(sbyte[] arr, int offset) {
  24.  
  25.         return ((arr[offset+ 7] & 0xFFL) << 0) +
  26.                   ((arr[offset+ 6] & 0xFFL) << 8) +
  27.                   ((arr[offset+ 5] & 0xFFL) << 16) +
  28.                   ((arr[offset+ 4] & 0xFFL) << 24) +
  29.                   ((arr[offset+ 3] & 0xFFL) << 32) +
  30.                   ((arr[offset+ 2] & 0xFFL) << 40) +
  31.                   ((arr[offset+ 1] & 0xFFL) << 48) +
  32.                   (((long)b[offset+ 0]) << 56);
  33.     }
  34.     // -----------------------------------------------
  35.     private double getDouble(sbyte[] arr, int offset) {
  36.  
  37.         long j = ((arr[offset+ 7] & 0xFFL) << 0) +
  38.                     ((arr[offset+ 6] & 0xFFL) << 8) +
  39.                     ((arr[offset+ 5] & 0xFFL) << 16) +
  40.                     ((arr[offset+ 4] & 0xFFL) << 24) +
  41.                     ((arr[offset+ 3] & 0xFFL) << 32) +
  42.                     ((arr[offset+ 2] & 0xFFL) << 40) +
  43.                     ((arr[offset+ 1] & 0xFFL) << 48) +
  44.                     (((long)b[offset+ 0]) << 56);
  45.  
  46.         return (double)(j);
  47.     }
  48.     // -----------------------------------------------
  49.  
  50.  
  51.  

El caso es que la fecha me la recupera bien (obtengo un long que traslado a una fecha) pero con los doubles no hay manera.
¿ alguna ayuda o sugerencia ?
gracias

4
C# / Encriptar un String
« en: Lunes 8 de Septiembre de 2008, 16:36 »
Hola a tod@s

Tengo que guardar algunos datos de una aplicación (preferencias y otros) en un archivo.
Se me ha ocurrido usar Xml para guardarlos, por su facilidad para volver a leerlos y tenerlos disponibles, al abrir de nuevo la aplicación.
Ahora el problema que se me plantea es encriptar dicho Xml para que no pueda ser leido y modificado por un simple editor de texto.
He repasado un poco el espacio "System.Security.Cryptography" pero la verdad no me entero de mucho. Me basta con una simple API con una clave para cifrar y descifrar un string (el texto del Xml), no me hace falta pares de claves pública/privada (que no sé usar) ni cosas tan complejas.

¿alguien sabe cómo hacerlo?
muchas gracias.

5
C# / Precisión
« en: Viernes 29 de Agosto de 2008, 10:37 »
Hola amigos, a ver si me podeis ayudar en una duda que me trae de cabeza.

En algún lugar de un programa uso listas de valores en coma flotante. Puesto que cada valor sólo usa como máximo cinco posiciones decimales, me dispongo a usar el tipo que menos recursos necesite, a elegir entre Decimal (16 bytes), Double (8 bytes) y Float (4 bytes). Evidentemente el Float es el más económico en recursos, sobre todo si usamos listas con miles de Floats dentro.

Sin embargo, cuando realizo operaciones en los valores, la precisión se va degradando de forma que siempre obtengo decimales en posiciones que no deberían estar. Para hacerme entender, 0.0075d + 0.0025d debería ser 0.01 sin embargo me sale un número con muchos más decimales que se aproxima mucho al resultado correcto.

El mismo error me ocurre con los Float, únicamente trabajando con Decimal me realiza las operaciones correctamente, pero entonces uso 16 bytes en vez de 4 (4 veces más de espacio en memoria !!).

A modo de ejemplo:

Código: Text
  1. static void Main(string[] args) {
  2.             List<float> listaF = new List<float>();
  3.             float f1 = 0.0075F;
  4.             float incrementoF = 0.0025F;
  5.            
  6.             for (int i = 0; i < 100; i++) {
  7.  
  8.                 // Esto se degrada con el paso de las iteraciones, y adquiere cada vez más decimales
  9.                 f1 = f1 + incrementoF;
  10.                 // Tengo que hacer esto para que pierda los decimales que no interesan
  11.                 //f1 = Single.Parse(f1.ToString("F4"));
  12.                 listaF.Add(f1);
  13.  
  14.                 Console.WriteLine("Posición {0}: {1}", i, f1);
  15.             }
  16.  
  17.             //Poner un punto de interrupción aquí, y mirar la lista en la ventana de "Variables locales" del debugger
  18.             Console.ReadLine();
  19. }
  20.  

Bueno, veréis que la única solución que se me ocurre es truncar los decimales sobrantes convirtiendo a string y volviendo a parsear esa cadena, una solución bastante chapucera que además es poco eficiente. ¿ Cómo debo hacer para que me sume correctamente, sin decimales fantasma ?

gracias.

6
C# / Importar Dll
« en: Martes 18 de Marzo de 2008, 19:48 »
Hola amigos

Aprovecho para presentarme al foro. Soy un programador casual (sólo programo aplicaciones para mi mismo) y autodidacta (no soy informático) pero llevo bastante tiempo programando. La experiencia es un grado, aunque debo admitir que a veces me cuesta demasiado.
En fin, espero pasarme por aquí a menudo, ahora que conozco el foro, y aportar lo que buenamente pueda.

Venga, ahí va la primera pregunta:
¿ dónde puedo aprender a importar dlls compiladas en un programa C# ? (y a usar sus APIs claro). Concretando, ¿ conocéis algún buen tutorial en algún sitio donde lo expliquen ?

muchas gracias

Páginas: [1]