set no funciona

[[AgustinOrtu]]

Buenas, a mi me funciona, copie y pege tu implementacion tal cual e hice estas pruebas:

Código Delphi [-]
implementation

var
  Form3: TForm3;
  listCampos: TArrayClaveValor;

procedure TForm3.InicializarClick(Sender: TObject);
var
    i: integer;
    registro: TClaveValor;
begin
    SetLength(listCampos, 5);
    for i := 0 to 4 do
    begin
        registro.Value := Format('Prueba %d', [i]);
        listCampos[i] := registro;
    end;
end;

procedure TForm3.BtnRecorrerClick(Sender: TObject);
var
    registro: TClaveValor;
    i: integer;
begin
    for i := Low(listCampos) to High(listCampos) do
    begin
        listCampos[i].Value := ReverseString(listCampos[i].Value);
        ShowMessage(Listcampos[i].Value);
    end;
end;

Cuando llamo a ShowMessage me muestra el string invertido

Si no te entendi mal. Uso Delphi 2010

[[nlsgarcia]]

Alberto,

Empezado por Al

...eres uno de los impulsores Delphi (independientes) más esmerados de la comunidad hispana...tus aportaciones en estos foros no son nada baladíes...

Realmente Daniel es todo un maestro

Empezado por Al

...imaginemos las contribuciones que podría hacer ecfisa si tuviera en sus manos un Delphi más actual...

Quizás se pueda proponer que le otorguen el titulo de MVP y esto facilite el camino, aparte de ser un merecido reconocimiento a su labor de tantos años como impulsor de Delphi

Saludos,

Nelson.

[[AgustinOrtu]]

Totalmente de acuerdo, se merece un MVP

[doctorhd]

Al González:

Pero aun así, en lo personal, me seguiría pareciendo un diseño extraño y no muy óptimo.

Y de acuerdo a tu experiencia, que forma debería tomar la implementación para optimizar su funcionamiento...

Saludos...

[ecfisa]

Hola.

Creo que son unos exagerados , aquí hay muchos que son mas merecedores de esas palabras.

Pero de todos modos les agradezco mucho, leer esas opiniones, es la mejor gratificación que cualquiera desearía tener

Saludos

[mamcx]

Empezado por doctorhd

Y de acuerdo a tu experiencia, que forma debería tomar la implementación para optimizar su funcionamiento...

No hablo por AL, pero este es un ejemplo muy tipico de la infección "classitis". Porque una cosa es como hacer esto tipo OO, y otra es darse cuenta que NO ES NECESARIO!

1- Estas usando un record como si fuera una clase
http://www.delphibasics.co.uk/Article.asp?Name=Records

2- Estas usando metodos y funciones & propiedades que no *aportan nada* que no te da un record gratis.
3- Generando mucho codigo para algo que se resuelve con 1 array, 2 record y un par de funciones.

Delphi no es Java! Puedes usar funciones, metodos y dejar de la lado la OO. Es un lenguaje "multi-paradigma", aunque obviamente esta mas enfocado al lado de la OO.

Te pongo un ejemplo:

Código Delphi [-]
type TEnumTypeData = (tyNone,tyCurrency, tyBoolean, tyDate, tyDateTime, tyFloat, tyInteger, tyString, tyExpandString, tyTime, tyBinaryData);

TClaveValor = record
  Clave: string;
  ValueDefault:Variant;
  Value:Variant;
  Tipo: TEnumTypeData;
end;

//TArrayClaveValor = array of TClaveValor;
TArrayClaveValor = TArray; {Aqui es un Array con Generics, pero no se ve que es Array (TClaveValor)}

TConfigBDRegistro = record
public
  TipoServer:TClaveValor;
  NameServer:TClaveValor;
  Ruta:TClaveValor;
  ProComunicacion:TClaveValor;
  VendorLib:TClaveValor;
  ListCampos:TArrayClaveValor;
end;

function createClaveValor(clave:string;tipo:TEnumTypeData; value, ValueDefault:Variant): TClaveValor;
begin
  //Construyes aqui
  result.Clave := clave;
  //etc
end;

function createConfigBD(
  nameServer, tipoServer, ruta, proComunicacion, VendorLib:TClaveValor;
  ListCampos:TArrayClaveValor): TConfigBDRegistro;
begin
  //Construyes aqui
  result.NameServer := nameServer;
  //etc
end;

begin
  try
    { TODO -oUser -cConsole Main : Insert code here }
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

Nota lo siguiente:

- No necesitas hacer create de un record. Los record son tipos "Value" like un string. Por eso son mas livianos y eficientes en memoria
- Mucho codigo eliminado
- Centralizado en createXXXX todo el proceso, incluyendo las validaciones.
- Si tu Delphi soporta Generics, puedes usar TArray<> y te ganas un constuctor + todo lo que te dan las clases genericas, lo que te ahorra otra clase

Código Delphi [-]
TArrayClaveValor.Create(TClaveValor1, TClaveValor2, TClaveValor3);

