[generic]

Hallo DP,

wie so oft gibt es wieder ein neues Video von mir.
Dieses mal erkläre ich einen kleinen Einstieg in die OTL.

Die OTL ist die "Omni Thread Lib." mit welcher man sehr einfach Multithread programmieren kann.

Wie immer ist das Thema zu groß um es in nur 10 Minuten zu erschlagen. Ggf. gibt es weitere Videos zu dem Thema.
Ihr könnt hier auch gerne Wünsche äußern, was hier erfahren wollt. Falls ich irgendwo falsch liege, dann korrigiert mich hier bitte.

Hier das Video:
https://www.youtube.com/watch?v=OBBjqxxw31Y

Die Quellen aus dem Video sind im Anhang.

Danke für die Info

Zur OTL kann ich auch das Buch empfehlen. Leanpub

Danke für das Video!

Vielen Dank!

Vielen Dank für das Video-Tut! Parallelprogrammierung interessiert mich schon seit geraumer Zeit, hab mich aber bisher nicht so recht ran getraut. Vielleicht gehe ich das ja jetzt mal an.

Was mich an dem Video ein wenig stört, und das ist ausdrücklich keine Kritik an @generic, ist diese anonyme Prozeduritis. Ich hatte früher viel mit jQuery zu tun, da wurde dies bis zum Exzess getrieben. Das Ergebnis ist hier wie da immer das selbe: Schwer lesbarer Code, unter Kollegen manchmal "Kot" genannt. Irgendwie wehrt sich da in mir was, Bibliotheken zu verwenden, die anonyme Prozeduren zum Designprinzip erheben. Ein Methodenzeiger mag vllt. etwas umständlich und altbacken wirken, räumt aber den Source auf. - Meine ganz persönliche Meinung! -

Zitat von Codehunter:

Irgendwie wehrt sich da in mir was, Bibliotheken zu verwenden, die anonyme Prozeduren zum Designprinzip erheben. Ein Methodenzeiger mag vllt. etwas umständlich und altbacken wirken, räumt aber den Source auf.

Es wird ja niemand gezwungen, die anonyme Methode direkt beim Aufruf hinzuschreiben. Auch werden Methoden einer Klasse bei passender Signatur akzeptiert.

zusammenfalten · markieren

Delphi-Quellcode:

program Project746;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils;

type
  TMyTest = class
  private
    procedure MyTest(Arg: Integer);
  public
    procedure CallTest;
  end;

procedure Test(proc: TProc<Integer>);
begin
  proc(42);
end;

procedure TMyTest.CallTest;
begin
  Test(MyTest);
end;

procedure TMyTest.MyTest(Arg: Integer);
begin
  Writeln(ClassName + '.MyTest(' + Arg.ToString + ')');
end;

procedure MyProc(Arg: Integer);
begin
  Writeln('MyProc(' + Arg.ToString + ')');
end;

var
  myTest: TMyTest;
begin
  Test(MyProc);
  myTest := TMyTest.Create;
  try
    myTest.CallTest;
    Test(myTest.MyTest);
  finally
    myTest.Free;
  end;
  Readln;
end.

@codehunter Bezüglich der Anonymen-Methoden ist das natürlich eine persönliche Preferenz. Wie Uwe schon geschrieben hat, kann man natürlich auch benannte Funktionen draus machen.

Gibt zu dem Thema auch zufällig ein Video "Zeiger auf Methoden und Funktionen in Delphi" https://www.youtube.com/watch?v=7PL_H2aBUOI .

Meine Aufteilung - über den Daumen gepeilt:
Wenn es spezielle Code nur für den Aufruf ist bzw. gefühlt "dort hin gehört", dann als anonyme.
Wenn der Code ggf. wieder verwendet wird oder ich das Unittesten will, dann benannte.

Ja ganz klar meine persönliche Meinung. Ich hätte damals auch gegen die Einführung anonymer Prozeduren in der Syntax votiert wenn mich einer gefragt hätte ^^. Sowas neigt zur Spaghettisierung und Verkleben.

Um jetzt wieder den Bogen zum Video zu schließen: Vier von fünf Sternen. Den fünften gäbe es, wenn neben den anonymen Prozeduren auch die Methodenzeiger-Variante gezeigt würde.