Campaña para corregir el uso de 'With' en Object Pascal

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

Entiendo que la única utilidad del with dentro del lenguaje es eliminar determinadas "palabras" de forma reiterativa en un bloque de código.
Si resulta que para poder usar el with ahora vamos a introducir la necesidad de usar una nueva palabra, ¿no será mejor no utilizarlo?
Es decir, creo que usar el with (que creo que es lo que proponéis) usando un identificador (it o idem) es lo mismo (o es peor) que usar una variable y declararla del tipo correcto.

Me explico:

Ahora tenemos esto:

Código Delphi [-]
var
  John, Sarah : TCustomer;
begin
  // Set up the John's customer details
  with John do
  begin
    firstName := 'John';
    lastName  := 'Smith';
    address1  := '7 Park Drive';
    address2  := 'Branston';
    address3  := 'Grimworth';
    city      := 'Banmore';
    postCode  := 'BNM 1AB';
  end;

Para solventarlo, proponemos crear una directiva condicional y obligar a escribir esto:

Código Delphi [-]
var
  John, Sarah : TCustomer;
begin
  // Set up the John's customer details
  with John do
  begin
    idem.firstName := 'John';
    idem.lastName  := 'Smith';
    idem.address1  := '7 Park Drive';
    idem.address2  := 'Branston';
    idem.address3  := 'Grimworth';
    idem.city      := 'Banmore';
    idem.postCode  := 'BNM 1AB';
  end;

Creo que en comparación con esto, estamos liando las cosas...
Porque resulta que al final, para poder utilizar el with (cuya ventaja creo que es eliminar determinadas palabra repetitivas), estamos obligando al usuario a escribir más código con otra palabra que se repite (y menos entendible) que si escribiéramos el código natural.

Código Delphi [-]
var
  John, Sarah : TCustomer;
begin
  // Set up the John's customer details
  John.firstName := 'John';
  John.lastName  := 'Smith';
  John.address1  := '7 Park Drive';
  John.address2  := 'Branston';
  John.address3  := 'Grimworth';
  John.city      := 'Banmore';
  John.postCode  := 'BNM 1AB';

O no lo entiendo o no lo veo.

NOTA: El código de ejemplo está extraído de la explicación del WITH de DelphiBasics.

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

Y que conste que hay ejemplos en los que WITH puede tener sentido (y creo que es para lo que se pensó) como puede ser algo así (donde la parte a eliminar es muy grande):

Código Delphi [-]
  dmClientesMain.objCliente.QueryClientes.FieldByName('ID').AsString := ID;
  dmClientesMain.objCliente.QueryClientes.FieldByName('Nombre').AsInteger := 'Nombre';
  dmClientesMain.objCliente.QueryClientes.FieldByName('Desc').AsString := 'Descripcion';
  dmClientesMain.objCliente.QueryClientes.FieldByName('Telefono').AsString := '123456789';
  ...

Pero es que para estos casos, creo que esto:

Código Delphi [-]
var
  q:TQuery;
begin
  q := dmClientesMain.objCliente.QueryClientes;
  q.FieldByName('ID').AsString := ID;
  q.FieldByName('Nombre').AsInteger := 'Nombre';
  q.FieldByName('Desc').AsString := 'Descripcion';
  q.FieldByName('Telefono').AsString := '123456789';
  ...

Es más claro que esto, ya sea usando it o idem:

Código Delphi [-]
  with dmClientesMain.objCliente.QueryClientes do 
  begin
  it.FieldByName('ID').AsString := ID;
  it.FieldByName('Nombre').AsInteger := 'Nombre';
  it.FieldByName('Desc').AsString := 'Descripcion';
  it.FieldByName('Telefono').AsString := '123456789';
  end;
  ...

Entre otras cosas porque <it> o <idem> me dan un significado "genérico", <q> en este caso, para mi tiene un significado (de query) que además me hace más claro entender el código.
Al igual que si uso frm (para un TForm), f (para un TField), ds (para un TDataSet),...

[jhonny]

Empezado por Neftali

Entiendo que la única utilidad del with dentro del lenguaje es eliminar determinadas "palabras" de forma reiterativa en un bloque de código.
Si resulta que para poder usar el with ahora vamos a introducir la necesidad de usar una nueva palabra, ¿no será mejor no utilizarlo?
Es decir, creo que usar el with (que creo que es lo que proponéis) usando un identificador (it o idem) es lo mismo (o es peor) que usar una variable y declararla del tipo correcto.

Me explico:

Ahora tenemos esto:

Código Delphi [-]
var
  John, Sarah : TCustomer;
begin
  // Set up the John's customer details
  with John do
  begin
    firstName := 'John';
    lastName  := 'Smith';
    address1  := '7 Park Drive';
    address2  := 'Branston';
    address3  := 'Grimworth';
    city      := 'Banmore';
    postCode  := 'BNM 1AB';
  end;

