Iterar a través de elementos en una enumeración en Delphi

enums

Question

Quiero iterar a través de los elementos en una enumeración.

Me gustaría poder decir algo como esto:

type
TWeekdays = (wdMonday, wdTuesday, wdWednesday, wdThursday, wdFriday);
...
elementCount := GetElementCount(TypeInfo(TWeekDays));
for i := 0 to elementCount - 1 do begin
ShowMessage(GetEnumName(TypeInfo(TWeekdays),i));
end;

Lo más cerca que he podido venir es esto:

function MaxEnum(EnumInfo: PTypeInfo): integer;
const
c_MaxInt = 9999999;
var
i: integer;
s: string;
begin
//get # of enum elements by looping thru the names
//until we get to the end.
for i := 0 to c_MaxInt do begin
s := Trim(GetEnumName(EnumInfo,i));
if 0 = Length(s) then begin
Result := i-1;
Break;
end;
end;
end;

Que utilizo así:

procedure TForm1.BitBtn1Click(Sender: TObject);
var
i, nMax: integer;
begin
ListBox1.Clear;
nMax := MaxEnum(TypeInfo(TWeekdays));
for i := 0 to nMax do begin
ListBox1.Items.Add(GetEnumName(TypeInfo(TWeekdays),i));
end;
end;

Eso funciona bien, excepto que la lista que recibo se parece a esto (observe los últimos dos artículos):

wdMonday
wdTuesday
wdWednesday
wdThursday
wdFriday
Unit1
''@''#0''ôÑE''#0#0#0#0#0#0#0#0#0#0#0#0#0 <more garbage characters>

Los dos elementos al final obviamente no son lo que quiero.

¿Hay una mejor manera de iterar a través de los elementos de un tipo enumerado?

De no ser así, ¿es seguro asumir que siempre habrá exactamente dos elementos adicionales con mi método actual? Obviamente, uno es el nombre de la unidad ... pero ¿qué hace el símbolo "@"? ¿Es realmente basura, o es más información de tipo?

Estoy usando Delphi 2007. Gracias por cualquier información.

Answer 1

Es bastante más complejo que eso, cuando se usan enumeraciones especiales ... veamos una solución realmente funcional al 100% para una definición enumerada compleja:

type
TmyEnumType=(myEnumTypeA=5,myEnumTypeB=2,myEnumTypeC=9);
const
myEnumTypeOrder:Array[1..3] of TmyEnumType=(myEnumTypeA,myEnumTypeB,myEnumTypeC);
procedure TForm1.Button1Click(Sender: TObject);
var
myEnumTypeVariable:TmyEnumType;
begin
myEnumTypeVariable:=Low(TmyEnumType);
for myEnumTypeVariable in myEnumTypeOrder
do begin
ShowMessage(IntToStr(Ord(myEnumTypeVariable))); // Sample code to show enum integer value
// Extra code you neede
end;
end;
// This code shows three messages in this secuence: 5, 2, 9
// Correct number of elements and in the correct order

Notas:

• No todas las definiciones enumeradas deben comenzar con 0 y ser contiguas, se pueden definir como en la muestra
• Vea cómo se ha definido el tipo (no ordenado, no contiguo, etc.)
• Vea cómo se ha agregado una matriz constante con el orden correcto de los elementos.
• Debe iterar en dicha matriz ya que el orden se pierde y Succ y Pred no funcionan correctamente en ese tipo de enumeraciones

¿Por qué se ha hecho así ?:

• El orden enumerado debe conservarse y no es contiguo.
• Delphi cuando en esa muestra crea el tipo TmyEnumType asigna (9-2 + 1 = 8) elementos (de uno inferior (2) a uno superior (9), por lo que los valores válidos para dicho tipo son del ordinal 2 al ordinal 9
• Las funciones de Delphi Succ y Pred solo aumentan y disminuyen en uno, no comprueban la forma no contigua de definirlo, así que asigna valores que están fuera de alcance y también pierde el orden de definición

El truco:

• Declare una matriz constante contigua con elementos en el orden correcto
• Bucle en esa matriz constante

Si lo intentas con esta otra (forma humana de pensar lógica) no funcionará (no importa si se usa para bucle, bucle de tiempo, repita hasta, etc.):

type
TmyEnumType=(myEnumTypeA=5,myEnumTypeB=2,myEnumTypeC=9);
procedure TForm1.Button1Click(Sender: TObject);
var
myEnumTypeVariable:TmyEnumType;
begin
for myEnumTypeVariable:=Low(TmyEnumType) to High(TmyEnumType);
do begin
ShowMessage(IntToStr(Ord(myEnumTypeVariable))); // Sample code to show enum integer value
// Extra code you neede
end;
end;
// This code shows eight messages in this secuence: 2, 3, 4, 5, 6, 7, 8, 9
// Inorrect number of elements and in order is lost

Eso es lo que he probado por mi cuenta en Turbo Delphi 2006.

Answer 2

Hice un EnumerationEnumerator para que pudieras usarlo en la declaración ''for ... in'' en Delphi. Sin embargo, en ese entonces a veces generaría errores internos del compilador.

Editar:

Se las arregló para que funcione en Delphi 2007 en adelante, vea este artículo del blog (y la discusión bastante interesante debajo de él).

Answer 3

Puede usar Succ (x) y Pred (x) para recorrer una enumeración. ¡Pero recuerde verificar los límites para no probar Succ (x) en el último elemento de la enumeración!

Ejemplo:

type
TWeekdays = (wdMonday, wdTuesday, wdWednesday, wdThursday, wdFriday);
procedure Test;
var
val: TWeekdays;
begin
val := wdTuesday;
val := Succ(val); // wdWednesday
val := wdFriday;
val := Pred(val); // wdThursday,
end;

Answer 4

Sencillo:

type
TWeekdays = (wdMonday, wdTuesday, wdWednesday, wdThursday, wdFriday);
procedure Test;
var
el: TWeekdays;
begin
for el := Low(TWeekdays) to High(TWeekdays) do
; //
end;