type
  TEnumAliasesManager<T> = record
  strict private
    type
      TEnumValue = record
      case TOrdType of
        otSByte: (SByte: ShortInt);
        otUByte: (UByte: Byte);
        otSWord: (SWord: SmallInt);
        otUWord: (UWord: Word);
        otSLong: (SLong: Integer);
        otULong: (ULong: Cardinal);
      end;
      PEnumValue = ^TEnumValue;
  strict private
    class var
      FAliases: TArray<string>;
  strict private
    class procedure CheckRegistered; static;
    class procedure SizeError; static; inline;
    class function IndexOf(const AStr: string): Integer; static;
  public
    class procedure Register(const AAliases: array of string); static;
    class function EnumToString(const AVal: T): string; static;
    class function StringToEnum(const AVal: string): T; static;
  end;

  EEnumAliasesManagerError = class(Exception);

class procedure TEnumAliasesManager<T>.CheckRegistered;
begin
  if FAliases = nil then
    raise EEnumAliasesManagerError.Create('No aliases registered');
end;

class procedure TEnumAliasesManager<T>.SizeError;
begin
  raise EEnumAliasesManagerError.Create('Unknown enumeration size');
end;

class function TEnumAliasesManager<T>.IndexOf(const AStr: string): Integer;
begin
  for Result := 0 to Length(FAliases) - 1 do begin
    if AStr = FAliases[Result] then
      Exit;
  end;
  raise EEnumAliasesManagerError.CreateFmt('Alias "%s" not found', [AStr]);
end;

class procedure TEnumAliasesManager<T>.Register(
  const AAliases: array of string);
var
  LTypeInfo: PTypeInfo;
  LMinValue: Integer;
  LMaxValue: Integer;
  LLen: Integer;
begin
  LTypeInfo := TypeInfo(T);
  if LTypeInfo^.Kind <> tkEnumeration then
    raise EEnumAliasesManagerError.Create('Type must be Enumeration');
  if LTypeInfo^.Kind <> tkEnumeration then
    raise Exception.Create('Type must be Enumeration');
  LMinValue := LTypeInfo^.TypeData^.MinValue;
  if LMinValue < 0 then begin  // WordBool, LongBool etc
    LMinValue := 0;
    LMaxValue := 1
  end else
    LMaxValue := LTypeInfo^.TypeData^.MaxValue;

  LLen := Length(AAliases);
  if LMaxValue - LMinValue + 1 <> LLen then
    raise Exception.Create('Invalid aliases size');

  SetLength(FAliases, LLen);
  TArray.Copy<string>(AAliases, FAliases, LLen);
end;

class function TEnumAliasesManager<T>.EnumToString(const AVal: T): string;
var
  LTypeInfo: PTypeInfo;
  LEnumVal: PEnumValue;
begin
  CheckRegistered;
  LTypeInfo := TypeInfo(T);
  LEnumVal := @AVal;
  case LTypeInfo^.TypeData^.OrdType of
    otSByte: Result := FAliases[LEnumVal^.SByte];
    otUByte: Result := FAliases[LEnumVal^.UByte];
    otSWord: Result := FAliases[LEnumVal^.SWord];
    otUWord: Result := FAliases[LEnumVal^.UWord];
    otSLong: Result := FAliases[LEnumVal^.SLong];
    otULong: Result := FAliases[LEnumVal^.ULong];
  else
    SizeError;
  end;
end;

class function TEnumAliasesManager<T>.StringToEnum(const AVal: string): T;
var
  LTypeInfo: PTypeInfo;
  LEnumVal: PEnumValue;
  LIdx: Integer;
begin
  CheckRegistered;
  LIdx := IndexOf(AVal);
  LTypeInfo := TypeInfo(T);
  LEnumVal := @Result;
  case LTypeInfo^.TypeData^.OrdType of
    otSByte: LEnumVal^.SByte := LIdx;
    otUByte: LEnumVal^.UByte := LIdx;
    otSWord: LEnumVal^.SWord := LIdx;
    otUWord: LEnumVal^.UWord := LIdx;
    otSLong: LEnumVal^.SLong := LIdx;
    otULong: LEnumVal^.ULong := LIdx;
  else
    SizeError;
  end;
end;

type
  TTestEnum1 = (en11, en12);
  TTestEnum2 = (en21, en22, en23);

procedure TForm1.Button1Click(Sender: TObject);
var
  LStr: string;
  LEn1: TTestEnum1;
  LEn2: TTestEnum2;
begin
  TEnumAliasesManager<TTestEnum1>.Register(['a', 'b']);
  TEnumAliasesManager<TTestEnum2>.Register(['x', 'y', 'z']);
  LStr := TEnumAliasesManager<TTestEnum1>.EnumToString(en12);
  LStr := TEnumAliasesManager<TTestEnum2>.EnumToString(en23);
  LEn1 := TEnumAliasesManager<TTestEnum1>.StringToEnum('b');
  LEn2 := TEnumAliasesManager<TTestEnum2>.StringToEnum('z');
end;

interface

type
  TClass1<T> = class
  strict private
    class constructor Create;
  public
    class procedure Method; static;
  end;

  TClass2 = class
  strict private
    class constructor Create;
  end;

implementation

class constructor TClass1<T>.Create;
begin
  ShowMessage(ClassName + '.Create');
end;

class procedure TClass1<T>.Method; 
begin
  ShowMessage(ClassName + '.Method');
end;

class constructor TClass2.Create;
begin
  ShowMessage(ClassName + '.Create');
  TClass1<Byte>.Method;
end;