Отправка сообщений делфи. Отправка почты средствами Delphi. Использование сообщений внутри приложения

Отправка и прием почты реализуются при помощи Delphi довольно просто. Для отправки почты нам понадобится компонент idSMTP со страницы Indy Clients палитры компонентов Delphi.

Этот компонент реализует все необходимое для отправки электронной почты по протоколу SMTP (Simple Mail Transfer Protocol - простой протокол передачи почты), использующий 25 порт, по которому посылаются команды и текст письма. Этапы отправки электронной почты следующие:

1) соединение с SMTP сервером по 25 порту;
2) подготовка тела письма, определение отправителя и получателя письма;
3) отправка письма на SMTP сервер;

Разместив на форме компонент idSMTP, займёмся его настройкой. Настройку порта можно произвести в инспекторе объектов, установив свойство Port в значение 25, или в коде программы сделать то же самое:

IdSMTP1.Port:=25;

Соединение с сервером

Для соединения с SMTP сервером, который будет осуществлять отправку нашей почты, нужно указать его URL, для сервера mail.ru это производится следующим образом:

IdSMTP1.Host:= ′smtp.mail.ru′;

Соединение с сервером производится методом Connect:

где ATimeout - необязательный параметр, задает максимальное время в миллисекундах ожидания ответа с SMTP сервера, по истечении которого попытка установить соединение прекращается.

Например,

IdSMTP1.Connect(5000);

Если при соединении с сервером требуется авторизация, то значение свойства AuthenticationType нужно установить в atLogin, при этом в инспекторе объектов также нужно определить свойства Username(имя пользователя. К примеру, Username почтового ящика [email protected] - delphi) и Password(пароль на ящик), или сделать то же программно:

IdSMTP1.AuthenticationType:=atLogin;
IdSMTP1.Username:=′delphi′;
IdSMTP1.Password:=′something′;

IdSMTP1.AuthenticationType:=atNone;

После применения метода Connect, нужно анализировать логическое свойство Connected, которое в случае удачного соединения устанавливается в True. После этого при помощи метода Send можно отправлять сообщение:

if Connected=True then IdSMTP1.Send(Msg);

Структура письма

Метод Send отправляет тело сообщения, представляющего собой структуру типа TIdMessage;

Структура письма реализуется в Delphi отдельным компонентом TIdMessage, расположенным на палитре компонентов Indy Misc и выглядит следующим образом

TidMessage Структура TIdMessage определяется следующим образом:

С темой сообщения, я думаю, все понятно. Свойство

конкретно определяются названия электронных учетных записей, которым адресуется письмо. Названия должны указываться через разделитель вида "," то есть через запятую. Например:

например,

например,

Свойство Text содержит информацию обоих свойств. Тело письма представляет собой объект типа TStrings:

где Collection - объект класса TIdMessageParts, представляющее собой коллекцию приложений к электронному письму.
контстанта AFileName типа TFileName - представляет собой обычную текстовую строку с указанием правильного пути к файлу, например "C:file.zip", по умолчанию имеет значение ′′.

Таким образом, продолжая наш пример, строкой вида

где то так

IdTCPClient1.Host:= "127.0.0.1"; IdTCPClient1.Connect;// подключились IdTCPClient1.Socket.WriteLn("command"); // отправили команду command и перевод строки //Ожидаем ответ и закрываем соединение txtResults.Lines.Append(IdTCPClient1.Socket.ReadLn); IdTCPClient1.Disconnect;

в данном случае команда - это просто текст с переводом строки. Это сильно упрощает прием команды с другой стороны (просто ReadLn). В общем же случае нужно придумывать (или использовать готовый) протокол.

выше это был клиент. А теперь сервер. С сервером все немного сложнее. Понятное дело, что для сервера нормально обслуживать не одного клиента, многих. И для этого есть несколько "схем".

