TStrings como variable global

[Jose Roman]

Hola a todos,

Resulta que he declarado mi variable TStrings globalmente asi:

implementation

uses uDataModule, uMain;

{ TAlumno }

var
AlumnoSql : TStrings;


Cuando creo el TObject con el que estoy trabajando hago esto:

constructor TAlumno.Create;
begin
inherited Create;
AlumnoSql := TStringList.Create;
AlumnoSql := wDataModule.tbAlumnos.SelectSQL;
ShowMessage(AlumnoSql.Text);
end;


El cuadro de dialogo me muestra pecfectamente los valores de AlumnoSql, hasta ahi va bien, pero cuando voy a otro procedimiento:

procedure TAlumno.BuscarAlumno(Sender: TObject);
begin
wDataModule.tbAlumnos.Close;
wDataModule.tbAlumnos.SelectSQL.Clear;
ShowMessage('AlumnoSql.Text);
end;

La variable AlumnoSql esta vacia. Que estoy haciendo mal?

[mamcx]

En primer lugar, estas usando una variable global. Debes limitar al maximo eso. A duras penas, para objetos tipo "Singleton", y eso que ojala ni eso.

Segundo, estas dependiendo de manejo de estado mutable, osea, AlumnoSql puede cambiar en cualquier momento por medio de quien sabe quien, asi que se requiere disciplina para saber exactamente donde y como y en que orden se opera sobre un tipo mutable en un programa. Asi que lo que te tocaria hacer es buscar en todo el codigo fuente donde y quien esta modificando esos datos, y controlar manualmente el orden de acceso.

La forma mas correcta es:

- No usar variables globales
- Usar funciones "puras", que ante la misma entrada de datos de forma deterministica siempre sale el mismo dato, y no hay forma de interceptar a medio camino y alterar sus datos (que es lo que pasa con AlumnoSql). Ademas, que estas no dependan del estado de otras funciones y/o objetos.
- Centralizar todo lo que maneje estado (osea: Acceso a base de datos, archivos, etc).
- Si manipulas una estructura mutable (que en Delphi es casi todo :( ) encapsular en una clase para que sepas exactamente como y quien y cuando se hacen las cosas.

O dicho muy sencillo:

El manejo de estado debería ser LOCAL a la clase/objeto (no hay como accederlo por fuera, no hay forma de hacer MiObjeto.MiDato ni parecido). Cuando un objeto se comunica con otro, en vez de pasar punteros/referencias/datos mutables se debería pasar una COPIA de los datos. Osea, se debe poder asegurar que si Pepito le pasa a Juanito una billetera con 10000 dólares, Juanito VERDADERAMENTE tiene los 10000 dólares, no que Pepito puede cambiar 10000 por 0 y luego Juanito se pregunte: Porque desapareció mi plata magicamente?

Que en tu caso en concreto: AlumnoSql no debe ser ni una propiedad, ni variable ni externa ni interna, siempre que se requiere asignar un sql al dataset una funcion lo regenera siempre:


procedure TAlumno.BuscarAlumno(Params....);
begin
//PREFERIBLEMENTE NO usara un datamodule global..
self.tbAlumnos.Close;
self.tbAlumnos.SelectSQL.Clear;
self.tbAlumnos.Sql := AQUI SE HACE EL SQL

end;

Y mucho mejor:

function TAlumno.BuscarAlumno(Params....):TDataSet;
begin
//Crear el DataSet y retornarlo desde 0
end;

Lo que lo convertiria en una funcion testeable.

[Jose Roman]

Gracias mamcx, a corregir lo que estoy haciendo, de nuevo gracias por mostrarme el camino.

[roman]

Vamos a examinar paso a paso lo que sucede.


constructor TAlumno.Create;
begin
inherited Create;
AlumnoSql := TStringList.Create;
AlumnoSql := wDataModule.tbAlumnos.SelectSQL;
ShowMessage(AlumnoSql.Text);
end;



En la línea en negritas creas una instancia de TStringList y la asignas a la variable global AlumnoSql.

En la siguiente línea "asesinas" la asignación anterior y le asignas a AlumnoSql otro objeto de tipo TStringList. O sea, el objeto creado en la línea anterior se pierde irremediablemente.

En esta segunda asignación, lo que asignas a la variable AlumnoSql es una referencia al objeto wDataModule.tbAlumnos.SelectSQL, no una copia de él.

Esto quiere decir que cualquier cosa que le pase a wDataModule.tbAlumnos.SelectSQL también le pasará a AlumnoSql.

En particular, cuando en el otro procedimiento haces


wDataModule.tbAlumnos.SelectSQL.Clear;


también borras lo que tenga AlumnoSql, pues en realidad se trata del mismo objeto.


Quizá lo que pensabas era algo más de este estilo:


constructor TAlumno.Create;
begin
inherited Create;
AlumnoSql := TStringList.Create;
AlumnoSql.Assign(wDataModule.tbAlumnos.SelectSQL);
ShowMessage(AlumnoSql.Text);
end;


En este caso, sí tendrías una copia del objeto.

De todas formas, como dice mamcx, es mala idea tener una variable global así. Aunque no estoy muy seguro de concordar con él en eso de construir la sentencia SQL cada vez.

// Saludos