Para solventarlo, proponemos crear una directiva condicional y obligar a escribir esto:

Código Delphi [-]
var
  John, Sarah : TCustomer;
begin
  // Set up the John's customer details
  with John do
  begin
    idem.firstName := 'John';
    idem.lastName  := 'Smith';
    idem.address1  := '7 Park Drive';
    idem.address2  := 'Branston';
    idem.address3  := 'Grimworth';
    idem.city      := 'Banmore';
    idem.postCode  := 'BNM 1AB';
  end;

Creo que en comparación con esto, estamos liando las cosas...
Porque resulta que al final, para poder utilizar el with (cuya ventaja creo que es eliminar determinadas palabra repetitivas), estamos obligando al usuario a escribir más código con otra palabra que se repite (y menos entendible) que si escribiéramos el código natural.

Código Delphi [-]
var
  John, Sarah : TCustomer;
begin
  // Set up the John's customer details
  John.firstName := 'John';
  John.lastName  := 'Smith';
  John.address1  := '7 Park Drive';
  John.address2  := 'Branston';
  John.address3  := 'Grimworth';
  John.city      := 'Banmore';
  John.postCode  := 'BNM 1AB';

O no lo entiendo o no lo veo.

NOTA: El código de ejemplo está extraído de la explicación del WITH de DelphiBasics.

¡Caramba!, creo que lo que dije antes, ha quedado mucho mejor explicado y reflejado por Neftali en este post. Así que me uno a este comentario y al otro que escribió después de ese.

[Casimiro Noteví]

Empezado por jhonny

¡Caramba!, creo que lo que dije antes, ha quedado mucho mejor explicado y reflejado por Neftali en este post. Así que me uno a este comentario y al otro que escribió después de ese.

+1 .

[roman]

De hecho, creo que el debate debió comenzar con una exposición de motivos, precisamente para dar mayor claridad: cuáles son exactamente las supuestas falencias y virtudes de la cláusula.

Por ejemplo, ¿quién no ha usado el típico

Código Delphi [-]
with TAlgunFormulario.Create do
begin
  // ...
  ShowModal;
  // ..
end;

para mostrar un cuadro de diálogo?

Claro que podemos usar una variable pero resulta muy cómodo ahorrárnosla si el formulario se desecha una vez cerrado.

O bien, ¿han considerado que además de ahorrar escritura, el with puede ahorrar llamadas a métodos? Por ejemplo en:

Código Delphi [-]
Persona.Domicilio.Calle := 'Av. Principal';
Persona.Domicilio.Numero := 1;

si Domicilio es una propiedad de la clase TPersona a la que se accede mediante un getter, éste se llamará dos veces. El uso con with:

Código Delphi [-]
with Persona.Domicilio do
begin
  Calle := 'Av. Principal';
  Numero := 1;
end;

reduce a una sóla llamada.

Igual que el caso anterior, se puede usar una variable para evitar el doble acceso, pero resulta mucho más cómodo así.

LineComment Saludos

[[Al González]]

¡Menudos ejemplos, Germán! Por supuesto que no tendría sentido usar el nuevo With en casos así.

Pero hay otros donde sí, como el de la imagen del primer mensaje (que parece que salió borrosa). Consideremos la siguiente comparativa:

Sin With:

Código Delphi [-]
procedure TForm1.Button1Click(Sender: TObject);
var
  LForm :TForm2;
begin
  LForm := TForm2.Create(Self);

  try
    AppLogger.LogForm(LForm);  // Llamada a un método externo usando el formulario creado como parámetro
    LForm.ShowModal;
  finally
    LForm.Free;
  end;
end;

Con el nuevo With:

Código Delphi [-]
procedure TForm1.Button1Click(Sender: TObject);
begin
  with TForm2.Create(Self) do
    try
      AppLogger.LogForm(It);  // Llamada a un método externo usando el formulario creado como parámetro
      It.ShowModal;
    finally
      It.Free;
    end;
end;

No es que busquemos ahorrar palabras. No es así de simple. Sino que los recursos que permitan simplificar código fuente de una manera elegante siempre debieran ser bienvenidos, salvo que no sean seguros. Como el riesgo es la desventaja del With actual, se propone hacerlo seguro conservando su elegancia. Incluso se añade una ventaja más: la de poder hacer referencia al objeto mismo dentro del bloque With (algo que la actual sintaxis no posee).

Saludos aclaratorios.

Al González.

P.D. Se agradece el anterior mensaje, de Román, que ahora veo y suscribo.

[[AgustinOrtu]]

Sigo sin verle mucho sentido. En lugar de escribir var it: TForm2 tengo que escribir with. No son muchos caracteres que se ahorran, y se debe agregar un nivel de sangría adicional. Combinado con un bloque de protección de recursos (try-finally) y un bloque de manejo de excepciones (try-except) se tendrían 3 niveles de sangría. A mi ya dos me parece mucho