Классическая - один клиент - один поток. Схема проста в кодировании, интуитивно понятна. Хорошо распаралеливается по ядрам. Недостаток - обычно очень сложно создать много потоков, а это ограничивает кол-во клиентов. Для 32битных программ верхний предел где то в районе 1500 (полторы тысячи) потоков на процесс. Но в этом случае накладные расходы на их переключение могут "скушать" весь проц. Именно эта схема используется в indy.

Вторая классическая - все клиенты на один поток. Эта схема часто более сложна в кодировании, но при правильном подходе позволяет держать 20-30к "медленных пользователей" практически не нагружая ядро. Сильный плюс этой схемы - можно обойтись без мютексов и других примитивов синхронизации. Эту схему использует NodeJS и стандартные классы для работы с сетью в Qt.

Смешанная. В этом случае создается несколько потоков, каждый с которых обслуживает какое-то кол-во клиентов. Самая сложная в кодировании, но позволяет по максимуму использовать ресурсы железа.

Как это сделано в Indy. Indy tcp сервер для каждого подключения создает отдельный поток (TThread) и дальнейшая работа с клиентом идет в нем. Indy красиво это прячет, оставляя для пользователя только необходимость реализовать метод IdTCPServer.onExecute . Но, как я сказал выше, этот метод запускается в отдельном треде и он у каждого клиента свой личный. Это значит следующее:

• в этом методе можно позвать sleep и только один клиент будет ждать. Все остальные будут работать (а вот если в обработчике нажатия кнопки позвать sleep, то результат известен)
  • обращаться к глобальным переменным лучше только через примитивы синхронизации.
  • обращаться к элементам gui нужно аккуратно и правильно. Напрямую лучше не делать (некоторые компоненты разрешают обращаться к ним с других потоков, но нужно внимательно читать доки).
  • обращаться к другим клиентам нужно через блокировку (потому что если два потока захотят писать одному и тому же пользователю - ничего хорошего с этого не выйдет).

Рассмотрим очень простой пример. На любой запрос клиента отвечаем тем же и закрываем соединение (такой себе echo сервер).

Procedure TForm1.IdTCPServer1Execute(AContext: TIdContext); var strText: String; begin //Принимаем от клиента строку strText:= AContext.Connection.Socket.ReadLn; //Отвечаем AContext.Connection.Socket.WriteLn(strText); //Закрываем соединение с пользователем AContext.Connection.Disconnect; end;

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

Var Clients: TList; i: integer; begin // защита от дурака:) if not Assigned(IdTCPServer1.Contexts) then exit; // получим список клиентов, и заблокируем его Clients:=IdTCPServer1.Contexts.LockList; try for i:= 0 to Clients.Count-1 do try //LBuffer имеет тип TBytes и содержит подготовленные данные для отправки // но можно и WriteLn использовать. TIdContext(Clients[i]).Connection.IOHandler.Write(LBuffer); except // тут нужно добавить логику. Клиент может отключиться в процессе end; finally // важно! список нужно разблокировать, иначе другие методы не смогут пройти дальше Contexts.LockList IdTCPServer1.Contexts.UnlockList; end; end;

инди содержит BytesToString() и ToBytes() для предобразования String и TIdBytes друг в дружку.

Список блокируется, что бы другие не могли его модифицировать. Иначе сам цикл сильно усложняется. И главное, не забывать разблокировать!

Остался последний вопрос. Как отправить сообщение какому то определенному клиенту. Для этого нужно научиться идентифицировать соединение. Это можно сделать несколькими способами - посмотреть в айпи/порт. Но есть лучше. У IdContext (точнее у его предка idTask) есть свойство Data типа TObject. В него можно записать свой объект и хранить там все нужные данные. Типичный пример использования будет следующий. Когда клиент только подключился - это поле пустое. Когда он прошел проверку имени-пароля - создаем объект (свой), сохраняем имя туда и прописываем в свойство Data. А потом, когда нужно делать цикл по подключенным клиентам, просто вычитываем его. Конечно, если пользователей тысячи, каждый раз просматривать всех пользователей будет накладно. Но как делать это более оптимально - тема другой большой статьи.

