Полезное для программистов:

Фриланс
Новости
Статьи
   
Рубрики:


Теория и практика использования RTTI

Поиск:
Delphi — это мощная среда визуальной разработки программ сочетающая в себе весьма простой и эффективный язык программирования, удивительный по быстроте компилятор и подкупающую открытость (в состав Delphi входят исходные тексты стандартных модулей и практически всех компонент библиотеки VCL). Однако, как и на солнце, так и в Delphi существуют пятна (на солнце черные, а в Delphi — белые), пятна недокументированных (или почти не документированных) возможностей. Одно из таких пятен — это информация о типах времени исполнения и методы работы с ней.

Информация о типах времени исполнения.(Runtime Type Information, RTTI) —это данные, генерируемые компилятором Delphi о большинстве объектов вашей программы. RTTI представляет собой возможность языка, обеспечивающее приложение информацией об объектах (его имя, размер экземпляра, указатели на класс-предок, имя класса и т. д.) и о простых типах во время работы программы. Сама среда разработки использует RTTI для доступа к значениям свойств компонент, сохраняемых и считываемых из dfm-файлов и для отображения их в Object Inspector,

Компилятор Delphi генерирует runtime информацию для простых типов, используемых в программе, автоматически. Для объектов, RTTI информация генерируется компилятором для свойств и методов, описанных в секции published в следующих случаях:

Объект унаследован от объекта, дня которого генерируется такая информация. В качестве примера можно назвать объект TPersistent.

Декларация класса обрамлена директивами компилятора {$M+} и {$M-}.

Необходимо отметить, что published свойства ограничены по типу данных. Они могут быть перечисляемым типом, строковым типом, классом, интерфейсом или событием (указатель на метод класса). Также могут использоваться множества (set), если верхний и нижний пределы их базового типа имеют порядковые значения между 0 и 31 (иначе говоря, множество должно помещаться в байте, слове или двойном слове). Также можно иметь published свойство любого из вещественных типов (за исключением Real48). Свойство-массив не может быть published. Все методы могут быть published, но класс не может иметь два или более перегруженных метода с одинаковыми именами. Члены класса могут быть published, только если они являются классом или интерфейсом.

Корневой базовый класс для всех VCL объектов и компонент, TObject, содержит ряд методов для работы с runtime информацией. Наиболее часто используемые из них приведены в таблице 1.

Наиболее часто используемые методы класса TObject для работы с RTTI

Метод Описание
ClassType Возвращает тип класса объекта. Вызывается неявно компилятором при определении типа объекта при использовании операторов is и as
ClassName Возвращает строку, содержащую название класса объекта. Например, для объекта типа TForm вызов этой функции вернет строку "TForm"
ClassInfo Возвращает указатель на runtime информацию объекта
InstanceSize Возвращает размер конкретного экземпляра объекта в байтах.
Object Pascal предоставляет в распоряжение программиста два оператора, работа которых основана на неявном для программиста использовании RTTI информации. Это операторы is и as. Оператор is предназначен для проверки соответствия экземпляра объекта заданному объектному типу. Так, выражение вида:

Код
AObject is TSomeObjectType


является истинным в том случае, если объект AObject является экземпляром класса TSomeObjectType или одного из порожденных от него классов. Следует отметить, что определенная проверка происходит еще на этапе компиляции программы. если фактические объект и класс несовместимы, компилятор выдаст ошибку в этом операторе. Так, следующий программный код

Код
if Edit1 is TForm then  
 ShowMessage('Враки!');


даже не будет пропущен компилятором, и он выдаст сообщение о не совместимости типов (разумеется, что Edit1 — это компонент типа TEdit):

Цитата
Incompatible types: 'TForm' and 'TEdit'.


Перейдем теперь к оператору as. Он введен в язык специально для приведения объектных типов. Посредством него можно рассматривать экземпляр объекта как принадлежащий к другому совместимому типу:

Код
AObject as TSomeObjectType


Использование оператора as отличается от обычного способа приведения типов

