[[gluglu]]

Hola Neftalí !

Antes de nada, decirte que el último ZIP añadido no está accesible en estos momentos. El contenido es ilegible y da error. Así que no he podido revisar este último código que adjuntas.

He estado revisando todo mi código y todos vuestros comentarios.

... y mira que hace algunos años ya que estuve revisando el ejemplo que pones en un mensaje más arriba.

Ya me queda claro que no declaré el Thread Calculate_Total en la unit List_General como private. Entiendo que en cualquier caso, también se podría declarar como público, no es verdad ?

También llevo muchos años siguiendo el foro y he denotado en todas mis consultas, que cada uno pasa parámetros de manera diferente a procedimientos. En el primer ejemplo tu utilizas el propio método Create para pasar los parámetros a cada Thread. Personalmente nunca lo he utilizado así y no sé si es mejor o peor (aunque a mi me funciona hasta el día de hoy perfectamente) el pasar los parámetros mediante variables públicas en el procedimiento llamado.

Por lo tanto entiendo también que puedo pasar tanto la referencia de la instancia del Form List_General en concreto que ejecuta el Thread al propio Thread, o puedo pasar una variable Pos_Array que es la cual me indica la posición en el Array Arr_List declarado en el MainForm, y después hacer referencia al listado en concreto como MainForm.Arr_List[Pos_Array] y a continuación el elemento que quiera.

En respuesta a tu pregunta de donde sale precisamente esa variable Pos_Array, cuando creo en el MainForm una nueva instancia de List_General lo que hago es añadir un elemento al Array Arr_List y su posición en el Array la asigno a la variable Pos_Array que a su vez se la paso a List_General para saber en cada form qué referencia es en concreto del MainForm.Arr_List

Además indico aquí que cuando hago un Free de una instancia de List_General, en MainForm.Arr_List busco la referencia en concreto y le asigno el valor Nil. Por lo tanto, respecto al párrafo anterior, al crear un nuevo List_General, no siempre lo añado al final, sino busco la primera posición en MainForm.Arr_List que esté a nil, y si lo encontrase, asigno esa posición del MainForm.Arr_List a la instancia que acabo de crear de List_General. Si no hay ningun nil en el Array, entonces sí que lo añado al final.

Código Delphi [-]
procedure TMainForm.Create_New_List;
var
  i : integer;
  Aux_L : Integer;
begin
 
  Screen.Cursor := crHourGlass;
 
  Aux_L := Length(Arr_List);
  if Aux_L = 0 then
    I := 0
  else begin
    for I := 0 to Aux_L - 1 do begin
      if Arr_List[i] = nil then break;
    end;
  end;
 
  if I >= Aux_L then begin
    SetLength(Arr_List,I+1);
    I := length(Arr_List)-1;
  end;
 
  Arr_List[i] := TList_General.Create(Self);
  Arr_List[i].FormStyle             := fsMDIChild;
  ....
  Arr_List[i].Pos_Array             := I;
  ....
  Arr_List[i].Show;
 
  Screen.Cursor := crDefault;
 
end;

Cada instancia de List_General tiene por lo tanto una variable pública Pos_Array.

Pienso que si le paso esta variable Pos_Array al Thread Calculate_Total, también podré hacer referencia dentro del Thread a la instancia concreta de List_General que quiera. Como tu bien dices, también podría pasar el Form en sí mismo como referencia.

Todavía no me ha quedado claro la otra cuestión, que a su vez te intento aclarar a ti.

El Thread Calculate_Total a su vez llama a otro procedimiento almacenado en una unit .pas .

