ARC - Weak-Referenzen mit unterschiedlichem Verhalten bei ARC und Nicht-ARC

[alda]

Zitat von Stevie:

Zitat von Sir Rufo:

Für normale Instanzen kann man WeakReference auch nachbauen. Bei der Umsetzung dessen bin ich auf dieses Verhalten erst gestossen. Gut für Nicht-ARC ist es schon ganz schöner Schweinecode, aber funktioniert zuverlässig und auf beiden Architekturen.

Spar dir die Arbeit, hab ich schon fertig

Oder alternativ hier: Delphi-WeakReferences

Zitat von Der schöne Günther:

Zitat von himitsu:

Für Interfaces kann man Weak-Referenzen auch nachbauen, was ich für mich bereits gemacht hab, dank der Operatoren.

Das möchtest du bestimmt einmal zeigen.

Letztendlich ist es "einfach" ein Pointer auf das Interface, da Pointer von Haus aus weak sind (z.B TAggregatedObject).

[Sir Rufo]

Also die Delphi-WeakReferences kann ich gar nicht gebrauchen, weil das für jede Instanz egal von welcher Klasse benötige (z.B. für ein TBitmap und da kann ich eben nicht mal so eben ein zusätzliches Interface dranklatschen, ohne wilde Schreiborgie).

Ja, den Spring-Stevie-Weg habe ich auch gewählt (anders beschritten, aber auch über die Virtuellen Klassen) das geht dann einfach so mit jeder Klasse

Aber der Spring springt mir zu sehr in meine eigene Bibliotheken rein (gleiche Funktionalitäten haben gleiche Namen) und da habe ich keine Lust ständig auf den Namespace zu achten.

BTW: Bei mir schalte ich den gesamten VirtualClass-Kram unter ARC komplett ab, denn da geht das ja von Haus aus

[alda]

Zitat von Sir Rufo:

Also die Delphi-WeakReferences kann ich gar nicht gebrauchen, weil das für jede Instanz egal von welcher Klasse benötige (z.B. für ein TBitmap und da kann ich eben nicht mal so eben ein zusätzliches Interface dranklatschen, ohne wilde Schreiborgie).

Das ist korrekt, wollte es auch einfach nur mit einwerfen (ohne Wertung) Hatte die Spring-WeakReference auch bisher noch nicht genutzt, aber da scheint Stefan mal wieder super Arbeit geleistet zu haben

Zitat von Sir Rufo:

Ja, den Spring-Stevie-Weg habe ich auch gewählt (anders beschritten, aber auch über die Virtuellen Klassen) das geht dann einfach so mit jeder Klasse

Wo funktioniert die Spring-WeakReference denn nicht?

[Sir Rufo]

Die Spring-WeakReference funktioniert genau wie meine mit jeder Instanz egal von welcher Klasse.

Ich kann nur das gesamte Spring nicht gebrauchen

[himitsu]

Zitat von Der schöne Günther:

Das möchtest du bestimmt einmal zeigen.

War eine Designstudie, war noch nie im realen Einsatz und ich hoffe ich hab auf die Schnelle auch die richtige Version erwischt.
Einfach nur die Referenzzählung deaktiviert, aber nichts mit automatischem nil.

Delphi-Quellcode:

type
  TWeakRef<Obj: class> = record
  private
    //FReference: {$IFDEF WEAKINSTREF}Obj{$ELSE}Pointer{$ENDIF};
    {$IFDEF WEAKINSTREF}
    FReference: Obj;
    {$ELSE}
    FReference: Pointer;
    {$ENDIF}
  public
    class operator Implicit(const Value: Obj): TWeakRef<Obj>; inline;
    class operator Implicit(const Value: TWeakRef<Obj>): Obj; inline;
  end;
  TWeakIntf<Intf: IInterface> = record
  private
    //FReference: {$IFDEF WEAKINTREF}Intf{$ELSE}Pointer{$ENDIF};
    {$IFDEF WEAKINTREF}
    FReference: Intf;
    {$ELSE}
    FReference: Pointer;
    {$ENDIF}
  public type
    PIntf = ^Intf;
  public
    class operator Implicit(const Value: Intf): TWeakIntf<Intf>; inline;
    class operator Implicit(const Value: TWeakIntf<Intf>): Intf; inline;
  end;

{ TWeakRef<Ref> }

class operator TWeakRef<Obj>.Implicit(const Value: Obj): TWeakRef<Obj>;
begin
  //Result.FReference := {$IFDEF WEAKINSTREF}Value{$ELSE}Pointer(Value){$ENDIF};
  {$IFDEF WEAKINSTREF}
  Result.FReference := Value;
  {$ELSE}
  Result.FReference := Pointer(Value);
  {$ENDIF}
end;

class operator TWeakRef<Obj>.Implicit(const Value: TWeakRef<Obj>): Obj;
begin
  //Result := {$IFDEF WEAKINSTREF}Value.FReference{$ELSE}Obj(Value.FReference){$ENDIF};
  {$IFDEF WEAKINSTREF}
  Result := Value.FReference;
  {$ELSE}
  Result := Obj(Value.FReference);
  {$ENDIF}
end;

{ TWeakIntf<Intf> }