Последовательность обработки сообщений в Delphi
Все классы Delphi имеют встроенный механизм обработки сообщений, называемый обработчики сообщений. Класс получает какое-либо сообщение и вызывает один из набора определенных методов в зависимости от полученного сообщения. Если соответствующий метод не определен, то вызывается заданный по умолчанию обработчик. Более подробно этот механизм работает следующим образом.

После того, как сообщение получено, система сообщений VCL выполняет большую предварительную работу по его обработке.

Как уже отмечалось выше, первоначально сообщение обрабатывается методом TApplication.ProcessMessage, который выбирает его из очереди в основном цикле сообщений. При этом проверяет содержимое поля FOnMessage (фактически проверяет наличие’обработчика у события OnMessage) и, если оно не пусто, то вызывает обработчик этого события, а если поле пусто (Nil), то вызывает функцию API DispatchMessage(Msg). При отправке сообщения этого не происходит.

Если обработчик события OnMessage не определен, то для обработки полученного сообщения вызывается функция API DispatchMessage, которая передает сообщение главной процедуре окна.

Рассмотрим цикл обработки сообщения после поступления его в главное окно компонента. Последовательность обработки сообщения представлена на следующем рисунке:

Видно, что сообщение передается в MainWndProc, далее в WndProc, далее в Dispatch, далее в DefaultHandler.

В Delphi предусмотрен главный не виртуальный метод MainWndProc (Var Message: TMessage) для окна каждого компонента. Он содержит блок обработки особых ситуаций, передавая структуру сообщения от Windows до виртуального метода, определенного в свойстве WindowProc. При этом этот метод обрабатывает любые исключения, которые происходят в течение обработки сообщения, вызывая метод HandleException приложения. Начиная с этого места можно обеспечить специальную обработку сообщения, если это требуется логикой работы вашей программы. Обычно на этом этапе обработку изменяют, чтобы не дать состояться стандартной обработке VCL.

По умолчанию значение свойства WindowProc объекта инициализируется адресом виртуального метода WndProc. Далее, если нет зарегистрированных перехватчиков сообщения типа TWindowHook, WndProc вызывает виртуальный метод TObject.Dispatch, который, используя поле Msg структуры поступившего сообщения, определяет, находится ли это сообщение в списке обработчиков сообщения для данного объекта. Если объект не обрабатывает сообщение, исследуется список обработчиков сообщений предков. Если такой метод, в конце концов, будет найден, то он вызывается, в противном случае вызывается виртуальный метод DefaultHandler.

Наконец сообщение достигает соответствующей процедуры его обработки, где производится предусмотренная для него обработка. С помощью ключевого слова Inherited оно далее отправляется для обработки в предках. После этого сообщение также попадает в метод DefaultHandler, который производит завершающие действия по обработке сообщений и передает его процедуре DefWindowProc (DefMDIProc) для стандартной обработки Windows.

Обработка сообщений компонентами Delphi
Таким образом, краткое описание последовательности обработки сообщения выглядит следующим образом. Все сообщения первоначально проходят через метод, адрес которого указан в свойстве WindowProc. По умолчанию это метод WndProc. После чего они разделяются и рассылаются по своим методам сообщений. В конце они вновь сходятся в методе DefaultHandler, если не были обработаны ранее или в обработчиках вызывается унаследованный обработчик (Inherited). Следовательно, у компонентов Delphi есть следующие возможности для обработки сообщений:
а) До того, как какой-нибудь обработчик сообщения увидит сообщение. В этом случае требуется либо замена адреса метода в свойстве WindowProc, либо замещение метода TControl.WndProc.
Свойство WindowProc объявлено следующим образом:

Туре TWndMethod=Procedure (Var Message: TMessage) Of Object ;
Property WindowProc: TWndMethod;

