[xaguilars]

Hola cHackAll, gracias por tu propuesta. No sé si he entendido mal pero propones utilizar un fichero con un header o cabezera... me parece interesante e igual después estudio como adaptarlo a mi caso. Ayer estuve mejorando mi estructura de datos y me ha quedado de la siguiente manera (en realidad el programa ya estaba funcionando, pero estoy reescribiendo el código porque he añadido la función de manejar álbums que antes no tenía. Era el proyecto final de 1º de FP de Admin de sistemas jeje, ahora tengo k empezar 2º y allí empezamos con las BDD). Bueno ahí va:

Código Delphi [-]
unit UEstructuras;

interface
uses classes, sysutils;

type
  {----------SONGS----------}
  TSong = packed record
  {EXTERNAL MP3 INFO}
    UID:Integer; {UNIQUE IDENTIFIER}
    Path, {MP3 FILENAME}
    Lyrics: string[255];  {TXT file PATH}
    Rate:byte; {NUMBER OF STARS}
    Favourite:Boolean;
    {ID3 Tags, INTERNAL MP3 INFO}
    Title,
    Artist,
    Album: string[255];
    Track: Byte;
    Year: string[4];
    Genre,
    Comments,
    Composer,
    Encoder,
    Copyright,
    Link,
    Language: string[255];
  end;

  TSongFile= File of TSong;

  PSongNode= ^TSongNode; {pointer to TSongNode}

  TSongNode = record
    Prev:PSongNode;
    ID:Integer;
    Info:TSong;
    Next:PSongNode;
  end;

  {----------ALBUMS----------}
  TAlbum = packed record
    UID:Integer; {UNIQUE IDENTIFIER}
    Name: string[255];
    Rate:byte; {NUMBER OF STARS}
    Image: string[255]; {Path of Image}
    Favourite:Boolean;
    Songs: String[255]; {ex.: 'UID:#157#158#159#160#7#2514#12477'}
  end;

  TAlbumFile= File of TAlbum;

  PAlbumNode= ^TAlbumNode; {pointer to TAlbumNode}

  TAlbumNode = record
    Prev:PAlbumNode;
    ID:Integer;
    Info:TAlbum;
    Next:PAlbumNode;
  end;

  {----------ARTISTS----------}
  TArtist = packed record
    UID:Integer; {UNIQUE IDENTIFIER}
    Name, {KEY IDENTIFIER, UNIQUE}
    Country,
    Language,
    Genre,
    Web,
    Comment,
    Albums: string [255]; {ex.: 'UID:#157#158#159#160#7#2514#12477'}
    Photos : array [0..13] of string [255];   {Path of each photo}
  end;

  TArtistFile= File of TArtist;

  PArtistNode= ^TArtistNode; {pointer to TArtistNode}

  TArtistNode = record
    Prev:PArtistNode;
    ID:Integer;
    Info:TArtist;
    Next:PArtistNode;
  end;

  TSearchMethod = (ID, UID, Path, Name);
 
{***********CLASSES***********}
  TSongs = class
     private
      Datapath:string;                              // Ruta al archivo de registros
      function UIDAssign: integer;                  // Asigna el primer número disponible que no se use a los campos UID
    public
      List:PSongNode;                                // Puntero a la lista de canciones
      Counter:Integer;                              // Contador de elementos de la lista
      constructor Create (Filename:string);          // Crea el objeto y llama a LoadDatabase
      procedure LoadDatabase;                        // Carga los registros en la lista de memoria
      procedure SaveDatabase;                        // Guarda la lista en el fichero de registros. Sobreescribe todo.
      function Add (Info: TSong):boolean;            // Añade un nodo, una canción
      function Delete (ID: Integer):boolean;        // Elimina una canción
      function IDReset : boolean;                    // Cuando por ejemplo se elimina un nodo, se reasignan los ID
      procedure DelBrokenLinks;                      // Si una canción no se encuentra en el PC, se da la opción de eliminar el registro
      function Search (Info:TSong; Option:TSearchMethod): PSongNode;  // Busca una canción en la lista dado un criterio de búsqueda
      procedure DropList;                            // Vacía la lista
      procedure FillStringList (Target: TStrings);  // Llena un TStrings con los elementos de la lista
      destructor Destroy; overload;                  // Guarda la lista en el fichero, destruye el objeto y la lista
  end;

  TAlbums = class
    private
      Datapath:string;
      function UIDAssign: integer;
    public
      List:PAlbumNode;
      Counter:integer;
      constructor Create (Filename:string);
      procedure LoadDatabase;
      procedure SaveDatabase;
      function Add (Info: TAlbum):boolean;
      function Delete (ID: Integer):boolean;
      function IDReset : boolean;
      function Search (Info:TAlbum; Option:TSearchMethod): PAlbumNode;
      procedure DropList;
      procedure FillStringList (Target: TStrings);
      destructor Destroy; overload;
  end;

  TArtists = class
    private
      Datapath:string;
      function UIDAssign: integer;
    public
      List:PArtistNode;
      Counter:integer;
      constructor Create (Filename:string);
      procedure LoadDatabase;
      procedure SaveDatabase;
      function Add (Info: TArtist):boolean;
      function Delete (ID: Integer):boolean;
      function DeleteByName (Name:String):boolean;
      function IDReset : boolean;
      function Search (Info:TArtist; Option:TSearchMethod): PArtistNode;
      procedure DropList;
      procedure FillStringList (Target: TStrings);
      destructor Destroy; overload;
  end;

Si os habéis fijado tengo algunos tipos y clases que sólo difieren del tipo de una variable o del tipo que recibe o devuelve un método. He probado de hacer una clase global y después subclases... pero sería lo mismo porque tendría que redefinir... ya que cada método de cada clase utiliza implementaciones distintas, aunque sea sólo cambiar un tipo. No sé hasta qué punto lo puedo simplificar todo.

Me gustaría aprender BDD en delphi, porque si yo supiera haría esto como BDD... pero no sé por donde empezar hay tantas cosas... qué me aconsejáis?

Ah se me olvidaba... si quiero salir de un bucle basta poner 'break;'?

Gracias gente.