delphi - tanteo - ¿Cómo hacer una iteración de soporte de interfaz correctamente?

resolver ecuaciones con solver excel

Question

¿Cómo puedo exponer este TList de una interfaz, como IEnumerator o IEnumerator<IFungibleTroll> ? Estoy usando Delphi XE.

Aquí está lo lejos que conseguí:

unit FungibleTrollUnit;
interface
uses
Windows, Messages, SysUtils,
Variants, Classes, Graphics,
Controls, Forms,
Generics.Collections;
type
IFungibleTroll = interface
[''{03536137-E3F7-4F9B-B1F5-2C8010A4D019}'']
function GetTrollName:String;
function GetTrollRetailPrice:Double;
end;
TFungibleTrolls = class (TInterfacedObject,IEnumerable<IFungibleTroll>)
protected
FTrolls:TList<IFungibleTroll>;
public
// IEnumerable
function GetEnumerator:IEnumerator<IFungibleTroll>;//
// function GetEnumerator:IEnumerator; overload;
// find/search app feature requires searching.
// this
function FindSingleItemByName(aName:String;patternMatch:Boolean):IFungibleTroll;
function FindMultipleItemsByName(aName:String;patternMatch:Boolean):IEnumerable<IFungibleTroll>;
function FindSingleItemByIdentifier(anIdentifer:String):IFungibleTroll;// use internal non-visible identifier to find an app.
constructor Create;
property Trolls:TList<IFungibleTroll> read FTrolls; // implements IEnumerable<IFungibleTroll>;??
private
end;
implementation
{ TFungibleTrolls }
constructor TFungibleTrolls.Create;
begin
FTrolls := TList<IFungibleTroll>.Create;
end;
function TFungibleTrolls.FindMultipleItemsByName(aName: String;
patternMatch: Boolean): IEnumerable<IFungibleTroll>;
begin
end;
function TFungibleTrolls.FindSingleItemByIdentifier(
anIdentifer: String): IFungibleTroll;
begin
end;
function TFungibleTrolls.FindSingleItemByName(aName: String;
patternMatch: Boolean): IFungibleTroll;
begin
end;
function TFungibleTrolls.GetEnumerator: IEnumerator<IFungibleTroll>;
begin
result := FTrolls.GetEnumerator;
end;
//function TFungibleTrolls.GetEnumerator: IEnumerator;
//begin
// result := FTrolls.GetEnumerator; // type IEnumerator<IFungibleTroll> or IEnumerator?
//end;
end.

Me quedo atascado en uno de los tres errores que no logro resolver:

[DCC Error] FungibleTrollUnit.pas(26): E2252 Method ''GetEnumerator'' with identical parameters already exists -o--

[DCC Error] FungibleTrollUnit.pas(19): E2291 Missing implementation of interface method IEnumerable.GetEnumerator -o-- [DCC Error] FungibleTrollUnit.pas(19): E2291 Missing implementation of interface method IEnumerable.GetEnumerator

Parece que debo declarar dos formas de GetEnumerator, si declaro TFungibleTrolls para implementar IEnumerable, pero parece que no puedo encontrar la manera de hacerlo, ya sea con sobrecargas, o sin sobrecargas, o usando una "cláusula de resolución de método", como esta:

 function IEnumerable.GetEnumerator = GetPlainEnumerator; // method resolution clause needed?
function GetEnumerator:IEnumerator<IFungibleTroll>;
function GetPlainEnumerator:IEnumerator;

Esto probablemente parezca un uso bastante básico de IEnumerable, y hacer una iteración de soporte de la Interfaz, y sin embargo, estoy atascado.

Actualización: parece que cuando trato de hacer esto sin declarar primero una List<T> , estoy cayendo en una grieta causada por el hecho de que IEnumerable<T> hereda de IEnumerable , y aún así, en vez de un solo método get enumerator, mi la clase debe proporcionar varias y, como mi clase no es genérica, no puede "asignarse a sí misma" a los requisitos de IEnumerable directamente a menos que use una declaración genérica de la List<T> . El ejemplo de Marjan funciona cuando se compila en un proyecto (.dproj + .dpr) pero no cuando se integra en un paquete (.dproj + .dpk) y se compila en el IDE. Funciona bien desde la línea de comandos, en un paquete, pero no en el IDE, en un paquete.

Answer 1