Фактически, используя свойство WindowProc, можно создать метод типа TWndMethod и временно заменить исходный метод на созданный, однако, поскольку адрес метода в свойстве WindowProc не сохраняется, то необходимо предварительно сохранять адрес исходного метода WndProc, чтобы его можно было восстановить позднее.

OldWndProc: TWndMethod;
procedure NewWndProc(var Message: TMessage);
procedure TForm1.NewWndProc(var Message: TMessage);
var Ch: char;
begin
if message.Msg= WM_MOUSEMOVE then begin
Edit1.Text:=’x=’+inttostr(message.LParamLo)+’, y=’+inttostr(message.LParamHi);
end
else WndProc(Message);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
OldWndProc:=WindowProc;
end;

procedure TForm1.CheckBox1Click(Sender: TObject);
begin
If CheckBox1.Checked then WindowProc:= NewWndProc
else WindowProc:= OldWndProc;
end;

б) Внутри соответствующего метода сообщения.
Приведем еще один аналогичный пример.
Воспользуется сообщением, посылаемым компонентам для перерисовки WMPAINT.

В классе TForml объявим этот метод с целью его переопределения и представим реализацию переопределенного метода сообщения:

Туре TForml=Class(TForm)
… // Все иные необходимые объявления
Protected
Procedure WMPaint(Var Msg: TWMPaint); Message WM_PAINT; End;
Procedure TForml.WMPaint(Var Msg: TWMPaint); Begin
If CheckBox1.Checked Then ShowMessage(‘О6pa6oтчик сообщения!’);
Inherited;
End;

При переопределении конкретных обработчиков сообщений всегда целесообразно вызывать Inherited для выполнения базовой обработки сообщения, которое необходимо Windows.

в) После того, как каждый из соответствующих сообщению методов увидит его.

В этом случае необходимо замещать метод DefaultHandler.

procedure DefaultHandler(var Message); override;
procedure TForm1.DefaultHandler(var Message);
var i:integer;
begin
if Cardinal(Message)=WM_defh then
for i:= 0 to 10 do begin
beep;
sleep(100);
end
else
inherited;
end;

procedure TForm1.Button5Click(Sender: TObject);
begin
SendMessage(Handle,WM_defh,0,0);
end;

Связь между сообщениями и событиями
Многие события VCL Delphi непосредственно связаны с сообщениями Windows. В справочной системе Delphi эти соответствия перечислены. Представлены они в табл.1.

Таблица 1

He стоит создавать обработчики сообщений, если для него имеется предопределенное событие. В подобных случаях целесообразно использовать обработку события, поскольку на нее накладывается меньше ограничений.

Разработать программу, которая будет предоставлять интерфейс для использования стандартной для Win2000/XP команды передачи сообщений net send. Дать возможность указать пользователю адрес получателя, текст сообщения и количество отправляемых сообщений. Также предусмотреть возможность установки блокировки на получение сообщений от других компьютеров.

Создайте новый проект Delphi. Измените заголовок формы (свойство Caption) на Net Sender. Разместите вдоль левого края формы один над другим три компонента Label категории Standard и присвойте их свойству Caption значения IP-адрес:, Сообщение: И Количество:.

Рядом с каждой из меток разместите по компоненту Edit категории Standard . Самый верхний назовите ip (свойство Name), а свойству Text присвойте значение 192.168.0.1.; среднее поле назовите txt, а свойству Text присвойте какой-либо текст сообщения по умолчанию; самое нижнее поле назовите how, а свойству Text присвойте значение 1.

Под перечисленными компонентами разместите компонент Checkbox категории Standard . Присвойте ему имя secure, свойству Caption присвойте значение Отключить прием сообщений, а свойству Checked - значение True.

В самом низу формы разместите кнопку (компонент Button категории Standard ), присвоив ее свойству Caption значение Send. Также нам понадобится таймер (компонент Timer категории System ), для которого свойству Interval следует присвоить значение 10.

