¿El problema de la referencia circular de unidades es propio de Object Pascal?
 

Me preguntaba si el problema de la referencia circular de unidades es propio de Object Pascal.

A veces dos clases necesitan intercambiarse mensajes de forma bidireccional pero es imposible resolver esto en Object Pascal a no ser que metas dos clases en la misma unidad.

Ya se que si se hace uso de la unit2 en la sección Implementation de la unit1 puede resolverse el problema a no ser que la clase de la unit1 tenga atributos del tipo de la clase de la unit2 y la clase de la unit2 tenga atributos del tipo de la clase de la unit1.

Me pregunto esto porque no se si es una limitación de Object Pascal o si hacer esto es hacer un diseño muy enrevesado.

¿Qué opinais?

Saludos.

Esto que comentas no suele ocurrir si lo planteas bien, la verdad es que una vez me paso esto (nunca me había pasado antes, y me quede :confused: xD), y era un fallo mío de diseño xD

Si se plantea bien, no suele ocurrir... :P

Saludos.

Hola,

¿Estás seguro de que dos "clases" no pueden intercambiar información de forma bidireccional, incluso estando en diferentes unidades? Es posible que el asunto de las referencias circulares no se de en otros lenguajes, pero, no creo que se trae de un problema que traiga de cabeza a nadie, y para muestra la cantidad de programas que ahí por ahí escritos en Delphi, entre los que seguro hay alguno que intercambia información entre sus diferentes componentes.

Si la memoria no me falla, eso viene de pascal, CARAMBA, hace 8 años programaba en pascal :P.

Bueno es sencillo, tienes la clase padre

TMamifero y las clases hijas TCaballo y TGato Esto en la unidad1

en unidad2 tienes la Clase TMamifero y las clases hijas TPerro y TRaton

Cuando incluyes en el uses de la unidad 1 el uses de la unidad 2 por que quieres que TGato como a TRaton, pues creas un conflicto al existir clases exactamente iguales TMamifero. Esto de hecho no es exclusivo de Pascal, en C# he notado que sucede exactamente lo mismo a menos claro que utilices namespaces.


Suerte

¿Podrías mostrarnos las secciones Interface de tus dos unidades y decirnos a grandes rasgos qué función tendrán esas clases?

Saludos.

Al González. :)

Puedes resolver las referencias siempre que una esté en implementacion y otra en Interface; Si aun así no se puede, una salida puede ser utilizar una de las clases como un Ancestro (en la herencia), por ejempo utilizarla como TForm y valerse de RTTI para completar el proceso.

Puedes valerte del uses de Implementation e interface, y seguro que si puedes lograr la bidireccionalidad, yo lo he hecho y lo supe hacer leyendo la cara oculta de delphi 4 trae en apartado dedicado a esto leetelo y veras que facil es

No busco una solución, eso ya lo se hacer (si te fijas lo puse en mi mensaje expresamente para que no pensarais que no sabía hacerlo).

Gracias de todos modos.

[sarcasmo]Tienes razón, el enrevesado eres tú :D :D[/sarcasmo]

Ya en serio, el hecho de "necesitar" los uses de forma circular, es causa y consecuencia de un mal diseño.

Imagina, tengo una ventana principal, Form1, y después dos ventanas Form2 y Form3. Ahora quiero usar las 3 de forma circular, y estoy en problemas.

La solución: Crear otra unidad (sin Form asociado), además me ayudo de un tipo enumerado que me evita las referencias circulares:

Código Delphi [-]

Unit publica;

interface
   Uses unit1, unit2, unit3;

Type TAbrir = (aForm1, aForm2, aForm3)

procedure Abrir(QueAbrir:TAbrir);
begin
 case QueAbrir of
   aForm1 : TForm1.Create(application);
   aForm2 : TForm2.Create(application);
   aForm3 : TForm3.Create(application);
end;

Ahora Form1, Form2 y Form3 harán uso de la unidad publica, pero ya estamos evitando crear referencias circulares:

Código Delphi [-]
Unit Unit2;

interface

uses publica;

IMPLEMENTATION

procedure TForm2.blabla(...);
begin 
   Form2 := publica.Abrir(aForm2);
end;

Y en otro sentido: Si las clases comparten atributos, será porque tienen algo en común, por tanto, es lógico que compartan la misma unidad ¿no? ;)

Saludos

Bueno, no siempre...
Hay un caso en que a mi me ha salido bastante.
Imagina las clases de un Frame de persistencia. Cada clase en una Unit, para ser ordenado.
Las relaciones recíprocas entre dos tablas se convierten en referencias circulares entre units.

Por ejemplo:
Persona está relacionado con empresa (pertenece), pero empresa también está relacionado con persona (contacto).

Alguien que me entiende. :)

Vale, os pongo un ejemplo que se me acaba de ocurrir:

Imaginad un dispositivo que además de servir de entrada de datos sirve de salida también, este dispositivo está controlado por una unidad de control.

Tenemos el siguiente funcionamiento:

1) El dispositivo de entrada salida envía una entrada a la unidad de control y esta la almacena.
2) La unidad de control envía un dato al dispositivo de entrada salida y este genera un mensaje.

A mi se me ocurre esta implementación a priori:

Código Delphi [-]
unit uEntradaSalida;

interface

uses StdCtrls, uUnidadControl;