Código Delphi [-]
procedure TCalculate_Total.Execute;
begin
 
  CTDatabase := TIBDatabase.Create(nil);
  CTDataBase.DatabaseName := DM0.IBDatabase1.DatabaseName;
  CTDataBase.LoginPrompt  := DM0.IBDatabase1.LoginPrompt;
  CTDataBase.Params       := DM0.IBDatabase1.Params;
  CTDataBase.SQLDialect   := 3;
  CTDataBase.Connected    := True;
 
  CTTransaction := TIBTransaction.Create(nil);
  CTTransaction.DefaultDataBase := CTDatabase;
  CTTransaction.StartTransaction;
 
  CTDataSet1 := TIBDataSet.Create(nil);
  CTDataSet1.Transaction := CTTransaction;
 
  CTDataSet2 := TIBDataSet.Create(nil);
  CTDataSet2.Transaction := CTTransaction;
 
  CTDataSet3 := TIBDataSet.Create(nil);
  CTDataSet3.Transaction := CTTransaction;
 
  CTDataSet4 := TIBDataSet.Create(nil);
  CTDataSet4.Transaction := CTTransaction;
 
  CTDataSetCheck  := TIBDataSet.Create(nil);
  CTDataSetCheck.Transaction  := CTTransaction;
 
  CTDataSetCheck2 := TIBDataSet.Create(nil);
  CTDataSetCheck2.Transaction := CTTransaction;
 
  CTDataSetCheck3 := TIBDataSet.Create(nil);
  CTDataSetCheck3.Transaction := CTTransaction;
 
  with CTDataSet1 do begin
    SelectSQL.Clear;
    SelectSQL.Add('..... ');
    ....
    ModifySQL.Clear;
    ModifySQL.Add('..... ');
    ....
    InsertSQL.Clear;
    InsertSQL.Add('..... ');
  end;

  ...
 
  if Type_Listing = 1 then Calculate_Detail(6, CTDataSet1, CTDataSetCheck,
     CTDataSetCheck2, CTDataSetCheck3, CTDataSet2, Random_No4, Today, Today); 
  ...
 
  CTTransaction.Active := False;
  CTDataBase.Close;
  CTDataBase.Free;
  CTTransaction.Free;
  CTDataSet1.Free;
  CTDataSet2.Free;
  CTDataSet3.Free;
  CTDataSetCheck.Free;
  CTDataSetCheck2.Free;
  CTDataSetCheck3.Free;

end;

El procedimiento Calculate_Detail, como decía, está en otra Unit diferente y puede ser llamado por otros muchos forms de mi aplicación, al igual que se llama a este procedimiento desde el propio Thread. Pienso que esto es posible, no ? Es correcto hacerlo así, no ?

Mi duda es cómo actualizo una variable del Thread (Calculate_Total) desde el procedimiento Calculate_Detail ?

Hasta ahora lo hacía tal y como indiqué en un hilo anterior

Código Delphi [-]
procedure Calculate_Detail(Modus: Integer; pDataSet1: TIBDataSet;
  pDataSetBDM: TIBDataSet; pDataSetBDM2: TIBDataSet; pDataSetBDM3: TIBDataSet;
  pDataSetBook: TIBDataSet; Random_No: Int64; StayOverFrom: TDate; StayOverTo: TDate);
begin
  ...
  Calculate_Total.Aux_Random := Aux_R1;
  ...
end;

Pero está claro que está mal hecho lo que hacía hasta ahora, porque en verdad no esta referiéndome a ninguna instancia en concreto del Thread Calculate_Total creado en cada List_General. No había declarado la variable Calculate_Total correctamente dentro de List_General.

Cómo puedo actualizar entonces la variable Aux_Random declarada como pública dentro del Thread Calculate_Total ? Cómo me puedo referir a cada instancia en concreto de Calculate_Total, que a su vez ha sido creada por cada instancia de List_General ?

Pensaba que podía ser igual que ponía en mi último post :

Código Delphi [-]
MainForm.Arr_List[i].Calculate_Total.Aux_Random := Aux_R1;

pero lo he probado y no me funciona.

Si pasase el Form (List_General) como referencia al Thread (Calculate_Total), y este Thread (Calculate_Total) a su vez se lo pasase al procedimiento Calculate_Detail, como sería posible la actualización desde Calculate_Detail de la variable Aux_Random declarada en el Thread Calculate_Total ?

.... que lío no ???

Gracias de nuevo !