En resumen: Usa clases cuando necesites la funcionalidad de clases.

[doctorhd]

En un principio TClaveValor era un siempre record sin propiedades, pero al asignarlo como campo a la clase me enviaba el siguiente error:

Código Delphi [-]
e2064 left side cannot be assigned to

y por tal motivo tuve que transformarlo a su forma actual. Respecto a la conveniencia de utilizar registros en vez de clases, sin duda lo hago cuando el caso lo amerita, pero en este caso en particular necesito encapsular los datos contenidos y realizar algunas tareas con ellos, cosa que puedo hacer con funciones como me sugieren, pero prefiero que todo quede dentro de una clase, ya que dichas funciones solo sirven al tratamiento de dicha clase...

Saludos...

[doctorhd]

Bueno finalmente mi diseño quedo de la siguiente forma:

Código Delphi [-]

TEnumTypeData = (tyNone,tyCurrency, tyBoolean, tyDate, tyDateTime, tyFloat, tyInteger, tyString, tyExpandString, tyTime, tyBinaryData);

TClaveValor = record
      private
        FClave:string;
        FValueDefault:Variant;
        FValue:Variant;
        FTipo:TEnumTypeData;
        procedure SetClave(const Value:string);
        procedure SetValueDefault(const Value:variant);
        procedure SetValue(const Value:variant);
        procedure SetTipo(const Value:TEnumTypeData);
      public
        property Clave: string read FClave write SetClave;
        property ValueDefault: Variant read FValueDefault write SetValueDefault;
        property Value:Variant read FValue write SetValue;
        property Tipo: TEnumTypeData read FTipo write SetTipo;
    end;

  procedure TClaveValor.SetClave(const Value:string);
  begin
    FClave:=Value;
  end;

  procedure TClaveValor.SetValueDefault(const Value:variant);
  begin
    FValueDefault:=Value;
  end;

  procedure TClaveValor.SetValue(const Value:variant);
  begin
    FValue:=Value;
  end;

  procedure TClaveValor.SetTipo(const Value:TEnumTypeData);
  begin
    FTipo:=Value;
  end;

 type PClaveValor = ^TClaveValor;{Puntero a TClaveValor }

 type
    TConfigBDRegistro = class
    private
      FTipoServer:TClaveValor;
      FNameServer:TClaveValor;
      FRuta:TClaveValor;
      FProComunicacion:TClaveValor;
      FRutaVendorLib:TClaveValor;
      FListCampos:array of PClaveValor;
      function GetCampo(const Index: Integer): PClaveValor;
      procedure SetCampo(const Index: Integer; const Value: PClaveValor);
      function GetNCampos:Integer;
    public
      constructor Create;
      property TipoServer:TClaveValor read FTipoServer write FTipoServer;
      property NameServer:TClaveValor read FNameServer write FNameServer;
      property Ruta:TClaveValor read FRuta write FRuta;
      property ProComunicacion:TClaveValor read FProComunicacion write FProComunicacion;
      property RutaVendorLib:TClaveValor read FRutaVendorLib write FRutaVendorLib;
      property ListCampos[const Index: Integer]:PClaveValor read GetCampo write SetCampo;
      property NCampos:Integer read GetNCampos;
    end;

  constructor TConfigBDRegistro.Create;
  begin
    Setlength(FListCampos,5);{Dimencionamos el tamaño de la lista de campos}
    FListCampos[0]:=@FTipoServer;
    FListCampos[1]:=@FNameServer;
    FListCampos[2]:=@FRuta;
    FListCampos[3]:=@FProComunicacion;
    FListCampos[4]:=@FRutaVendorLib;
  end;{constructor}

  function TConfigBDRegistro.GetCampo(const Index:Integer):PClaveValor;
  begin
    Result:=FListCampos[Index];
  end;{function}

  procedure TConfigBDRegistro.SetCampo(const Index:Integer; const Value:PClaveValor);
  begin
    FListCampos[Index]:=Value;
  end;{function}

  function TConfigBDRegistro.GetNCampos:Integer;
  begin
    Result:=High(FListCampos);
  end;{function}

Para ser llamado asi:

Código Delphi [-]
  ....
   vFin:=ConfigBDRegistro.NCampos;
   {recorremos la lista de campos}
   for vIndice:=0 to vFin do begin
     ListCampos[vIndice].Value:='un Dato';{Funciona}
   end;{for}
  ....

Un comentario acerca de lo dicho por mamcx

1- Estas usando un record como si fuera una clase

Si, pero el lenguaje lo permite y lo implementa como una opción, por tanto porque no utilizarlo...

Creo que mamcx tiene razón en varios de los comentarios que hace, referente a simplificar el diseño utilizando solo record y funciones, ahora la pregunta es cuando programar O.O y cuando programar procedimientalmente... En mi caso mi aprendizaje fue enfocado a este ultimo, pero he ido cambiando de paradigma, por las enormes ventajas que representa programar O.O. herencia, encapsulacion, etc... Quizas utilizar lo mejor de ambos modelos...????

Saludos...