No es una respuesta a su pregunta directamente (sigue trabajando en eso), pero esto es lo que hice para obtener un "enumerador interconectado", es decir, una clase interconectada que admite la iteración:

IList<T> = interface(IInterface)
[...]
function GetEnumerator: TList<T>.TEnumerator;
function Add(const Value: T): Integer;
end;
type
TBjmInterfacedList<T> = class(TBjmInterfacedObject, IList<T>)
strict private
FList: TList<T>;
function GetEnumerator: TList<T>.TEnumerator;
strict protected
function Add(const Value: T): Integer;
public
constructor Create; override;
destructor Destroy; override;
end;
implementation
constructor TBjmInterfacedList<T>.Create;
begin
inherited;
FList := TList<T>.Create;
end;
destructor TBjmInterfacedList<T>.Destroy;
begin
FreeAndNil(FList);
inherited;
end;
function TBjmInterfacedList<T>.GetEnumerator: TList<T>.TEnumerator;
begin
Result := FList.GetEnumerator;
end;
function TBjmInterfacedList<T>.Add(const Value: T): Integer;
begin
Result := FList.Add(Value);
end;

Y luego puedes hacer cosas como estas:

ISite = interface(IInterface)
...
end;
ISites = interface(IList<ISite>);
...
end;
var
for Site in Sites do begin
...
end;

con implementar clases como:

TSite = class(TBjmInterfacedObject, ISite)
...
end;
TSites = class(TBjmInterfacedList<ISite>, ISites)
...
end;

Actualizar

Ejemplo de fuente del proyecto cargada en http://www.bjmsoftware.com/delphistuff//interfacedlist.zip

Answer 2

Si realmente desea crear una clase que implemente IEnumerable <T>, puede hacerlo así:

unit uGenericEnumerable;
interface
uses SysUtils, Classes, Generics.Collections;
type TGenericEnumerator<T> = class(TInterfacedObject, IEnumerator, IEnumerator<T>)
private
FList: TList<T>;
FIndex: Integer;
protected
function GenericGetCurrent: T;
public
constructor Create(AList: TList<T>);
procedure Reset;
function MoveNext: Boolean;
function GetCurrent: TObject;
function IEnumerator<T>.GetCurrent = GenericGetCurrent;
property Current: T read GenericGetCurrent;
end;
type TNonGenericEnumerable = class(TInterfacedObject, IEnumerable)
protected
function GetNonGenericEnumerator: IEnumerator; virtual; abstract;
public
function IEnumerable.GetEnumerator = GetNonGenericEnumerator;
end;
type TGenericEnumerable<T> = class(TNonGenericEnumerable, IEnumerable<T>)
private
FList: TList<T>;
public
constructor Create;
destructor Destroy; override;
function GetNonGenericEnumerator: IEnumerator; override;
function GetEnumerator: IEnumerator<T>;
property List: TList<T> read FList;
end;
implementation
{ TGenericEnumerator<T> }
constructor TGenericEnumerator<T>.Create(AList: TList<T>);
begin
inherited Create;
FList := AList;
FIndex := -1;
end;
procedure TGenericEnumerator<T>.Reset;
begin
FIndex := -1;
end;
function TGenericEnumerator<T>.MoveNext: Boolean;
begin
if FIndex < FList.Count then
begin
Inc(FIndex);
Result := FIndex < FList.Count;
end
else
begin
Result := False;
end;
end;
function TGenericEnumerator<T>.GenericGetCurrent: T;
begin
Result := FList[FIndex];
end;
function TGenericEnumerator<T>.GetCurrent: TObject;
begin
// If T has not been constrained to being a class, raise an exception instead of trying to return an object.
raise Exception.Create(''Cannot use this as a non-generic enumerator'');
// If T has been constrained to being a class, return GenericGetCurrent.
// Result := GenericGetCurrent;
end;
{ TGenericEnumerable<T> }
constructor TGenericEnumerable<T>.Create;
begin
inherited Create;
FList := TList<T>.Create;
end;
destructor TGenericEnumerable<T>.Destroy;
begin
FList.Free;
end;
function TGenericEnumerable<T>.GetEnumerator: IEnumerator<T>;
begin
Result := TGenericEnumerator<T>.Create(FList);
end;
function TGenericEnumerable<T>.GetNonGenericEnumerator: IEnumerator;
begin
Result := GetEnumerator;
end;
end.

Ahora, tu FungibleTrollUnit tendrá un aspecto similar a este:

unit FungibleTrollUnit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics,
Controls, Forms, Generics.Collections,
uGenericEnumerable;
type
IFungibleTroll = interface
[''{03536137-E3F7-4F9B-B1F5-2C8010A4D019}'']
function GetTrollName:String;
function GetTrollRetailPrice:Double;
end;
IFungibleTrolls = interface(IEnumerable<IFungibleTroll>)
[''{090B45FB-2925-4BFC-AE97-5D3F54E1C575}'']
function GetTrolls: TList<IFungibleTroll>;
function FindSingleItemByName(aName:String):IFungibleTroll;
function FindMultipleItemsByName(aName:String):IEnumerable<IFungibleTroll>;
property Trolls:TList<IFungibleTroll> read GetTrolls;
end;
TFungibleTrolls = class (TGenericEnumerable<IFungibleTroll>, IFungibleTrolls, IEnumerable<IFungibleTroll>)
public
function GetTrolls: TList<IFungibleTroll>;
function FindSingleItemByName(aName: String): IFungibleTroll;
function FindMultipleItemsByName(aName: String): IEnumerable<IFungibleTroll>;
property Trolls:TList<IFungibleTroll> read GetTrolls;
private
end;
implementation
uses StrUtils;
{ TFungibleTrolls }
function TFungibleTrolls.GetTrolls: TList<IFungibleTroll>;
begin
Result := List;
end;
function TFungibleTrolls.FindMultipleItemsByName(aName: String): IEnumerable<IFungibleTroll>;
var FilteredTrolls: TGenericEnumerable<IFungibleTroll>;
var Troll: IFungibleTroll;
begin
FilteredTrolls := TGenericEnumerable<IFungibleTroll>.Create;
for Troll in List do
begin
if Troll.GetTrollName = aName then
FilteredTrolls.List.Add(Troll);
end;
Result := IEnumerable<IFungibleTroll>(FilteredTrolls);
end;
function TFungibleTrolls.FindSingleItemByName(aName: String): IFungibleTroll;
var Troll: IFungibleTroll;
begin
Result := nil;
for Troll in List do
begin
if Troll.GetTrollName = aName then
Result := Troll;
break;
end;
end;
end.

Tenga en cuenta que la implementación de IEnumerable no funciona, pero IEnumerable <T> sí funciona.
Esto se debe a que, a menos que T esté restringido, no puede convertir una T en un TObject.
Si T es una cadena o un entero, por ejemplo, entonces IEnumerator no tiene un TObject para devolver.

Si T tiene restricciones para ser una clase, puede lograr que la implementación de IEnumerable funcione.
Si constriñes que T sea una interfaz intrasectorial, podría hacer que IEnumerable funcione (Delphi 2010 y después (convertir GenericGetCurrent en una interfaz secundaria, luego en un TObject), pero dudo que sea una ventaja.

Prefiero usarlo sin las restricciones, y lo hago sin poder iterar todo como TObjects.

TGenericEnumerable <T> .GetEnumerator no puede usar FList.GetEnumerator porque TList <T> .GetEnumerator no devuelve un IEnumerator <T>

Aunque puede implementar TGenericEnumerable <T> sin definir TNonGenericEnumerable, así:

type TGenericEnumerable<T> = class(TInterfacedObject, IEnumerable, IEnumerable<T>)
private
FList: TList<T>;
protected
function GenericGetEnumerator: IEnumerator<T>;
public
constructor Create;
destructor Destroy; override;
function GetEnumerator: IEnumerator;
function IEnumerable<T>.GetEnumerator = GenericGetEnumerator;
property List: TList<T> read FList;
end;

la desventaja de hacer esto es que si intenta iterar utilizando el objeto TGenericEnumerable <T>, en lugar de la interfaz, GetEnumerator no será genérico y solo podrá iterar TObjects.

Advertencias habituales sobre la mezcla de referencias a una interfaz y su objeto subyacente. Si se refiere a un objeto como un tipo de objeto y como un IEnumerable <....>, cuando el recuento de referencia de la interfaz vuelve a cero, el objeto se liberará incluso si todavía tiene una referencia como objeto . (Es por eso que definí IFungibleTrolls, para poder referirme a la colección como una interfaz).

Puede realizar implementaciones alternativas de TGenericEnumerator <T>; por ejemplo, podría contener una referencia a una lista, un índice y un predicado de selección, que se suministran todos en el constructor.