Evitar variables globales....

[Neftali [Germán.Estévez]]

Empezado por Paoti

Estará bien esta forma de realizarlo, digo, no lo he puesto en practica en un ambiente de producción.

Yo no acabo de verle la lógica. Usas una clase Global para acceder a una variable, que en lugar de estar dentro de la clase está fuera.

(1) No le veo ventajas (seguramente es que yo no las veo), pero las hay, entre lo que has puesto tú y esto:

Código Delphi [-]
TGlobales = class private
    FUsuario : string;   <<<<====

     // procediminto y función para leer la varables    
    // se antepone Class, para indicar que son métodos de clase y on de objeto     
    class function GetUsuario : string;     
    class procedure SetUsuario(const Value: string); 
  protected 
  public   
   // Es una propiedad de clase y no de objeto, debido a que usa metodos de clase   
   property Usuario : string read GetUsuario write SetUsuario; 
  published 
end;

(2) Lo segundo que no veo es qué ventajas tiene en este caso usar la clase, respecto a esto:

Código Delphi [-]
unit uGlobales; 
interface 
 var Usuario : string;
implementation 
end.

Y cuando la uses poner

Código Delphi [-]
Caption := uGlobales.Usuario;
...
uGlobales.Usuario := 'pepe';

[roman]

A ver si aclaramos un poco:

Una forma de manejar variables de ámbito global sin ser propiamente globales, es encapsularlas en una clase como propiedades estáticas, esto es, como propiedades que no dependen de ningua instancia particular y que, por tanto, pueden usarse sin tener que crear un objeto de la clase.

El punto es que hasta delphi 2010, creo, no había propiedades estáticas -como sí las hay en otros lenguajes. Entonces, para simularlas, se hacía lo que propone Paoti. La variable a la que se accede desde la clase está restringida al ámbito privado de la unidad en la que se declara y, por tanto y es lo importante, no es accesible directamente desde fuera, lo cual, proporciona un cierto grado de control sobre dicha variable. Cosa que no ocurre si simplemente se usa una variable declarada en la sección interface. La variable queda "expuesta" a todo mundo.

Si tal variable se pone "dentro" de la clase, entonces no sería posible usarla sin instanciar un objeto de la clase. Dicho de otra forma, ya no sería una propiedad estática de la clase.

// Saludos

[[Chris]]

Interesante pauti.

Pero no entiendo el por qué de este código:

Código Delphi [-]
// desde un formulario 2
procedure TForm2.btn1Click(Sender: TObject);
var
  myGlobal : TGlobales;
begin
  Caption := myGlobal.Usuario;
end;

......

// desde un formulario 1
procedure TForm1.btn1Click(Sender: TObject);
var
  myGlobal : TGlobales;
begin
myGlobal.Usuario := 'Paoti';
end;

Cuando simplemente se podría hacer así, según una clase de muestra que he escrito:

Código Delphi [-]
    TGlobalVars = class
        private
            class var FVar1: String;
        public
            class property Var1: String read FVar1 write FVar1;
            // o simplemente:
            class var Var2: String;
    end;

// -------------------------------------------------------//
implementation

procedure TForm2.Button1Click(Sender: TObject);
begin
    TGlobalVars.Var1 := Edit1.Text;
end;

procedure TForm2.Button2Click(Sender: TObject);
begin
    ShowMessage(TGlobalVars.Var1);
end;

[Paoti]

El (1) no funciona, como variable privada, debe ser de la forma como está la clase expuesta por mi anteriormente.

el (2) es otra forma, usando propiedades estáticas simuladas.

Ahora, el ejemplo anterior, del post, es cómo usar otro tipo de Variables Globales, sí no quieres usar la forma tradicional.

[Neftali [Germán.Estévez]]

Empezado por Paoti

El (1) no funciona, como variable privada, debe ser de la forma como está la clase expuesta por mi anteriormente.

Correcto.
En ese caso hay que definir una variable global del tipo TGlobales, como comenté antes.

De todas formas, sigo viéndolo "raro".

[roman]

Es que no hay que definir ninguna variable del tipo TGlobales. Simplemente se hace:

Código Delphi [-]
TGlobales.Usuario := 'roman';

Edito:

¡Ah! Veo que Chris ya lo mencionó

// Saludos

[roman]

Sólo añadir que, con esta técnica, dado que el acceso es vía métodos de una clase, se puede tener un mejor control, validación, etc. Incluso pueden implementarse variables "globales" de sólo lectura, por ejemplo.

// Saludos

[Paoti]

¡Hola compañeros!

Me gusta tu idea roman, para evitar usar ahora sí, variables globales


Por ejemplo, una idea sería la siguiente:

Código Delphi [-]

TGlobales.CadenaConexion := 'lcoalhost:baseDatos';
TGlobales.Inicializa('usario', 'pAssW0rd');
TieneAcceso := TGLobales.Activo;
Perfil := TGloables.Perfil;
ultimoAcceso := TGlobales.FEchaUltAcceso

el método Inicializa(), incializa los valores de las propiedades de clase, que serán Globales, y de solo lectura. en base a los datos de la base de datos. y están disponibles en todos lados donde se haga referencia la unidad.

[Neftali [Germán.Estévez]]

Yo personalmente hubiera hecho algo así (en realidad es lo que hago).

Sigues manteniendo las propiedades de lectura/escritura de las diferentes variables (ya que eso te lo da la clase), y colocas las variables "dentro" de la clase en lugar de fuera.

Mantienes una variable Global del tipo TGlobales, pero es que de la otra forma también mantienes en memoria todas las variables necesarias. No le veo diferencia en eso.

Código Delphi [-]
unit Globales;

interface

type
  TGlobales = class
  private
    FUsuario : string;
    FCadenaConexion: string;
    FPassWord: string;

    // procediminto y función para leer la varables
    // se antepone Class, para indicar que son métodos de clase y on de objeto
    function GetUsuario : string;
    procedure SetUsuario(const Value: string);
    function GetPassWord: string;
  protected

  public
    // Es una propiedad de clase y no de objeto, debido a que usa metodos de clase
    property Usuario : string read GetUsuario;
    property Password: string read FPassWord;
    property CadenaConexion:string read FCadenaConexion write FCadenaConexion;

    procedure Inicializa(Us,psw:String);
  published
  { published declarations }
  end;

var
  uGlobales:TGlobales;

implementation

uses
  SysUtils;


function TGlobales.GetUsuario: string;
begin
  Result := FUsuario;
end;

procedure TGlobales.Inicializa(Us, psw: String);
begin
  FUsuario := us;
  FPassWord := psw;
end;

procedure TGlobales.SetUsuario(const Value: string);
begin
  FUsuario := Value;
end;

Initialization
  uGlobales := TGlobales.Create();

Finalization
  FreeAndNil(uGlobales)

end.