public override void QueueEvents(RemoteEvent remoteEvent)
{
try
{
if (_eventManager == null)
{
var(auxHandle, ipAddress, portNumber, timeout) = ConnectionRequest();
_eventManager = new GdsEventManager(auxHandle, ipAddress, portNumber, timeout);
_eventManager.Open();
var dummy = _eventManager.StartWaitingForEvents(remoteEvent);
}
remoteEvent.LocalId++;
var epb = remoteEvent.BuildEpb();
var epbData = epb.ToArray();
Xdr.Write(IscCodes.op_que_events);
Xdr.Write(_handle);
Xdr.WriteBuffer(epbData);
Xdr.Write(AddressOfAstRoutine);
Xdr.Write(ArgumentToAstRoutine);
Xdr.Write(remoteEvent.LocalId);
Xdr.Flush();
var response = (GenericResponse)ReadResponse();
remoteEvent.RemoteId = response.ObjectHandle;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public void QueueEvents(RemoteEvent remoteEvent)
{
try
{
if (_eventManager == null)
{
ConnectionRequest(out var auxHandle, out var ipAddress, out var portNumber);
_eventManager = new GdsEventManager(auxHandle, ipAddress, portNumber);
var dummy = _eventManager.WaitForEventsAsync(remoteEvent);
}
remoteEvent.LocalId++;
var epb = remoteEvent.BuildEpb();
var epbData = epb.ToArray();
Xdr.Write(IscCodes.op_que_events);
Xdr.Write(_handle);
Xdr.WriteBuffer(epbData);
Xdr.Write(AddressOfAstRoutine);
Xdr.Write(ArgumentToAstRoutine);
Xdr.Write(remoteEvent.LocalId);
Xdr.Flush();
var response = (GenericResponse)ReadResponse();
remoteEvent.RemoteId = response.ObjectHandle;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public void Dispose()
{
if (!_disposed)
{
_disposed = true;
if (TransactionCount > 0)
{
throw IscException.ForErrorCodeIntParam(IscCodes.isc_open_trans, TransactionCount);
}
try
{
CloseEventManager();
var detach = _handle != -1;
if (detach)
{
XdrStream.Write(IscCodes.op_detach);
XdrStream.Write(_handle);
}
XdrStream.Write(IscCodes.op_disconnect);
XdrStream.Flush();
if (detach)
{
ReadResponse();
}
CloseConnection();
#warning Here
_xdrStream?.Dispose();
}
catch (IOException ex)
{
try
{
CloseConnection();
}
catch (IOException ex2)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex2);
}
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
finally
{
_xdrStream = null;
_connection = null;
_charset = null;
_eventManager = null;
_serverVersion = null;
_dialect = 0;
_handle = -1;
_packetSize = 0;
_warningMessage = null;
_transactionCount = 0;
}
}
}
private void Dispose(bool disposing)
{
lock (SyncObject)
{
if (!_disposed)
{
try
{
Detach();
}
catch
{ }
finally
{
if (disposing)
{
_connection = null;
_charset = null;
_eventManager = null;
_serverVersion = null;
_dialect = 0;
_eventsId = 0;
_handle = 0;
_packetSize = 0;
_warningMessage = null;
_transactionCount = 0;
}
_disposed = true;
}
}
}
}
public void CloseEventManager()
{
if (_eventManager != null)
{
_eventManager.Dispose();
_eventManager = null;
}
}
public override void CloseEventManager()
{
if (_eventManager != null)
{
_eventManager.Close();
_eventManager = null;
}
}
public override async ValueTask CloseEventManagerAsync(CancellationToken cancellationToken = default)
{
if (_eventManager != null)
{
await _eventManager.CloseAsync(cancellationToken).ConfigureAwait(false);
_eventManager = null;
}
}
public override async Task CloseEventManager(AsyncWrappingCommonArgs async)
{
if (_eventManager != null)
{
await _eventManager.Close(async).ConfigureAwait(false);
_eventManager = null;
}
}
public void CloseEventManager()
{
lock (this.SyncObject)
{
if (this.eventManager != null)
{
this.eventManager.Close();
this.eventManager = null;
}
}
}
public void CloseEventManager()
{
lock (SyncObject)
{
if (_eventManager != null)
{
_eventManager.Close();
_eventManager = null;
}
}
}
public virtual async Task Detach(AsyncWrappingCommonArgs async)
{
if (TransactionCount > 0)
{
throw IscException.ForErrorCodeIntParam(IscCodes.isc_open_trans, TransactionCount);
}
try
{
await CloseEventManager(async).ConfigureAwait(false);
var detach = _handle != -1;
if (detach)
{
await Xdr.Write(IscCodes.op_detach, async).ConfigureAwait(false);
await Xdr.Write(_handle, async).ConfigureAwait(false);
}
await Xdr.Write(IscCodes.op_disconnect, async).ConfigureAwait(false);
await Xdr.Flush(async).ConfigureAwait(false);
if (detach)
{
await ReadResponse(async).ConfigureAwait(false);
}
await CloseConnection(async).ConfigureAwait(false);
}
catch (IOException ex)
{
try
{
await CloseConnection(async).ConfigureAwait(false);
}
catch (IOException ex2)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex2);
}
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
finally
{
_connection = null;
_charset = null;
_eventManager = null;
_serverVersion = null;
_dialect = 0;
_handle = -1;
_packetSize = 0;
_warningMessage = null;
_transactionCount = 0;
}
}
public override async ValueTask DetachAsync(CancellationToken cancellationToken = default)
{
if (TransactionCount > 0)
{
throw IscException.ForErrorCodeIntParam(IscCodes.isc_open_trans, TransactionCount);
}
try
{
await CloseEventManagerAsync(cancellationToken).ConfigureAwait(false);
var detach = _handle != -1;
if (detach)
{
await Xdr.WriteAsync(IscCodes.op_detach, cancellationToken).ConfigureAwait(false);
await Xdr.WriteAsync(_handle, cancellationToken).ConfigureAwait(false);
}
await Xdr.WriteAsync(IscCodes.op_disconnect, cancellationToken).ConfigureAwait(false);
await Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
if (detach)
{
await ReadResponseAsync(cancellationToken).ConfigureAwait(false);
}
await CloseConnectionAsync(cancellationToken).ConfigureAwait(false);
}
catch (IOException ex)
{
try
{
await CloseConnectionAsync(cancellationToken).ConfigureAwait(false);
}
catch (IOException)
{ }
throw IscException.ForIOException(ex);
}
finally
{
_connection = null;
Charset = null;
_eventManager = null;
ServerVersion = null;
Dialect = 0;
_handle = -1;
PacketSize = 0;
WarningMessage = null;
TransactionCount = 0;
}
}
public override void Detach()
{
if (TransactionCount > 0)
{
throw IscException.ForErrorCodeIntParam(IscCodes.isc_open_trans, TransactionCount);
}
try
{
CloseEventManager();
var detach = _handle != -1;
if (detach)
{
Xdr.Write(IscCodes.op_detach);
Xdr.Write(_handle);
}
Xdr.Write(IscCodes.op_disconnect);
Xdr.Flush();
if (detach)
{
ReadResponse();
}
CloseConnection();
}
catch (IOException ex)
{
try
{
CloseConnection();
}
catch (IOException)
{ }
throw IscException.ForIOException(ex);
}
finally
{
_connection = null;
Charset = null;
_eventManager = null;
ServerVersion = null;
Dialect = 0;
_handle = -1;
PacketSize = 0;
WarningMessage = null;
TransactionCount = 0;
}
}
public void Dispose()
{
if (!_disposed)
{
_disposed = true;
Detach();
_connection = null;
_charset = null;
_eventManager = null;
_serverVersion = null;
_dialect = 0;
_handle = 0;
_packetSize = 0;
_warningMessage = null;
_transactionCount = 0;
}
}
public void QueueEvents(RemoteEvent events)
{
if (_eventManager == null)
{
string ipAddress = string.Empty;
int portNumber = 0;
int auxHandle = 0;
ConnectionRequest(out auxHandle, out ipAddress, out portNumber);
_eventManager = new GdsEventManager(auxHandle, ipAddress, portNumber);
}
lock (SyncObject)
{
try
{
events.LocalId = Interlocked.Increment(ref _eventsId);
// Enqueue events in the event manager
_eventManager.QueueEvents(events);
EventParameterBuffer epb = events.ToEpb();
XdrStream.Write(IscCodes.op_que_events);
XdrStream.Write(_handle); // Database object id
XdrStream.WriteBuffer(epb.ToArray()); // Event description block
XdrStream.Write(0); // Address of ast routine
XdrStream.Write(0); // Argument to ast routine
XdrStream.Write(events.LocalId); // Client side id of remote event
XdrStream.Flush();
GenericResponse response = (GenericResponse)ReadResponse();
// Update event Remote event ID
events.RemoteId = response.ObjectHandle;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
}
public void QueueEvents(RemoteEvent events)
{
if (this.eventManager == null)
{
string ipAddress = string.Empty;
int portNumber = 0;
int auxHandle = 0;
this.ConnectionRequest(out auxHandle, out ipAddress, out portNumber);
this.eventManager = new GdsEventManager(auxHandle, ipAddress, portNumber);
}
lock (this.SyncObject)
{
try
{
events.LocalId = ++this.eventsId;
EventParameterBuffer epb = events.ToEpb();
this.Write(IscCodes.op_que_events); // Op codes
this.Write(this.handle); // Database object id
this.WriteBuffer(epb.ToArray()); // Event description block
this.Write(0); // Address of ast routine
this.Write(0); // Argument to ast routine
this.Write(events.LocalId); // Client side id of remote event
this.Flush();
GenericResponse response = (GenericResponse)this.ReadResponse();
// Update event Remote event ID
events.RemoteId = response.ObjectHandle;
// Enqueue events in the event manager
this.eventManager.QueueEvents(events);
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
}
public override async ValueTask QueueEventsAsync(RemoteEvent remoteEvent, CancellationToken cancellationToken = default)
{
try
{
if (_eventManager == null)
{
var(auxHandle, ipAddress, portNumber, timeout) = await ConnectionRequestAsync(cancellationToken).ConfigureAwait(false);
_eventManager = new GdsEventManager(auxHandle, ipAddress, portNumber, timeout);
await _eventManager.OpenAsync(cancellationToken).ConfigureAwait(false);
var dummy = _eventManager.StartWaitingForEvents(remoteEvent);
}
remoteEvent.LocalId++;
var epb = remoteEvent.BuildEpb();
var epbData = epb.ToArray();
await Xdr.WriteAsync(IscCodes.op_que_events, cancellationToken).ConfigureAwait(false);
await Xdr.WriteAsync(_handle, cancellationToken).ConfigureAwait(false);
await Xdr.WriteBufferAsync(epbData, cancellationToken).ConfigureAwait(false);
await Xdr.WriteAsync(AddressOfAstRoutine, cancellationToken).ConfigureAwait(false);
await Xdr.WriteAsync(ArgumentToAstRoutine, cancellationToken).ConfigureAwait(false);
await Xdr.WriteAsync(remoteEvent.LocalId, cancellationToken).ConfigureAwait(false);
await Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
var response = (GenericResponse) await ReadResponseAsync(cancellationToken).ConfigureAwait(false);
remoteEvent.RemoteId = response.ObjectHandle;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override async Task QueueEvents(RemoteEvent remoteEvent, AsyncWrappingCommonArgs async)
{
try
{
if (_eventManager == null)
{
var(auxHandle, ipAddress, portNumber) = await ConnectionRequest(async).ConfigureAwait(false);
_eventManager = new GdsEventManager(auxHandle, ipAddress, portNumber);
await _eventManager.Open(async).ConfigureAwait(false);
var dummy = _eventManager.WaitForEvents(remoteEvent, new AsyncWrappingCommonArgs(true));
}
remoteEvent.LocalId++;
var epb = remoteEvent.BuildEpb();
var epbData = epb.ToArray();
await Xdr.Write(IscCodes.op_que_events, async).ConfigureAwait(false);
await Xdr.Write(_handle, async).ConfigureAwait(false);
await Xdr.WriteBuffer(epbData, async).ConfigureAwait(false);
await Xdr.Write(AddressOfAstRoutine, async).ConfigureAwait(false);
await Xdr.Write(ArgumentToAstRoutine, async).ConfigureAwait(false);
await Xdr.Write(remoteEvent.LocalId, async).ConfigureAwait(false);
await Xdr.Flush(async).ConfigureAwait(false);
var response = (GenericResponse) await ReadResponse(async).ConfigureAwait(false);
remoteEvent.RemoteId = response.ObjectHandle;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
private void Dispose(bool disposing)
{
lock (this.SyncObject)
{
if (!this.disposed)
{
try
{
// release any unmanaged resources
this.Detach();
}
catch
{
}
finally
{
// release any managed resources
if (disposing)
{
this.connection = null;
this.charset = null;
this.eventManager = null;
this.serverVersion = null;
this.dialect = 0;
this.eventsId = 0;
this.handle = 0;
this.packetSize = 0;
this.warningMessage = null;
this.transactionCount = 0;
}
this.disposed = true;
}
}
}
}
private void Dispose(bool disposing)
{
lock (SyncObject)
{
if (!_disposed)
{
try
{
Detach();
}
catch
{ }
finally
{
if (disposing)
{
_connection = null;
_charset = null;
_eventManager = null;
_serverVersion = null;
_dialect = 0;
_eventsId = 0;
_handle = 0;
_packetSize = 0;
_warningMessage = null;
_transactionCount = 0;
}
_disposed = true;
}
}
}
}
public void CloseEventManager()
{
lock (SyncObject)
{
if (_eventManager != null)
{
_eventManager.Close();
_eventManager = null;
}
}
}
public void QueueEvents(RemoteEvent events)
{
if (_eventManager == null)
{
string ipAddress = string.Empty;
int portNumber = 0;
int auxHandle = 0;
ConnectionRequest(out auxHandle, out ipAddress, out portNumber);
_eventManager = new GdsEventManager(auxHandle, ipAddress, portNumber);
}
lock (SyncObject)
{
try
{
events.LocalId = Interlocked.Increment(ref _eventsId);
// Enqueue events in the event manager
_eventManager.QueueEvents(events);
EventParameterBuffer epb = events.ToEpb();
XdrStream.Write(IscCodes.op_que_events);
XdrStream.Write(_handle); // Database object id
XdrStream.WriteBuffer(epb.ToArray()); // Event description block
XdrStream.Write(0); // Address of ast routine
XdrStream.Write(0); // Argument to ast routine
XdrStream.Write(events.LocalId); // Client side id of remote event
XdrStream.Flush();
GenericResponse response = (GenericResponse)ReadResponse();
// Update event Remote event ID
events.RemoteId = response.ObjectHandle;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
}
public void CloseEventManager()
{
lock (this.SyncObject)
{
if (this.eventManager != null)
{
this.eventManager.Close();
this.eventManager = null;
}
}
}
public void QueueEvents(RemoteEvent events)
{
if (this.eventManager == null)
{
string ipAddress = string.Empty;
int portNumber = 0;
int auxHandle = 0;
this.ConnectionRequest(out auxHandle, out ipAddress, out portNumber);
this.eventManager = new GdsEventManager(auxHandle, ipAddress, portNumber);
}
lock (this.SyncObject)
{
try
{
events.LocalId = ++this.eventsId;
EventParameterBuffer epb = events.ToEpb();
this.Write(IscCodes.op_que_events); // Op codes
this.Write(this.handle); // Database object id
this.WriteBuffer(epb.ToArray()); // Event description block
this.Write(0); // Address of ast routine
this.Write(0); // Argument to ast routine
this.Write(events.LocalId); // Client side id of remote event
this.Flush();
GenericResponse response = (GenericResponse)this.ReadResponse();
// Update event Remote event ID
events.RemoteId = response.ObjectHandle;
// Enqueue events in the event manager
this.eventManager.QueueEvents(events);
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
}
private void Dispose(bool disposing)
{
lock (this.SyncObject)
{
if (!this.disposed)
{
try
{
// release any unmanaged resources
this.Detach();
}
catch
{
}
finally
{
// release any managed resources
if (disposing)
{
this.connection = null;
this.charset = null;
this.eventManager = null;
this.serverVersion = null;
this.dialect = 0;
this.eventsId = 0;
this.handle = 0;
this.packetSize = 0;
this.warningMessage = null;
this.transactionCount = 0;
}
this.disposed = true;
}
}
}
}
