Voy
a exponer la lógica y los recursos de código empleados por mí en un programa C#
para contabilizar y totalizar los megabyte que se copian en un PC hacia
dispositivos extraíbles USB.
Los requerimientos del programa:
- Debe detectar todas las unidades de almacenamiento USB que se conectan al pc y contabilizar los megabytes copiados.
- Debe reportar los megabyte copiados en un archivo de valores separados por coma (csv); un archivo por cada día con al menos la siguiente información: Nombre del volumen, Hora de conexión y Megabytes copiados.
- Debe ejecutarse como un proceso sin interface visible.
- Debe garantizar iniciarse cuando se inicie Windows.
El objetivo de este artículo es
publicar mi idea para retroalimentarme con otras ideas.
El núcleo
de esta aplicación está sustentado sobre la clase DriverDetector.cs de
codeproject.com (http://www.codeproject.com/Articles/18062/Detecting-USB-Drive-Removal-in-a-C-Program).
Esta clase detecta el mensaje WM_DEVICECHANGE que Windows envía a todas las
aplicaciones, este mensajes es enviado por Windows cuando ocurre un cambio en
el hardware de la pc; adicionalmente se envía con el mensaje el parámetro
WParam que contiene el código especifico del cambio ocurrido. Los valores que
interesan de WParam son:
DBT_DEVICEARRIVAL: es
enviado cuando se conecta un dispositivo USB.
DBT_DEVICEQUERYREMOVE:
se envía cuando se solicita la extracción del dispositivo.
DBT_DEVICEREMOVECOMPLETE: se envía cuando el dispositivo es removido
completamente.
Consecuentemente con
esto la clase DriverDetector.cs nos da la posibilidad de escribir código en los
procedimientos de eventos:
OnDriveArrived: Código
que se ejecutara cuando se conecte un dispositivo USB.
OnQueryRemove: Código
a ejecutar antes de remover el dispositivo USB.
OnDriveRemove: Código para cuando se extraiga completamente el
dispositivo.
Con estos
elementos el trabajo consiste en codificar la siguiente lógica:
- En el evento OnDriveArrived tomar el espacio libre del dispositivo y guardarlo en una variable A (mas adelante veremos que debe ser un arreglo de memoria bidimensional).
- En el evento OnDriveRemove calcular A-A1 (el resultado es el tamaño de la informacion copiada al dispositivo), escribir el resultado en el archivo csv. (El calculo en este punto no es totalmente cierto; si se borra informacion el resultado del calculo no es exactamente la informacion copiada).
- En el evento OnQueryRemove volver a leer el espacio libre del dispositivo y guardarlo en otra variable A1 (debe ser en una columna del arreglo bidimensional).
La clase DriverDetector.cs es perfecta, me quito
el sombrero ante el autor, pero tiene una limitacion que por mas que intente no
pude solventar.
El asunto es el siguiente; para que window envie
el submensaje (para llamarle de alguna manera) DBT_DEVICEQUERYREMOVE hay que “decirle explícitamente que lo haga” (esto
incluye crear un archivo con ciertas características en la unidad entre otras
cosas) de lo contrario no se envía. La clase DriverDetector.cs lo hace, pero
solo para un dispositivo a la vez, de manera que no podemos controlar el evento
OnQueryRemove para varios dispositivos conectados.
De modo que el punto
2 de la lógica no tenemos como resolverlo. La pregunta es:
¿Qué recurso de software tenemos
para resolver esto?
Existe
una clase en .NET (namespace System.IO) para monitorear cambios en un directorio
y/o subdirectorios y provocar eventos para actuar ante estos cambios; la clase
es FileSystemWatcher. Con esta clase
se pueden inspeccionar cambios en un directorio tales como creación o
eliminación de archivos.
Esta
pudiera ser la solución, instanciando la clase para cada dispositivo USB detectados
podemos tener el tamaño de los archivos creados (copiados) en la unidad USB.
Pero esto tiene otro problema y es que cuando intentemos extraer el dispositivo
Windows “nos dira” que el mismo está en uso. Lo lógico es que en el evento que
ocurre antes del OnDriveRemove detengamos el monitoreo de la unidad USB por
parte de la clase FileSystemWatcher, y
ese evento es OnQueryRemove. De modo que estamos en las mismas.
SOLUCION
Mi
solución fue desechar la escucha del mensaje DBT_DEVICEQUERYREMOVE y su correspondiente evento OnQueryRemove. En su
lugar, cada 1 segundo voy a leer el espacio libre en el dispositivo y lo voy a
restar a la lectura anterior, si la diferencia es positiva (mayor que cero)
significa que el espacio libre va disminuyendo, por tanto hay en marcha un
proceso de copia, entonces voy acumulando la diferencia en una variable
(columna de un arreglo de memoria). Finalmente al extraer el dispositivo, el
valor de esa variable va a ser el tamaño copiado al dispositivo USB.
Ilustrare esta
solución con los “trozos” de código fundamentales.
Namespaces referenciados (independientes de los referenciados por la
clase DriverDetector)
using
System;
using
System.Collections.Generic;
using
Microsoft.Win32;
using
System.Windows.Forms;
using
System.Text;
using
System.IO;
using System.Text;
Variables con alcance en todo el
formulario
// Variables para almacenar el tamaño del disp.,
Bay libres y ocupados al conectar
long size0,Bay0,Ocup0;
// Variable de tipo DriveInfo (clase .NET q
proporciona acceso a información sobre //una unidad
DriveInfo flash;
String NombreVolumen;
char LetraUnidad;
byte fila_matriz;
//Matrix string 26 filas x 6 columnas, 26 posibles
unidades a conectar, 6 columnas
//0-Letra unidad,1-EtiquetaVolumen+Hora de
conexión,2-Tamaño, 3-Byte libres al
//conectar,4-Byte Ocupados al conectar,5-Columna de
apoyo al calculo,6-Byte copiados
public
static string[,]
usb_conectada = new string[26,
7];
string Hora_conexion;
Procedimiento Main de program.cs
El parámetro “install” si es pasado a la aplicación se crea una
llave en el registro para garantizar la carga en cada inicio del sistema, lo
contrario con el parámetro “uninstall”
Evento Load del formulario
Genarq es una clase del programa
con métodos de apoyo a la solución del problema.
La definición de la
clase comienza así:
Como se ve, incluye
la declaración de una variable tIntervalo de tipo Timer (clase .NET para ejecutar
métodos a intervalos regulares de tiempo, 1 segundo para nuestro caso).
El método HeadFileCSVRW() y
public
static string
HeadFileCSVRW()
{
string
namefile = Application.StartupPath + Path.DirectorySeparatorChar.ToString() + "cusb_" + DateTime.Now.Day.ToString()
+ "_" + DateTime.Now.Month.ToString()
+ "_" + DateTime.Now.Year.ToString()
+ ".csv";
if
(!File.Exists(namefile))
{
using
(FileStream fs = new
FileStream(namefile, FileMode.CreateNew, FileAccess.Write, FileShare.ReadWrite))
{
using
(TextWriter fila_csv = new StreamWriter(fs))
{
// LetraUnidad,Nombre+HoraConexion,Tamaño,MBL0,MBOcup,BLtmp,BCopiados
fila_csv.WriteLine("Escrito por: Arquimides R. Ribeaux del Rio"); fila_csv.WriteLine("Letra_Unidad,Etiqueta_Hora,GZ0,MBL_i,MB_o,MBL_Tmp,MBC");
fila_csv.Close();
}
}
}
return
namefile;
}
public static void AddLineFileCSV(string namefile,string linea)
{
using (FileStream fs = new FileStream(namefile, FileMode.Append, FileAccess.Write, FileShare.ReadWrite))
{
using (TextWriter fila_csv = new StreamWriter(fs))
{
// LetraUnidad,Nombre+HoraConexion,Tamaño,MBL0,MBOcup,BLBorrado,BLCopiado
fila_csv.WriteLine(linea);
fila_csv.Close();
}
}
}
El primer método chequea la existencia
del archivo csv, sino existe lo crea con un nombre que incluye la fecha del día
y escribe las 2 primeras líneas del fichero y el segundo agrega cada linea al csv despues de extraido el dispositivo
El procedimiento tProcess1Seg, código del evento
Tick del Timer
public
static void
tProcess1Seg(Object myobj, EventArgs myEA)
{
string
lunidad;
tIntervalo.Stop();
for
(byte i = 0; i <= 25; i++)
{
if (frmMain.usb_conectada[i,
0] != null) //La
letra de unidad NO es Null
{
try
{
// 0 ,1, 2, 3, 4, 5 , 6
// LetraUnidad,Nombre+HoraConexion,Tamaño,BL0,Ocupados,BLtmp,BCopiados
lunidad = frmMain.usb_conectada[i,0];
DriveInfo unidad = new DriveInfo(lunidad);
//BL al iniciar
long lec_anterior = (long)Convert.ToInt64(frmMain.usb_conectada[i,5]);
//Lectura de espacio libre ahora
long lec_now = unidad.AvailableFreeSpace;
// El espacio libre va disminuyendo por tanto estan copiando
if ((lec_anterior - lec_now) > 0 )
{
long lec_tmp = (long)Convert.ToInt64(frmMain.usb_conectada[i,6])+(lec_anterior - lec_now);
frmMain.usb_conectada[i,6] = lec_tmp.ToString();
}
frmMain.usb_conectada[i,5]=lec_now.ToString(); }
catch
{
tIntervalo.Start();
Application.DoEvents();
return;
}
}
}
tIntervalo.Enabled = true;
}
Procedimiento para el evento OnDriveArrived
private
void OnDriveArrived(object
sender, DriveDetectorEventArgs e)
{
// LetraUnidad,Nombre+HoraConexion,Tamaño,BL0,Ocup0,BLBorrado,BLCopiado
// e.Drive is the drive letter for the device which just arrived, e.g.
"E:\\" try
{
flash = new DriveInfo(e.Drive);
NombreVolumen = flash.VolumeLabel.ToString(); // obtener el nombre del volumen
if (NombreVolumen.Length == 0)
{ NombreVolumen = "Sin_Nombre";
}
// Obtener la primera letra de la cadena, la letra de unidad
LetraUnidad = e.Drive[0];
size0 = flash.TotalSize;
Bay0 = flash.AvailableFreeSpace; // Espacio
libre inicial
Ocup0 = size0 - Bay0; // Espacio Ocupado
inicial
// El ascii de letra unidad-65 para obtener la fila de la matriz
fila_matriz = Encoding.ASCII.GetBytes(LetraUnidad.ToString())[0];
Hora_conexion=DateTime.Now.Hour.ToString()+":"+DateTime.Now.Minute.ToString()+":"+ DateTime.Now.Second.ToString();
usb_conectada[fila_matriz - 65, 0] = e.Drive;
usb_conectada[fila_matriz - 65, 1] = NombreVolumen + "_" + Hora_conexion;
usb_conectada[fila_matriz - 65, 2] = size0.ToString();
usb_conectada[fila_matriz - 65, 3] = Bay0.ToString();
usb_conectada[fila_matriz - 65, 4] = Ocup0.ToString();
usb_conectada[fila_matriz - 65, 5] = Bay0.ToString();
usb_conectada[fila_matriz - 65, 6] = "0";
}
catch
{
Genarq.tIntervalo.Start();
Application.DoEvents();
Genarq.tIntervalo.Enabled
= true;
return;
}
Procedimiento para el evento OnDriveRemoved
private void OnDriveRemoved(object sender, DriveDetectorEventArgs e)
{
// Manipular unidad
LetraUnidad = e.Drive[0];
fila_matriz = Encoding.ASCII.GetBytes(LetraUnidad.ToString())[0];
// 0 , 1 , 2 , 3 , 4 , 5 , 6
// LetraUnidad,Nombre+HoraConexion,Tamaño,BL0,Ocup,BLBorrado,BLCopiado
long ar2, ar3, ar4, ar5, ar6;
ar2 = (long)Convert.ToInt64(usb_conectada[fila_matriz - 65, 2]); // Tamaño
ar3 = (long)Convert.ToInt64(usb_conectada[fila_matriz - 65, 3]); //BL al conectar
ar4 = (long)Convert.ToInt64(usb_conectada[fila_matriz - 65, 4]);
ar5 = (long)Convert.ToInt64(usb_conectada[fila_matriz - 65, 5]); //BL Tmp
ar6 = (long)Convert.ToInt64(usb_conectada[fila_matriz - 65, 6]); //B copiados
string letra = usb_conectada[fila_matriz - 65, 0];
string nombre = usb_conectada[fila_matriz - 65, 1];
// Limpiar la fila de la matriz
usb_conectada[fila_matriz - 65, 0] = null;
usb_conectada[fila_matriz - 65, 1] = "Sin_Nombre";
usb_conectada[fila_matriz - 65, 2] = string.Empty;
usb_conectada[fila_matriz - 65, 3] = string.Empty;
usb_conectada[fila_matriz - 65, 4] = string.Empty;
usb_conectada[fila_matriz - 65, 5] = string.Empty;
usb_conectada[fila_matriz - 65, 6] = string.Empty;
double Mb2, Mb3, Mb4, Mb5, Mb6;
Mb2 = ((Convert.ToDouble(ar2) / 1024) / 1024) / 1024; //tamaño
Mb3 = ((Convert.ToDouble(ar3) / 1024) / 1024); //MBL al conectar
Mb4 = ((Convert.ToDouble(ar4) / 1024) / 1024); //MB Ocupados al conectar
Mb5 = ((Convert.ToDouble(ar5) / 1024) / 1024); //BL Temporales
Mb6 = ((Convert.ToDouble(ar6) / 1024) / 1024); //MB copiados
string tam = Math.Round(Mb2, 2).ToString() + " GB";
string mbl0 = Math.Round(Mb3, 2).ToString();
string mbl1 = Math.Round(Mb4, 2).ToString();
string mbl2 = Math.Round(Mb5, 2).ToString();
string mbl3 = Math.Round(Mb6, 2).ToString();
string linea = letra + "," + nombre + "," + tam + "," + mbl0 + "," + mbl1 + "," + mbl2 + "," + mbl3;
// Si pc queda encendida hasta dia sig. el proceso esta cargado de modo q no se //ejecutar el Form_load
// Debemos asegurarnos q escriba en el dia correcto
string nombre_ruta_csv = Genarq.HeadFileCSVRW();
Genarq.AddLineFileCSV(nombre_ruta_csv, linea);
}
En el siguiente enlace de Google Drive se puede descargar un fichero compactado (cusb.rar) que contiene el ejecutable cusb.exe.
https://drive.google.com/file/d/0B1y9zYoMQe86S1djekRtV3RCZ28/view?usp=sharing
Hasta aquí mi solución. Al momento de terminar de redactar este artículo, me informan unos amigos (padre e hijo programadores) con los cuales compartí la idea inicial, que lograron controlar el DBT_DEVICEQUERYREMOVE e implementaron la solución utilizando directamente la función API de Windows que esta encapsulada en la clase .NET FileSystemWatcher; desarrollaran en Delphi/Pascal; para ellos el mejor lenguaje de programación que existe.
Hasta aquí mi solución. Al momento de terminar de redactar este artículo, me informan unos amigos (padre e hijo programadores) con los cuales compartí la idea inicial, que lograron controlar el DBT_DEVICEQUERYREMOVE e implementaron la solución utilizando directamente la función API de Windows que esta encapsulada en la clase .NET FileSystemWatcher; desarrollaran en Delphi/Pascal; para ellos el mejor lenguaje de programación que existe.
