Aufbau logisch und korrekt?

[Namenloser]

Zitat von ChEeTaH:

Ich bin leider (noch) kein ausgebildeter Informatiker

Ich auch nicht

Aber ich habe mir jetzt deinen Quellcode noch einmal genauer angesehen, und dabei ist mir aufgefallen: Wozu brauchst du überhaupt TParseServices?

Eine sinnvolle, logische Klassenstruktur sähe für mich so aus:

Delphi-Quellcode:

uses
  contnrs; // für TObjectList

type

  TSearchResult = class
  private
    FTitle, FLink: string;
  public
    property Title: string read FTitle write FTitle;
    property Link: string read FLink write FLink;
  end;

  TSearchResultList = class(TObjectList)
  private
    function GetItem(Index: integer): TSearchResult;
    procedure SetItem(Index: integer; Item: TSearchResult);
  public
    property Items[index: integer]: TSearchResult read GetItem write SetItem; default;
    function Add(Item: TSearchResult): integer; override;
    { ... }
  end;

  TSearchProvider = class
  private
    FResults: TSearchResults;
    FQuery: string;
  protected
    function BuildRequestURL(Query: string): string; virtual; abstract;
    procedure Parse(Content: string); virtual; abstract;
  public
    property Results: TSearchResultList read FResults;
    property Query: string read FQuery write FQuery;
    procedure Submit;

    constructor Create;
    destructor Destroy; override;
  end;

implementation

{ TSearchProvider }

constructor TSearchProvider.Create;
begin
  inherited;
  FResults := TSearchResultList.Create(True);
end;

constructor TSearchProvider.Destroy;
begin
  FResults.Free;
end;

procedure TSearchProvider.Submit;
var
  Content: string;
begin
  Content := HTTP_GET(BuildRequestURL(FQuery)); // ausgedachte Funktion... konkrete umsetzung überlasse ich dir

  Results.Clear;
  Parse(Content);
end;

{ TSearchResultList }

function TSearchResultList.GetItem(index: integer): TSearchResult;
begin
  Result := TSearchResult(inherited GetItem(index));
end;

procedure TSearchResultList.SetItem(index: integer; Item: TSearchResult);
begin
  inherited SetItem(index, Item);
end;

function TSearchResultList.Add(Item: TSearchResult);
begin
  Result := inherited Add(Item);
end;

Eine konkrete Implementierung eines bestimmten Searchproviders könnte dann so aussehen:

Delphi-Quellcode:

type
  TGoogle = class(TSearchProvider)
  protected
    function BuildRequestURL(Query: string): string; override;
    procedure Parse(Content: string); override;
  end;

implementation

function TGoogle.BuildRequestURL(Query: string): string;
begin
  Result := Format('http://google.de/?q=%s', [Query]);
end;

procedure TGoogle.Parse(Content: string); override;
var
  SearchResult: TSearchResult;
begin
  // Suchergebnisse in Quellcode suchen...

  SearchResult := TSearchResult.Create;
  SearchResult.Title := '...';
  SearchResult.Link := '...';
  Results.Add(Searchresult);

  // ...
end;

Und ein Aufruf dann so:

Delphi-Quellcode:

var
  SearchProvider: TSearchProvider;
  i: integer;
begin
  SearchProvider := TGoogle.Create;
//  SearchProvider := THeise.Create;
//  SearchProvider := TGulli.Create;
  SearchProvider.Query := 'delphi forum';
  SearchProvider.Submit;
  for i := 0 to SearchProvider.Results.Count -1 do
  begin
    WriteLn(Format('Titel: %s;    Link: %s', 
      [SearchProvider.Results[i].Title, 
       SearchProvider.Results[i].Link]));
  end;
  SearchProvider.Free;
end;

Nach dem Schema von TGoogle kannst du dir auch für alle anderen Seiten entsprechende Suchprovider erstellen.

Bitte beachte: Dieser Code wurde im Beitragseditor getippt und enthält sicher ein paar Fehlerchen - macht aber auch nix, schließlich geht es eher um die grobe Struktur.

[edit]

Zitat von ChEeTaH:

Edit: Wäre das hier eine Implementation?

Da es in großen Lettern in der Überschrift steht, wäre das anzunehmen, ja
[/edit]