Полученная форма должна соответствовать рис. 15.1.

Рис. 15.1. Форма для программы отправки сообщений в локальной сети

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

Также нам понадобится глобальная переменная i типа integer:

Теперь создадим реализацию процедуры bomb в разделе implementation:

procedure TForm1.bomb() ;

if how.Text= "" then how.Text:= "1";

if ip.Text = "" then ip.Text:= "127.0.0.1"; {если ip-адрес не указан, то отправляем на локальный компьютер}

WinExec(PChar("net send " + ip.Text + """ + txt.Text + """), 0); //отправка сообщения

В этой процедуре выполняется проверка: все ли необходимые поля заполнены. Если нет текста сообщения, то устанавливаем знак "!"; если не указан IP-адрес, то отправляем сообщение на локальный компьютер с адресом 127.0.0.1; если не указано количество сообщений, то отправляем одно сообщение. Сообщения отправляются с помощью стандартной команды net send, которая имеет следующий синтаксис:

net send ip-адрес сообщение.

Теперь обработаем событие таймера OnTimer:

h: HWND; //хранит идентификатор окна

if not secure.Checked then //если флажок не установлен

Timer1.Enabled:= False; //отключаем мониторинг

if secure.Checked then //если флажок установлен

//ищем окна с сообщениями

h:= FindWindow(nil, "Служба сообщений "); //закрываем все найденные окна

if h <>

Если установлен флажок Отключить прием сообщений, то мы начинаем мониторинг окон, заголовок которых говорит о том, что это - сообщение, и закрываем все найденные окна. Если флажок не установлен, то мониторинг отключается.

Для того чтобы можно было переключаться между этими двумя режимами, необходимо создать обработчик события secure.OnClick:

if secure.Checked then //если флажок установлен…

Timer1.Enabled:= True; //…включаем мониторинг

При нажатии кнопки Send мы будем просто вызывать процедуру bomb:

Для того чтобы облегчить пользователю жизнь, сделаем так, чтобы отправка сообщения осуществлялась также по нажатии клавиши в любом текстовом поле ввода. Для этого необходимо создать обработчик события OnKeyPress для каждого из полей. Код этого обработчика для поля ip, который затем можно назначить полям txt и how:

if key = #13 then //если нажата клавиша

bomb; //отправка сообщения

Полный код модуля программы отправки сообщений по локальной сети представлен в листинге 15.1.

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, ExtCtrls;

procedure Timer1Timer(Sender: TObject);

procedure secureClick(Sender: TObject);

procedure ipKeyPress(Sender: TObject; var Key: Char);

procedure txtKeyPress(Sender: TObject; var Key: Char);

procedure howKeyPress(Sender: TObject; var Key: Char);

procedure Button1Click(Sender: TObject);

//проверяем, не пустое ли текстовое сообщение

if txt.Text = "" then txt.Text:= "!";

//если количество не указано, то отправляем одно сообщение

if how.Text= "" then how.Text:= "1";

if ip.Text = "" then ip.Text:= "127.0.0.1"; {если ip-адрес не указан, то отправляем на локальный компьютер}

//отправляем указанное количество сообщений

for i:=1 to StrToInt(how.Text) do

WinExec(PChar("net send " + ip.Text + """ + txt.Text + """), 0); //отправка сообщения

procedure TForm1.Timer1Timer(Sender: TObject);

h: HWND; //хранит идентификатор окна

if not secure.Checked then //если флажок не установлен

Timer1.Enabled:= False; //отключаем мониторинг

if secure.Checked then //если флажок установлен

//ищем окна с сообщениями

h:= FindWindow(nil, "Служба сообщений "); //закрываем все найденные окна

if h <> 0 then PostMessage(h, WM_QUIT, 0, 0);

procedure TForm1.secureClick(Sender: TObject);

if secure.Checked then //если флажок установлен…

Timer1.Enabled:= True; //…включаем мониторинг

