Componente Hashes, para quien pueda interesar
 

Hola,

He subido al Directorio del ClubDelphi un componente que he dado en llamar "Hashes" (en un alarde de ingenio e imaginación) y que puede usarse para calcular el algoritmo MD5 y SHA1 de una cadena, archivo o "Stream".

El componente se basa en la unidad "Hashes.pas" de Domingo Seoane y yo me he limitado a encapsular las funciones de la misma dentro de un componente, que a su vez añade una serie de eventos y algún que otro método.

Pensaba usar la unidad "Hashes.pas" del maestro Seoane, pero, para archivos "grandes", en mi caso, al menos, precisaba de un evento que me fuera informando del progreso de la tarea.

Ya puestos añadí algún otro evento y un método para poder "abortar" una tarea comenzada. Y eso es todo. Yo pienso usarlo en cierto proyecto, de modo que, si veo que son menester ciertos cambios, actualizaré el archivo del componente en consecuencia.

Otra cosa. "Hashes" puede usarse como una clase más, es decir, puede instalarse (incluye un paquete para Delphi 2007) o puede usarse como cualquier otra clase, no es necesario instalarlo, vaya.

Además incluyo un ejemplo de uso del componente, aunque, en el ejemplo he utilizado el componente instalado en Delphi, de modo que si queréis probarlo (con el ejemplo) tendréis que hacer lo propio. Pero en todo caso veréis que es relativamente sencillo hacer uso del mismo.

PD. Para archivos y "Streams" "pequeños" y cadenas... lo cierto es que tal vez ya no merezca la pena el uso del componente, y baste y sobre con usar la unidad "Hashes.pas" de Domingo Seoane.

Muy bueno dec, lo dejaste perfecto.

Por cierto, para archivos grandes puede que sea mejor utilizar un buffer mayor. Por ejemplo:

Código Delphi [-]
GetMem(Buffer,1*1024*1024);

O incluso puedes dejar el tamaño del buffer como una propiedad mas del componente.

Hola,

Hum... pues no se me habría ocurrido Domingo. :)

¿Qué tamaño de "Buffer" crees tú válido "por defecto"? ;)

Y otra más... ¿crees que sería bueno limitar el máximo del "buffer"? ¿Y el mínimo?

Hola,

Vale... a la primera pregunta casi me respondo yo... un "buffer" de 1024 (que luego se multiplicará por diez) puede ser lo suyo "por defecto", puesto que así es como se establece en la unidad "Hashes.pas" de donde parte todo. :)

Ahora bien, ¿algún tipo de control para el mínimo y máximo del "buffer"? Lo digo para actualizar ya el componente o no. :D

Hombre, yo te recomendaría un tamaño de 1 mega (1024*1024) , o puede que medio mega (512*1024). En cuanto a limitar el máximo y el mínimo, es evidente que tiene que ser mayo de cero :p , y máximo lo que aguante, si alguien le coloca un tamaño demasiado grande simplemente provocara una excepción indicando que no hay memoria suficiente.

Hola,

O sea, que esto no va bien, entonces:

Código Delphi [-]
GetMem(Buffer,10*FBuffer);

Siendo "FBuffer" 1024 (el valor por defecto).

Y no sé si ya esto sea una pasada... un par de instrucciones por debajo tenemos:

Código Delphi [-]
BytesRead:= Stream.Read(Buffer^, 10*FBuffer);

¿Me he pasado de listo Seoane? :)

Por ahora el "buffer" por defecto sería de 1024. No habría máximo y tampoco mínimo... se supone a quien lo toca que sabe lo que hace.

Edito: Sí que habría mínimo: el buffer ha de ser mayor que cero.

Perfecto, veo que te diste cuenta de que otra instrucción había que cambiar.

Yo lo dejaría así:

Código Delphi [-]
GetMem(Buffer,FBuffer);
...
BytesRead:= Stream.Read(Buffer^, FBuffer);

Y limitaría el valor de FBuffer entre 1024 y 8*1024*1024, es decir entre 1KB y 8MB. Un rango bastante razonable.

Hola,

Sí; pero yo siento darte la brasa (nunca mejor dicho, acaso, por la calor que hace... al menos por aquí), pero, no me termino de aclarar, y es que, como se echa de ver, no estoy muy puesto en esto (como en casi nada).

¡A ver si me aclaro! Antes de toda esta movida había una instrucción tal que:

Código Delphi [-]
GetMem(Buffer,10*1024);

Entonces, mi sin duda superior intelecto había barruntado esto:

Código Delphi [-]
GetMem(Buffer,10*FBuffer);

La propiedad "Buffer" valdría por defecto 1024, y todo quedaría entonces "como antes". :)

Ahora bien, si decimos que la propiedad Buffer vale 1024 (por defecto), entonces la anterior instrucción no es lo mismo que esta:

Código Delphi [-]
GetMem(Buffer,FBuffer);

Entonces la propiedad "Buffer" tendría que valer, por defecto, 10024...

¿No? Pues me lo explica, por favor. :D :D :D

El tamaño del buffer es lo que esta dentro del GetMem. Tu te preguntaras por que utilizo 10*1024 y no 10240, pues siemplemente es una constumbre para distinguir a simple vista si son Kb, Mb, etc ...

En mi codigo utilizaba 10*1024 porque me parecio un tamaño razonable para una cadena de texto y archivos pequeños. Pero si se va a calcular algo realmente pequeño, puede utilizarse un buffer mas pequeño, y si vamos a calcular un archivo "grande" mejor un buffer mayor.

Lo que puedes hacer es esto otro:

Código Delphi [-]
GetMem(Buffer,FBuffer*1024);

De esta forma la propiedad FBuffer estaría en Kilobytes y seria mas fácil de manejar.

Y se me olvidaba, según tienes el código, el tamaño del buffer determina cuando ocurre el evento OnWork. Cuanto mayor sea el buffer, los eventos OnWork serán menos y mas espaciados en el tiempo.

Hola,

Vale. Pues me convence esto que dices. He renombrado la propiedad "Buffer" a "KBBuffer"... esperando que así el asunto se entienda mejor. Entonces, entiendo ahora que un buen valor por defecto para esta propiedad podría ser 512... ¿O tal vez 1024?

¿Qué me dices? :)

Hola,

Vaya... noto que si doy un valor a "KBBuffer" de 10 la aplicación se mueve mejor... no se atranca tanto, como si doy un valor de 1024 a dicha propiedad... de todos modos me he decidido por este último valor por defecto. Ya está también actualizado el invento. Gracias por todo Seoane. :)