Record uguaglianza in collezioni generici

Question

Si supponga di avere un record con un operatore di uguaglianza sovraccaricato

TSomeRecord = record 
    Value : String; 
    class operator Equal(Left, Right : TSomeRecord) : Boolean; 
end; 

(implementazione confronta i valori di stringa). Se si aggiungono due record all'elenco che sono uguali in base all'operatore sovraccarico, mi aspetto che il metodo Contains restituisca true in entrambi i casi. In realtà, l'elenco generico sembra semplicemente confrontare il contenuto di memoria dei record anziché applicare l'operatore di uguaglianza sovraccarico.

var 
    List : TList <TSomeRecord>; 
    Record1, 
    Record2 : TSomeRecord; 

begin 
Record1.Value := 'ABC'; 
Record2.Value := 'ABC'; 
List.Add(Record1); 

Assert(List.Contains(Record1)); 
Assert(List.Contains(Record2)); // <--- this is not true 
end; 

È questo il comportamento previsto? Qualche spiegazione?

Answer 1

Supponendo che non sia stato specificato un confronto nel costruttore su TList.Create, si otterrà TComparer<TSomeRecord>.Default come comparatore. E questo è un comparatore che esegue un semplice confronto binario usando CompareMem.

Questo va bene per un record pieno di tipi di valore, senza padding. In caso contrario, dovrai fornire la tua funzione di confronto quando installi l'elenco.

Se si desidera esaminare i dettagli, il confronto predefinito per i record è implementato in Generics.Defaults. Per i record più grandi il confronto di uguaglianza è questa funzione:

function Equals_Binary(Inst: PSimpleInstance; const Left, Right): Boolean; 
begin 
    Result := CompareMem(@Left, @Right, Inst^.Size); 
end; 

per i record più piccoli c'è un'ottimizzazione e il vostro operatore di confronto sarà l'operatore di confronto 4 byte. Che assomiglia a questo:

function Equals_I4(Inst: Pointer; const Left, Right: Integer): Boolean; 
begin 
    Result := Left = Right; 
end; 

Questo è un po 'strano, ma interpreta i 4 byte di vostro record come un intero 4 byte ed esegue confronto di uguaglianza intero. In altre parole, lo stesso di CompareMem, ma più efficiente.

L'operatore di confronto che si desidera utilizzare potrebbe essere simile a questo:

TComparer<TSomeRecord>.Construct(
    function const Left, Right: TSomeRecord): Integer 
    begin 
    Result := CompareStr(Left.Value, Right.Value); 
    end; 
) 

Usa CompareText se si vuole case insensitive, e così via. Ho usato una funzione di confronto ordinata perché è ciò che vuole TList<T>.

Il fatto che il confronto dei record predefinito sia un confronto di uguaglianza indica che i tentativi di ordinare elenchi di record senza specificare il proprio comparatore avranno risultati imprevisti.

Dato che l'operatore di confronto di default utilizza un confronto di uguaglianza ti dice che non sarebbe del tutto irragionevole utilizzare un operatore di confronto come questo:

TComparer<TSomeRecord>.Construct(
    function const Left, Right: TSomeRecord): Integer 
    begin 
    Result := ord(not (Left = Right)); 
    end; 
) 

Questo andrà bene per le operazioni non ordinate come IndexOf o Contains ma ovviamente non utilizzare affatto per l'ordinamento, la ricerca binaria e così via.

Answer 2

Per ottenere il comportamento previsto, è necessario creare l'elenco con un comparatore.

In questo caso si consiglia di utilizzare

List := TList<TSomeRecord>.Create(TComparer<TSomeRecord>.Construct(
    function (const L, R : TSomeRecord) : Integer 
    begin 
    Result := CompareStr(L.Value, R.Value); 
    end));