procedure TForm1.ipKeyPress(Sender: TObject; var Key: Char);

if key = #13 then //если нажата клавиша

bomb; //отправка сообщения

procedure TForm1.Button1Click(Sender: TObject);

⊚ Все файлы проекта и исполняемый файл рассмотренной программы находятся на прилагаемом к книге компакт-диске в папке Chapter 15.

Посылка сообщений

Так же как система Windows посылает свои сообщения различным окнам, в самом приложении также может появиться необходимость обмена сообщениями между его собственными окнами и элементами управления. Для посылки сообщений существует несколько способов: метод PerForm() (работающий независимо от API Windows), а также функции API Win32 SendMessage() и PostMessage().

Метод PerForm(), которым обладают все потомки класса TControl:

function TControl.Perform(Msg: Cardinal; WParam, LParam: Longint): Longint;

Чтобы послать сообщение форме или элементу управления, применяется следующий синтаксис:

RetVal:= ControlName.PerForm(MessageID, wParam, lParam);

При вызове PerForm() управление вызывающей программе не возвратится, пока сообщение не будет обработано. Этот метод передает сообщение, минуя систему передачи сообщений API Windows.

Функции API SendMessage() и PostMessage(), объявленные в модуле Windows следующим образом:

function SendMessage(hWnd: HWND; Msg: UINT; wParam: WPARAM;

lParam: LPARAM): LRESULT; stdcall;

function PostMessage(hWnd: HWND; Msg: UINT;

wParam: WPARAM; lParam: LPARAM): BOOL; stdcall;

hWnd – дескриптор окна получателя сообщения; Msg – идентификатор сообщения; wParam и lParam – дополнительные данные.

Функция SendMessage() подобно методу PerForm() посылает сообщение непосредственно процедуре окна и ожидает его обработки, а функция PostMessage() помещает сообщение в очередь сообщений и возвращает управление вызвавшей ее программе, не дожидаясь результатов обработки.

Функция SendMessage() возвращает значение, полученное в результате обработки сообщения. Функция PostMessage() – возвращает значение, которое показывает, удалось ли поместить сообщение в очередь сообщений.

Пользовательские сообщения

При разработке приложений может возникнуть ситуация, при которой приложению потребуется послать специальное сообщение либо самому себе, либо другому приложению для выполнения некоторых действий. Для сообщений, придуманных пользователем, в Windows зарезервированы значения от WM_USER до $7FFF.

Пример пользовательского сообщения:

TestMsg = WM_USER + 100; // идентификатор сообщения

TForm1 = class(TForm)

// метод обработки сообщения:

procedure MyMessage(var Msg: TMessage); message TestMsg;

procedure TForm1.MyMessage(var Msg: TMessage);

ShowMessage("Работает сообщение TestMsg");

Msg.Result:= 1; // возвращаемый результат

Примеры посылки сообщения форме:

if Form1.PerForm(TestMsg, 0, 0) = 1 then

if SendMessage(Form1.Handle, TestMsg, 0, 0) = 1 then

ShowMessage("Сообщение успешно обработано");

if PostMessage(Form1.Handle, TestMsg, 0, 0) then

ShowMessage("Сообщение помещено в очередь сообщений");

События Delphi

Событие – это то, что происходит в процессе работы программы. С точки зрения языка Delphi, событие – это свойство процедурного типа, и его значением является указатель на некоторый метод. Присвоить такому свойству значение означает указать адрес метода, который будет выполняться в момент наступления события. Такие методы называются обработчиками событий.

Использование событий позволяет к существующему классу добавить новую функциональность без создания класса-потомка.

Свойства событий стараются начинать со слова "On", за которым следует имя события.

Взаимосвязь сообщений и событий

Delphi представляет собой интерфейс для взаимодействия с сообщениями Windows, по крайней мере – с некоторой их частью. Многие события компонентов библиотеки VCL непосредственно связаны с сообщениями Windows типа WM_XXX.