Код
TSomeObjectType(AObject)


наличием проверки на совместимость типов. Так при попытке приведения этого оператора с несовместимым типом он сгенерирует исключение EInvalidCast. Определенным недостатком операторов is и as является то, что присваиваемый фактически тип должен быть известен на этапе компиляции программы и поэтому на месте TSomeObjectType не может стоять переменная указателя на класс.

Для иллюстрации только что написанного рассмотрим небольшой пример. Предположим у вас на форме имеется ряд компонент типа TEdit, и вы хотите реализовать их очистку их свойств перед созданием формы. С применением RTTI это можно сделать следующим программным кодом:

Код
var
 I: Integer;
begin
 for I := 0 to ComponentCount - 1 do
   if Components[I] is TEdit then
     (Components[I] as TEdit).Text := '';
     { или так TEdit (Components[I]).Text := ''; }
end;


Хочу обратить ваше внимание, а то, что стандартное приведение типа в данном примере предпочтительнее, поскольку в операторе if мы уже установили что компонент является объектом нужного нам типа и дополнительная проверка соответствия типов, проводимая оператором as, нам уже не нужна.

Первые шаги в понимании RTTI мы уже сделали. Теперь переходим к подробностям. Все основополагающие определения типов, основные функции и процедуры для работы с runtime информацией находятся в модуле TypInfo. Этот модуль содержит две фундаментальные структуры для работы с RTTI — TTypeInfo и TTypeData (типы указателей на них — PTypeInfo и PTypeData соответственно). Суть работы с RTTI выглядит следующим образом. Получаем указатель на структуру типа TTypeInfo (для объектов указатель можно получить, вызвав метод, реализованный в TObject, ClassInfo, а для простых типов в модуле System существует функция TypeInfo). Затем, посредством имеющегося указателя и вызова функции GetTypeData получаем указатель на структуру типа TTypeData. Далее используя оба указателя и функции модуля TypInfo творим маленькие чудеса. Для пояснения написанного выше рассмотрим пример получения текстового вида значений перечисляемого типа. Пусть, например, это будет тип TBrushStyle. Этот тип описан в модуле Graphics следующим образом:

Код
TBrushStyle = (bsSolid, bsClear, bsHorizontal, bsVertical,  
 bsFDiagonal, bsBDiagonal, bsCross, bsDiagCross);


Вот мы и попробуем получить конкретные значения этого типа в виде текстовых строк. Для этого создайте пустую форму. Поместите на нее компонент типа TListBox с именем ListBox1 и кнопку. Реализацию события OnClick кнопки замените следующим кодом:

Код
var
 ATypeInfo: PTypeInfo;
 ATypeData: PTypeData;
 I: Integer;
 S: string;
begin
 ATypeInfo := TypeInfo(TBrushStyle);
 ATypeData := GetTypeData(ATypeInfo);
 for I := ATypeData.MinValue to ATypeData.MaxValue do
 begin
   S := GetEnumName(ATypeInfo, I);
   ListBox1.Items.Add(S);
 end;
end;


Ну вот, теперь, когда на вооружении у нас есть базовые знания о противнике, чье имя, на первый взгляд выглядит непонятно и пугающее — RTTI настало время большого примера. Мы приступаем к созданию объекта опций для хранения различных параметров, использующего в своей работе мощь RTTI на полную катушку. Чем же примечателен, будет наш будущий класс? А тем, что он реализует сохранение в ini-файл и считывание из него свои свойства секции published. Его потомки будут иметь способность сохранять свойства, объявленные в секции published, и считывать их, не имея для этого никакой собственной реализации. Надо лишь создать свойство, а все остальное сделает наш базовый класс. Сохранение свойств организуется при уничтожении объекта (т.е. при вызове деструктора класса), а считывание и инициализация происходит при вызове конструктора класса. Декларация нашего класса имеет следующий вид:

Код
{$M+}
TOptions = class(TObject)
 protected
   FIniFile: TIniFile;
   function Section: string;
   procedure SaveProps;
   procedure ReadProps;
 public
   constructor Create(const FileName: string);
   destructor Destroy; override;
end;
{$M-}


Класс TOptions является производным от TObject и по этому, что бы компилятор генерировал runtime информацию его надо объявлять директивами {$M+/-}. Декларация класса весьма проста и вызвать затруднений в понимании не должна. Теперь переходим к реализации методов.

Код
constructor TOptions.Create(const FileName: string);
begin
 FIniFile:=TIniFile.Create(FileName);
 ReadProps;
end;

destructor TOptions.Destroy;
begin
 SaveProps;
 FIniFile.Free;
 inherited Destroy;
end;


Как видно реализация конструктора и деструктора тривиальна. В конструкторе мы создаем объект для работы с ini-файлом и организуем считывание свойств. В деструкторе мы в сохраняем значения свойств в файл и уничтожаем файловый объект. Всю нагрузку по реализации сохранения и считывания published-свойств несут методы SaveProps и ReadProps соответственно.

Код
procedure TOptions.SaveProps;
var
 I, N: Integer;
 TypeData: PTypeData;
 List: PPropList;
begin
 TypeData:= GetTypeData(ClassInfo);
 N:= TypeData.PropCount;
 if N <= 0 then
   Exit;
 GetMem(List, SizeOf(PPropInfo)*N);
 try
   GetPropInfos(ClassInfo,List);
   for I:= 0 to N - 1 do
     case List[I].PropType^.Kind of
       tkEnumeration, tkInteger:
         FIniFile.WriteInteger(Section, List[I]^.name,GetOrdProp(Self,List[I]));
       tkFloat:
         FIniFile.WriteFloat(Section, List[I]^.name, GetFloatProp(Self, List[I]));
       tkString, tkLString, tkWString:
         FIniFile.WriteString(Section, List[I]^.name, GetStrProp(Self, List[I]));
     end;
 finally
   FreeMem(List,SizeOf(PPropInfo)*N);
 end;
end;


procedure TOptions.ReadProps;
var
 I, N: Integer;
 TypeData: PTypeData;
 List: PPropList;
 AInt: Integer;
 AFloat: Double;
 AStr: string;
begin
 TypeData:= GetTypeData(ClassInfo);
 N:= TypeData.PropCount;
 if N <= 0 then
   Exit;
 GetMem(List, SizeOf(PPropInfo)*N);
 try
   GetPropInfos(ClassInfo, List);
   for I:= 0 to N - 1 do
     case List[I].PropType^.Kind of
       tkEnumeration, tkInteger:
       begin
         AInt:= GetOrdProp(Self, List[I]);
         AInt:= FIniFile.ReadInteger(Section, List[I]^.name, AInt);
         SetOrdProp(Self, List[i], AInt);
       end;
       tkFloat:
       begin
         AFloat:=GetFloatProp(Self,List[i]);
         AFloat:=FIniFile.ReadFloat(Section, List[I]^.name,AFloat);
         SetFloatProp(Self,List[i],AFloat);
       end;
       tkString, tkLString, tkWString:
       begin
         AStr:= GetStrProp(Self,List[i]);
         AStr:= FIniFile.ReadString(Section, List[I]^.name, AStr);
         SetStrProp(Self,List[i], AStr);
       end;
     end;
 finally
   FreeMem(List,SizeOf(PPropInfo)*N);
 end;
end;

function TOptions.Section: string;
begin
 Result := ClassName;
end;


Теперь, для проверки работоспособности, и отладки объекта опций создадим новое приложение и подключим к нему модуль, в котором описан и реализован объект TOptions. Ниже приведен программный код, иллюстрирующий создание наследника от класса TOptions и его использования в главной (и единственной) форме нашего тестового приложения интерфейсная часть выглядит так:

Код
TMainOpt = class(TOptions)
 private
   FText: string;
   FHeight: Integer;
   FTop: Integer;
   FWidth: Integer;
   FLeft: Integer;
   procedure SetText(const Value: string);
   procedure SetHeight(Value: Integer);
   procedure SetLeft(Value: Integer);
   procedure SetTop(Value: Integer);
   procedure SetWidth(Value: Integer);
 published
   property Text: string read FText write SetText;
   property Left: Integer read FLeft write SetLeft;
   property Top: Integer read FTop write SetTop;
   property Width: Integer read FWidth write SetWidth;
   property Height: Integer read FHeight write SetHeight;
end;

TForm1 = class(TForm)
   Edit1: TEdit;
   procedure Edit1Change(Sender: TObject);
 private
   FMainOpt: TMainOpt;
 public
   constructor Create(AOwner: TComponent); override;
   destructor Destroy; override;
end;


А вот и реализация:

Код
constructor TForm1.Create(AOwner: TComponent);
var
 S: string;
begin
 inherited Create(AOwner);
 S := ChangeFileExt(Application.ExeName, '.ini');
 FMainOpt := TMainOpt.Create(S);
 Edit1.Text := FMainOpt.Text;

 Left := FMainOpt.Left;
 Top := FMainOpt.Top;
 Width := FMainOpt.Width;
 Height := FMainOpt.Height;
end;

destructor TForm1.Destroy;
begin
 FMainOpt.Left := Left;
 FMainOpt.Top := Top;
 FMainOpt.Width := Width;
 FMainOpt.Height := Height;
 FMainOpt.Free;
 inherited Destroy;
end;

{ TMainOpt }

procedure TMainOpt.SetText(const Value: string);
begin
 FText := Value;
end;

procedure TForm1.Edit1Change(Sender: TObject);
begin
 FMainOpt.Text := Edit1.Text;
end;

procedure TMainOpt.SetHeight(Value: Integer);
begin
 FHeight := Value;
end;

procedure TMainOpt.SetLeft(Value: Integer);
begin
 FLeft := Value;
end;

procedure TMainOpt.SetTop(Value: Integer);
begin
 FTop := Value;
end;

procedure TMainOpt.SetWidth(Value: Integer);
begin
 FWidth := Value;
end;


В заключение своей статьи хочу сказать, что RTTI является недокументированной возможностью Object Pascal и поэтому информации на эту тему в справочной системе и электронной документации весьма мало. Наиболее легкодоступный способ изучить более подробно эту фишку — просмотр и изучение исходного текста модуля TypInfo.
Автор: delphiworld
Сайт: www.delphiworld.narod.ru






Просмотров: 12361

 

 

Новые статьи:


Популярные:
  1. Как сделать цикличным проигрывание MIDI-файла?
  2. Создание AVI файла из рисунков
  3. Как устройство "отключить в данной конфигурации"?
  4. Kто в данный момент присоединен через Сеть?
  5. Как узнать количество доступной памяти?
  6. Как реализовать в RichEdit разноцветный текст?
  7. Как скрыть свое приложение от ProcessViewer
  8. Как программно нажать/скрыть/показ кнопку "Start"?
  9. Модуль работы с ресурсами в PE файлах
10. Функции вызова диалоговых окон выбора
11. Проверка граматики средствами Word'а из Delphi.
12. Модуль для упрощенного вызова сообщений
13. Функции для записи и чтение своих данных в, ЕХЕ- файле
14. Рекурсивный просмотр директорий
15. Network Traffic Monitor
16. Разные модули
17. Универсальная функция для обращения к любым экспортируем функциям DLL
18. Библиотека от VladS
19. Протектор для UPX'а
20. Еще об ICQ, сообщения по контакт листу?
21. Использование открытых интерфейсов
22. Теория и практика использования RTTI
23. Работа с TApplication
24. Примеры использования Drag and Drop для различных визуальных компонентов
25. Что такое порт? Правила для работы с портами
26. Симфония на клавиатуре
27. Загрузка DLL
28. Исправление автоинкремента
29. Взаимодействие с чужими окнами
30. Проверить дубляжи в столбце


 

 

 
 
На главную