uiocompletionport.pas

楠楠写的DBiocp例子都是源码

unit uIOCompletionPort;

interface

uses
  Windows, WinSock2, uWin32Const, uException, uDIProtocol, uDIClientContext;
type

  TIOCompletionPort = class
  private
    m_hCompletionPort: Thandle;
  private
    procedure CreateCompletionPort;
  public
    function AssociateSocketWithCompletionPort( hDevice: THandle;
                                                dwCompletionKey: DWORD): Boolean;

    function GetIOCompletionStatus( var FClientContext: TDIClientContext;
                                    var pHandleData: PPerHandleData;
                                    var dwIoSize: DWORD): Boolean; overload;

    function GetIOCompletionStatus( var FClientContext: TDIClientContext;
                                    var pHandleData: PPerHandleData;
                                    var dwIoSize: DWORD;
                                    dwMilliseconds: DWORD): Boolean; overload;

    function PostIOCompletionStatus( lpCompletionKey: DWORD;
                                     lpOverlapped: POverlapped;
                                     lpNumberOfBytesTransferred: DWORD): Boolean;

  public
    constructor Create;
    destructor Destroy; override;
  end;

implementation

constructor TIOCompletionPort.Create;
begin
  inherited Create;
  CreateCompletionPort;
end;

destructor TIOCompletionPort.Destroy;
begin
  CloseHandle(m_hCompletionPort);
  inherited Destroy;
end;

procedure TIOCompletionPort.CreateCompletionPort;
var
  s: TSocket;
begin
  s := Winsock2.socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
  if (s = Winsock2.INVALID_SOCKET) then
    raise TException.Create(ErrWin32Error, GetLastError(), 'Winsock2.socket');

  m_hCompletionPort := CreateIOCompletionPort(s, 0, 0, 0);
  if (m_hCompletionPort = 0) then
    raise TException.Create(ErrWin32Error, GetLastError(), 'CreateIOCompletionPort');

  Winsock2.closesocket(s);
end;

function TIOCompletionPort.AssociateSocketWithCompletionPort( hDevice: THandle;
                                                              dwCompletionKey: DWORD ): Boolean;
var
  h: THandle;
begin
  Result := TRUE;
  h := CreateIOCompletionPort(hDevice, m_hCompletionPort, dwCompletionKey, 0);
  if (h <> m_hCompletionPort) then begin
    Result := FALSE;
    raise TException.Create(ErrWin32Error, GetLastError(), 'AssociateSocketWithCompletionPort');
  end;
end;

function TIOCompletionPort.GetIOCompletionStatus( var FClientContext: TDIClientContext;
                                                  var pHandleData: PPerHandleData;
                                                  var dwIoSize: DWORD): Boolean;
begin
  Result := GetQueuedCompletionStatus( m_hCompletionPort,
                                       dwIOSize,
                                       DWORD(FClientContext),
                                       POVERLAPPED(pHandleData),
                                       INFINITE );
end;

function TIOCompletionPort.GetIOCompletionStatus( var FClientContext: TDIClientContext;
                                                  var pHandleData: PPerHandleData;
                                                  var dwIoSize: DWORD;
                                                  dwMilliseconds: DWORD): Boolean;
var
  bRet: Boolean;
  nLastError: DWORD;
begin
  bRet := TRUE;

  if FALSE = GetQueuedCompletionStatus( m_hCompletionPort,
                                        dwIOSize,
                                        DWORD(FClientContext),
                                        POVERLAPPED(pHandleData),
                                        INFINITE ) then
  begin
    nLastError := GetLastError();
    if (nLastError <> WAIT_TIMEOUT) then
      raise TException.Create(ErrWin32Error, GetLastError(), 'GetQueuedCompletionStatus');
    bRet := FALSE;
  end;

  Result := bRet;
end;

function TIOCompletionPort.PostIOCompletionStatus( lpCompletionKey: DWORD;
                                                   lpOverlapped: POverlapped;
                                                   lpNumberOfBytesTransferred: DWORD): Boolean;
begin
  Result := PostQueuedCompletionStatus( m_hCompletionPort,
			                                  lpNumberOfBytesTransferred,
                                        lpCompletionKey,
                                        lpOverlapped );
end;

end.