type
  cEntradaSalida = class
                           private
                            Entrada: string;
                            Salida: string;
                            UControl: cUnidadControl;
                           public
                            constructor Create(E: string; S: string; UC: cUnidadControl);
                            procedure EnviarDato;
                            procedure RecibirDato(E);
                           end;

implementation

{ cEntradaSalida }

constructor cEntradaSalida.Create(E: string; S: string; UC: cUnidadControl);
begin
 Entrada := E;
 Salida := S;
 UControl := UC;
end;

procedure cEntradaSalida.EnviarDato;
begin
 UControl.AlmacenarDato(Entrada);
end;

procedure cEntradaSalida.RecibirDato(Dato: string);
begin
 Salida := Dato;
 ShowMessage(Salida);
end;

end.

Código Delphi [-]
unit uUnidadControl;

interface

uses uEntradaSalida;

type
  cUnidadControl = class
                           private
                            Dato: string;
                            EntradaSalida: cEntradaSalida;
                           public
                            constructor Create(Dat: string; ES: cEntradaSalida);
                            procedure AlmacenarDato(Dat: string);
                            procedure EnviarDato;
                           end;

implementation

{ cUnidadControl }

constructor cUnidadControl.Create(Dat: string; ES: cEntradaSalida);
begin
 Dato := Dat;
 EntradaSalida := ES;
end;

procedure cUnidadControl.EnviarDato;
begin
 EntradaSalida.RecibirDato(Dato);
end;

procedure cUnidadControl.AlmacenarDato(Dat: string);
begin
 Dato := Dat;
end;

end.

Se que esto, según está planteado es imposible de que compile en Object Pascal.

Puede que el ejemplo os parezca enrevesado pero os aseguro que hay ejemplos no inventados por mi sino otros estudiados en la Ingeniería del Software que no son soportados por Object Pascal a no ser de que se introduzca más de una clase en una misma unidad (si os pica la curiosidad os diré cual es).

Una solución a esto es hacer tres clases:

uUnidadControl.pas
uEntrada.pas
uSalida.pas

Mi pregunta es si en otros lenguajes de programación como Java o C++ por ejemplo ocurre esto también.

Saludos.

Tenía un peaso mensaje preparado, pero creo que no ha lugar.

Según estoy viendo, la pregunta sería:

¿Deben seguir existiendo esas restricciones hoy día? ¿qué opináis?

Hablo de restricciones que fueron dilucidadas hace 10 años (o más). Informáticamente hablando, fueron tomadas en la era glaciar :p

Saludos

Según estoy viendo....
Esto es un claro ejemplo de un mal diseño. Considero que deberías replantear el diseño y el análisis del problema.

No veo otra manera de resolverlo que reformular el diseño...

No se... ¿Tal vez se trata de un caso especial del uso del patrón Observador?:confused:

Saludos,

uy, uy, no me lo mentes... no me lo mentes, que se me cuelga la implementación que hice :D :D

No es el caso pero ¡bingo!

Pensé que nadie iba a comentarlo.

Iba a poneros la implementación del patrón Observador para que vierais (los que no lo supieran) que no tiene por qué estar mal planteado el problema ya que con el patrón del Observador ocurre esto aunque se soluciona metiendo al Sujeto y al Observador en la misma Unit.

Saludos.

Entonces, ¿se trata de ponernos a prueba? ¿a todos los foristas? ... pues ten cuidado, que HabEmos muchos y sEmos muy buenos :p

Saludos

No, no me malinterpretes, en el fondo aun no se ni un 10% de todo lo que rodea a Delphi, por eso vengo tan a menudo por el foro, para aprender de vosotros.

Lo del patrón Observador lo sabía pero estaba esperando a que alguien lo comentara como un caso de esos excepcionales.

Es lo que me gusta de esta comunidad, que sois muchos y buenos. :)

Saludos.

Yo echo de menos una opción en el IDE que oculte las clases sin referencia a la que desarrollo. Para mi sería genial, un botón de tipo check, o una tecla rápida.

No sé si me he explicado bien, supongamos que tengo en un .pas 3 clases,

TObservador hace referencia a TPatrón.
TMiobjeto es una clase aparte, no tiene nada que ver con la anterior.

Si estoy trabajando sobre TMiobjeto (tengo el cursor del ratón en ella), pulso la tecla rápida y se oculta del .pas TObservador y TPatrón.

BDS2006 permite ocultar procedimientos y métodos, pero es un poco engorroso, entiendo que es el primer paso a lo que digo. Quizás fuera viable como sugerencia a CnPacks o Gexperts.

Saludos

Mientras esa limitación exista, una solución es:

Código Delphi [-]
unit uUnidadControl;

interface

type
  cUnidadControl = class
                           private
                            Dato: string;
                            EntradaSalida: Pointer;  {cEntradaSalida}
                           public
                            constructor Create(Dat: string; ES: Pointer {cEntradaSalida});
                            procedure AlmacenarDato(Dat: string);
                            procedure EnviarDato;
                           end;

implementation

Uses
  uEntradaSalida;

{ cUnidadControl }

constructor cUnidadControl.Create(Dat: string; ES: Pointer {cEntradaSalida});
begin
 Dato := Dat;
 EntradaSalida := ES;
end;

procedure cUnidadControl.EnviarDato;
begin
 cEntradaSalida (EntradaSalida).RecibirDato(Dato);
end;

procedure cUnidadControl.AlmacenarDato(Dat: string);
begin
 Dato := Dat;
end;

end.

Saludos.

Al González. :)