class operator TWeakIntf<Intf>.Implicit(const Value: Intf): TWeakIntf<Intf>;
begin
  //Result.FReference := {$IFDEF WEAKINTREF}Value{$ELSE}PPointer(@Value)^{$ENDIF};
  {$IFDEF WEAKINTREF}
  Result.FReference := Value;
  {$ELSE}
  Result.FReference := PPointer(@Value)^;
  {$ENDIF}
end;

class operator TWeakIntf<Intf>.Implicit(const Value: TWeakIntf<Intf>): Intf;
begin
  //Result := {$IFDEF WEAKINTREF}Value.FReference{$ELSE}PIntf(@Value.FReference)^{$ENDIF};
  {$IFDEF WEAKINTREF}
  Result := Value.FReference;
  {$ELSE}
  Result := PIntf(@Value.FReference)^;
  {$ENDIF}
end;

Nix Großes ... im Grunde einfach nur die manuellen Casts im Generic verpackt.


Generics und unterschiedliche DEFINEs funktioniert nicht.
Außerdem erlauben Generics nur UND-Einschränkungen. (Object ODER Interface)
Auch wenn WEAKINTREF und WEAKINSTREF bisher scheinbar immer gleich eingestellt sind, weiß ich nicht was in Zukunft passiert.

Sonst hätte eine einzige Klasse gereicht. (per Code zur Laufzeit den Typ zu prüfen wollte ich nicht)
Und nicht über die Kommentare wundern, aber die Parser von Error-Insight und Docu-Insight sind sowas von schrottig, daß ich den Originalcode aufteilen musste.


[add]
Ein Code ala

Delphi-Quellcode:

type
  TWeak<Ref: class, interface> = record
  private
    FReference: {$IF Define(WEAKINSTREF) and (TypeInfo(Ref).Kint = tkClass)
      or Define(WEAKINTREF) and (TypeInfo(Ref).Kint = tkInterface)}Obj{$ELSE}Pointer{$IFEND};
  public
    class operator Implicit(const Value: Ref): TWeak<Ref>; inline;
    class operator Implicit(const Value: TWeak<Ref>): Ref; inline;
  end;

{ TWeak<Ref> }

class operator TWeak<Ref>.Implicit(const Value: Ref): TWeak<Ref>;
begin
  Result.FReference := {$IF Define(WEAKINSTREF) and (TypeInfo(Ref).Kint = tkClass)
    or Define(WEAKINTREF) and (TypeInfo(Ref).Kint = tkInterface)}Value{$ELSE}Pointer(Value){$IFEND};
end;

class operator TWeak<Ref>.Implicit(const Value: TWeak<Ref>): Ref;
begin
  Result := {$IF Define(WEAKINSTREF) and (TypeInfo(Ref).Kint = tkClass)
    or Define(WEAKINTREF) and (TypeInfo(Ref).Kint = tkInterface)}Value.FReference{$ELSE}Ref(Value.FReference){$IFEND};
end;

wäre cooler gewesen.


Ab TComponent lässt sich ein schön kleiner Code für eine selbst-auf-nil-setzende Objektvariable realisieren. (ansonsten isses nur ein bissl umständlicher)

[Stevie]

Zitat von alda:

Oder alternativ hier: Delphi-WeakReferences

Die machen das nur für Interfaces, mööp

Zitat von Sir Rufo:

Aber der Spring springt mir zu sehr in meine eigene Bibliotheken rein (gleiche Funktionalitäten haben gleiche Namen) und da habe ich keine Lust ständig auf den Namespace zu achten.

BTW: Bei mir schalte ich den gesamten VirtualClass-Kram unter ARC komplett ab, denn da geht das ja von Haus aus

Eventuell magst du mir mal ne PM oder email schreiben, was da kollidiert. Eventuell findet sich ja ein Weg, das kompatibel zu machen.
Wegen ARC. Joa, ist ja auch noch im Branch und mit den ARC Platformen selber mach ich nicht so viel, daher ist da noch nix zurecht geschneidertifdeft worden für.

Zitat von alda:

Hatte die Spring-WeakReference auch bisher noch nicht genutzt, aber da scheint Stefan mal wieder super Arbeit geleistet zu haben

Wird sich zeigen, ist letzlich so ähnlich implementiert, wie die weak references in der RTL (ob das gut oder schlecht ist, lass ich nun so stehen )
Aber die ganzen Sachen aus dem dynamicproxy Branch werden noch interessant. (hat da hinten nen Java developer gegähnt und irgendwas von "...vor 10 Jahren schon..." gesagt?)

[Mavarik]

Also nix gegen das Spring4D Framework...Gute Arbeit.
Aber es ist mir einfach zu dick...

Mavarik

PS.: Gibt es nicht die Möglichkeit das [WEAK] tag über die RTTI aus zu lesen und entsprechend zu reagieren?

[alda]

Zitat von Mavarik:

Also nix gegen das Spring4D Framework...Gute Arbeit.
Aber es ist mir einfach zu dick...

Es zwingt Dich ja keiner das ganze Framework einzubinden, wenn Du nur Funktionalität X benötigst. ;>

[Stevie]

Zitat von alda:

Es zwingt Dich ja keiner das ganze Framework einzubinden, wenn Du nur Funktionalität X benötigst. ;>

Mit genau dieser Zielsetzung sind auch die meisten grundlegenden Datentypen und Funktionalitäten aufgebaut. Für vieles davon bindest nur die Spring.pas ein und hast, was du brauchst. Um den Rest aus der Unit, den du nicht benutzt, kümmert sich der Smartlinker.