[dec]

Hola de nuevo,

Porque se vea la sencillez (e incluso simpleza) de la clase que he dicho arriba que utilizo para comprobar si existe nuevas versiones del programa de que he hablado es esta misma, sin más:

Código Delphi [-]
 { *********************************************************************** }
 {                                                                         }
 { XEditor                                                                 }
 { Copyright (C) 2005 por David Esperalta Calderón                         }
 { Todos los derechos reservados.                                          }
 {                                                                         }
 { El contenido de este archivo está protegido por la                      }
 { licencia del programa XEditor que puedes encontrar                      }
 { en el archivo "licencia.txt" del subdirectorio txt                      }
 {                                                                         }
 { Correo del programa:     XEditor@Gmail.com                              }
 { Página Web del programa: http://www.XEditor.tk                          }
 { Correo del autor:        DavidEsperalta@Gmail.com                       }
 {                                                                         }
 { *********************************************************************** }
 
 unit UBuscaVersiones;
 
 interface
 
 // Delphi 7
 //
 uses
   Classes, SysUtils, DateUtils, Controls, IdHttp;
 
 // Algunos eventos utilizados.
 //
 type
   TOnNuevaVersion = procedure(Sender: TObject;
     versionWeb, fechaVersionWeb: string) of object;
   TOnNuevaFechaVersion = procedure(Sender: TObject;
     versionWeb, fechaVersionWeb: string) of object;
 
 // Mantiene al usuario al tanto de las nuevas
 // versiones del programa que se publiquen.
 //
 type
   TBuscaVersiones = class(TObject)
   private
     FDatos: TStrings;
     FUrlDatos: string;
     FFechaActual: string;
     FVersionActual: string;
     FOnError: TNotifyEvent;
     FOnSinNuevaVersion: TNotifyEvent;
     FOnNuevaVersion: TOnNuevaVersion;
     FOnNuevaFechaVersion: TOnNuevaFechaVersion;
     procedure ProcesarDatos;
     function ObtenerDatos : boolean;
   public
     constructor Create;
     destructor Destroy; override;
     procedure Comprobar(versionActual, fechaActual: string);
   public
     property UrlDatos: string read FUrlDatos write FUrlDatos;
     property OnError: TNotifyEvent read FOnError write FOnError;
     property OnSinNuevaVersion: TNotifyEvent
       read FOnSinNuevaVersion write FOnSinNuevaVersion;
     property OnNuevaVersion: TOnNuevaVersion
       read FOnNuevaVersion write FOnNuevaVersion;
     property OnNuevaFechaVersion: TOnNuevaFechaVersion
       read FOnNuevaFechaVersion write FOnNuevaFechaVersion;
   end;
 
 implementation
 
 { TBuscaVersiones }
 
 // Constructor.
 //
 constructor TBuscaVersiones.Create;
 begin
   inherited Create;
   FDatos := TStringList.Create;
 end;
 
 // Destructor.
 //
 destructor TBuscaVersiones.Destroy;
 begin
   FDatos.Free;
   inherited Destroy;
 end;
 
 // Comprueba si hay una nueva versión.
 //
 procedure TBuscaVersiones.Comprobar(versionActual,
   fechaActual: string);
 begin
   FFechaActual := fechaActual;
   FVersionActual := versionActual;
   if ObtenerDatos then ProcesarDatos;
 end;
 
 // Obtiene los datos precisos para averiguar
 // si existe una nueva versión del programa.
 //
 function TBuscaVersiones.ObtenerDatos : boolean;
 var
   http: TIdHTTP;
   temp: TStringStream;
 begin
   Result := false;
   http := TIdHTTP.Create(nil);
   temp := TStringStream.Create(EmptyStr);
   try
     try
       http.Get(FUrlDatos, temp);
       if temp.Size > 0 then
       begin
         FDatos.Clear;
         FDatos.Text := temp.DataString;
         Result := true;
       end;
     except
       if Assigned(FOnError)
        then FOnError(Self);
       Abort;
     end;
   finally
     http.Free;
     temp.Free;
   end;
 end;
 
 // Procesa los datos que determinarán si
 // existe o no una nueva versión del programa.
 //
 procedure TBuscaVersiones.ProcesarDatos;
 var
   dVersionActual, dVersionWeb: double;
   fechaVersionActual, fechaVersionWeb: TDate;
 begin
   {
     Los datos que encontraremos en la variable
     FDatos guardan una muy sencilla estructura.
 
     En realidad partimos de las tres líneas que
     guardamos en un Servidor en Internet en el
     archivo que tenemos para estos menesteres.
 
     Estas son las tres líneas:
 
     0: XEditor (última versión)
     1: 1.3
     2: 15/09/2005
 
     Como se ve la primera línea no nos sirve de
     mucho, y así nos fijamos en las líneas uno
     y dos, que contiene, respectivamente, la
     versión del programa y la fecha de la misma.
   }
   if FDatos.Text = EmptyStr then begin
     if Assigned(FOnError) then FOnError(Self);
     Exit;
   end;
   DecimalSeparator := '.';
   dVersionWeb := StrToFloat(FDatos.Strings[1]);
   dVersionActual := StrToFloat(FVersionActual);
   if dVersionActual < dVersionWeb then
   begin
     if Assigned(FOnNuevaVersion) then
       FOnNuevaVersion(Self, FDatos.Strings[1],
         FDatos.Strings[2]);
     Exit;
   end;
   if dVersionActual = dVersionWeb then
   begin
     fechaVersionActual := StrToDate(FFechaActual);
     fechaVersionWeb := StrToDate(FDatos.Strings[2]);
     if (CompareDate(fechaVersionWeb,
       fechaVersionActual) = 1) then
       begin
         if Assigned(FOnNuevaFechaVersion) then
           FOnNuevaFechaVersion(Self, FDatos.Strings[1],
             FDatos.Strings[2]);
         Exit;
      end;
   end;
   if Assigned(FOnSinNuevaVersion) then
     FOnSinNuevaVersion(Self);
 end;
 
 end.

Podrá mejorarse todo lo que se quiera, no es mi intención entrar en eso ahora. El caso es que para hacer uso de la clase anteriormente presentada bastaría con algo así:

Código Delphi [-]
 
 var
   FBuscaVersiones: TBuscaVersiones;
 
 // Prepara el objeto que se encarga de obtener
 // información sobre la última versión del pro-
 // grama disponible en Internet.
 //
 procedure TfrmPrincipal.PrepararBuscaVersiones;
 begin
   FBuscaVersiones := TBuscaVersiones.Create;
   with FBuscaVersiones do begin
     UrlDatos := rsUrlActualizar;
     OnNuevaVersion := NuevaVersion;
     OnError := ErrorComprobandoVersion;
     OnNuevaFechaVersion := NuevaVersion;
     OnSinNuevaVersion := SinNuevaVersion;
   end;
 end;

Donde "FBuscaVersiones" será una variable que guarde la referencia al objeto de la clase "TBuscaVersiones" que utilizaremos. A continuación proporcionamos una serie de datos, básicamente nos interesa la propiedad "UrlDatos", que ha de ser la URL en que se encuentre el archivo que contenga la información "a comparar", es decir, el archivo texto plano que referí más arriba.

A continuación hacemos uso de los eventos del objeto para informar al usuario o tomar las medidas necesarias en caso de encontrarse nuevas versiones, no encontrarse, etc.

En todo caso, la llamada "principal" al objeto "TBuscaVersiones" se realizaría de este modo, una vez hecho lo anterior, es decir, una vez creado el objeto e inicializado:

Código Delphi [-]
 FBuscaVersiones.Comprobar(rsVersion, rsFechaVersion);

Con esa instrucción estamos llamando al método "Comprobar" del objeto "TBuscaVersiones". A dicho método le pasamos dos parámetros, como puede verse, la versión actual (local) del programa y la fecha de esta versión. Echo eso el objeto se encargará internamente de descargar el archivo de Internet que contendrá los datos con los que podremos comparar y también el objeto se encargará de disparar los eventos oportunos, si estos están asignados.

Otra vez pido disculpas por tanto rollo. No sé, iré al médico mañana a ver si es que tengo la gripe del pollo o algo parecido...