public void HeaderSerializer_Deserialize_BadLength_Throws()
{
var header = "A.00p168.68e999ca-a651-40f4-ad8f-3aaf781862b4.1\n";
var bytes = Encoding.ASCII.GetBytes(header);
Assert.ThrowsException <InvalidDataException>(() =>
{
var result = HeaderSerializer.Deserialize(bytes, 0, bytes.Length);
});
}
public IEnumerator DataHandle()
{
while (true)
{
yield return(new WaitForSeconds(0.016f));
int readCount = receiveMsgs.Count;
for (int i = 0; i < readCount; i++)
{
//패킷을 Dequeue 한다
//패킷 : 메시지 타입 + 메시지 내용
DataPacket packet;
//lock (receiveLock)
//{
packet = receiveMsgs.Dequeue();
//}
HeaderData headerData = new HeaderData();
HeaderSerializer headerSerializer = new HeaderSerializer();
headerSerializer.SetDeserializedData(packet.msg);
if (packet.endPoint == null)
{
headerSerializer.Deserialize(ref headerData);
DataReceiver.ResizeByteArray(0, NetworkManager.packetSource + NetworkManager.packetId, ref packet.msg);
if (server_notifier.TryGetValue(headerData.id, out serverRecvNotifier))
{
serverRecvNotifier(packet);
}
else
{
Debug.Log("DataHandler::Server.TryGetValue 에러 " + headerData.id);
}
}
else
{
headerSerializer.UdpDeserialize(ref headerData);
DataReceiver.ResizeByteArray(0, NetworkManager.packetSource + NetworkManager.packetId + NetworkManager.udpId, ref packet.msg);
if (p2p_notifier.TryGetValue(headerData.id, out p2pRecvNotifier))
{
p2pRecvNotifier(packet, headerData.udpId);
}
else
{
Debug.Log("DataHandler::P2P.TryGetValue 에러 " + headerData.id);
}
}
}
}
}
/// <inheritdoc />
public async Task <TransportMessage> Receive(ITransactionContext context, CancellationToken cancellationToken)
{
using (await _receiveBottleneck.Enter(cancellationToken))
{
var connection = await GetConnection(context);
TransportMessage receivedTransportMessage;
using (var selectCommand = connection.Connection.CreateCommand())
{
selectCommand.CommandText = $@"
DELETE from {_tableName}
where id =
(
select id from {_tableName}
where recipient = @recipient
and visible < clock_timestamp()
and expiration > clock_timestamp()
order by priority asc, id asc
for update skip locked
limit 1
)
returning id,
headers,
body
";
selectCommand.Parameters.Add("recipient", NpgsqlDbType.Text).Value = _inputQueueName;
try
{
using (var reader = await selectCommand.ExecuteReaderAsync(cancellationToken))
{
if (!await reader.ReadAsync(cancellationToken))
{
return(null);
}
var headers = reader["headers"];
var headersDictionary = HeaderSerializer.Deserialize((byte[])headers);
var body = (byte[])reader["body"];
receivedTransportMessage = new TransportMessage(headersDictionary, body);
}
}
catch (SqlException sqlException) when(sqlException.Number == OperationCancelledNumber)
{
// ADO.NET does not throw the right exception when the task gets cancelled - therefore we need to do this:
throw new TaskCanceledException("Receive operation was cancelled", sqlException);
}
}
return(receivedTransportMessage);
}
}
/// <summary>
/// Receives the next message by querying the messages table for a message with a recipient matching this transport's <see cref="Address"/>
/// </summary>
public async Task <TransportMessage> Receive(ITransactionContext context)
{
using (await _bottleneck.Enter())
{
var connection = await GetConnection(context);
TransportMessage receivedTransportMessage;
using (var selectCommand = connection.CreateCommand())
{
selectCommand.CommandText = $@"
SET NOCOUNT ON
;WITH TopCTE AS (
SELECT TOP 1
[id],
[headers],
[body]
FROM [{_tableName}] M WITH (ROWLOCK, READPAST)
WHERE M.[recipient] = @recipient
AND M.[visible] < getdate()
AND M.[expiration] > getdate()
ORDER
BY [priority] ASC,
[id] ASC
)
DELETE FROM TopCTE
OUTPUT deleted.[id] as [id],
deleted.[headers] as [headers],
deleted.[body] as [body]
" ;
selectCommand.Parameters.Add("recipient", SqlDbType.NVarChar, RecipientColumnSize).Value = _inputQueueName;
using (var reader = await selectCommand.ExecuteReaderAsync())
{
if (!await reader.ReadAsync())
{
return(null);
}
var headers = reader["headers"];
var headersDictionary = _headerSerializer.Deserialize((byte[])headers);
var body = (byte[])reader["body"];
receivedTransportMessage = new TransportMessage(headersDictionary, body);
}
}
return(receivedTransportMessage);
}
}
/// <summary>
/// Maps a <seealso cref="MySqlDataReader"/> that's read a result from the message table into a <seealso cref="TransportMessage"/>
/// </summary>
/// <returns>A <seealso cref="TransportMessage"/> representing the row or <c>null</c> if no row was available</returns>
protected static async Task <TransportMessage> ExtractTransportMessageFromReader(MySqlDataReader reader, CancellationToken cancellationToken)
{
if (await reader.ReadAsync(cancellationToken).ConfigureAwait(false) == false)
{
return(null);
}
var headers = reader["headers"];
var headersDictionary = HeaderSerializer.Deserialize((byte[])headers);
var body = (byte[])reader["body"];
return(new TransportMessage(headersDictionary, body));
}
public void HeaderSerializer_DeserializesFromAscii()
{
const string header = "A.000168.68e999ca-a651-40f4-ad8f-3aaf781862b4.1\n";
var bytes = Encoding.ASCII.GetBytes(header);
var result = HeaderSerializer.Deserialize(bytes, 0, bytes.Length);
Assert.Equal('A', result.Type);
Assert.Equal(168, result.PayloadLength);
Assert.Equal(Guid.Parse("68e999ca-a651-40f4-ad8f-3aaf781862b4"), result.Id);
Assert.True(result.End);
}
// private method
// packet seperate id / data
private bool SeperatePacket(byte[] originalData, out int packetID, out byte[] seperatedData)
{
PacketHeader header = new PacketHeader();
HeaderSerializer serializer = new HeaderSerializer();
serializer.SetDeserializedData(originalData);
serializer.Deserialize(ref header);
seperatedData = null;
packetID = 0;
return(true);
}
private async Task ProcessMessageWithTransaction(ImapClient client, UniqueId messageId)
{
using (var transaction = new MailBasedTransaction(client, _endpointName))
{
try
{
var pair = transaction.BeginTransaction(messageId);
var messageNativeId = pair.Item1;
var message = pair.Item2;
var headers = HeaderSerializer.Deserialize(message.TextBody);
if (headers.TryGetValue(Headers.TimeToBeReceived, out string ttbrString))
{
var ttbr = TimeSpan.Parse(ttbrString);
var sentTime = message.Date;
if (sentTime + ttbr < DateTime.UtcNow)
{
return;
}
}
var body = new byte[0];
if (message.Attachments.Any())
{
var ms = new MemoryStream();
((MimePart)message.Attachments.First()).Content.DecodeTo(ms);
body = ms.ToArray();
}
var transportTransaction = new TransportTransaction();
transportTransaction.Set(transaction);
var shouldCommit = await HandleMessageWithRetries(messageNativeId, headers, body, transportTransaction);
if (shouldCommit)
{
transaction.Commit();
_currentRetries.Remove(messageNativeId, out _);
}
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
transaction.Abort();
_criticalError.Raise(ex.Message, ex);
}
}
}
//Tcp 데이터 수신
void TcpReceiveDataCallback(IAsyncResult asyncResult)
{
AsyncData asyncData = (AsyncData)asyncResult.AsyncState;
Socket tcpSock = asyncData.sock;
try
{
asyncData.msgSize = (short)tcpSock.EndReceive(asyncResult);
}
catch
{
Debug.Log("NetworkManager::HandleAsyncDataReceive.EndReceive 에러");
tcpSock.Close();
return;
}
if (asyncData.msgSize >= NetworkManager.packetId)
{
Array.Resize(ref asyncData.msg, asyncData.msgSize + NetworkManager.packetSource + NetworkManager.packetId);
Debug.Log(asyncData.msg.Length);
HeaderData headerData = new HeaderData();
HeaderSerializer headerSerializer = new HeaderSerializer();
headerSerializer.SetDeserializedData(asyncData.msg);
headerSerializer.Deserialize(ref headerData);
DataPacket packet = new DataPacket(headerData, asyncData.msg);
lock (receiveLock)
{
try
{ //큐에 삽입
Debug.Log("Enqueue Message Length : " + packet.msg.Length);
msgs.Enqueue(packet);
}
catch
{
Console.WriteLine("NetworkManager::HandleAsyncDataReceive.Enqueue 에러");
}
}
}
//재 수신
asyncData = new AsyncData(tcpSock);
tcpSock.BeginReceive(asyncData.msg, 0, NetworkManager.packetLength, SocketFlags.None, new AsyncCallback(TcpReceiveLengthCallback), asyncData);
}
// 수신된 데이터가 어느 데이터 구조에 적합한지 판단후 등록된 함수 호출
public void ReceivePacket(byte[] data)
{
PacketHeader header = new PacketHeader();
HeaderSerializer serializer = new HeaderSerializer();
// 패킷 추출
serializer.Deserialize(data, ref header);
int packetId = (int)header.packetId;
int headerSize = sizeof(int);
byte[] packetData = new byte[data.Length - headerSize];
Buffer.BlockCopy(data, headerSize, packetData, 0, packetData.Length);
// 등록된 적절한 receive함수 호출
notifier[packetId]((PacketId)packetId, packetData);
}
/// <summary>
/// Called whene the transport needs to process a newly received message.
/// </summary>
/// <param name="context"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <TransportMessage> Receive(ITransactionContext context, CancellationToken cancellationToken)
{
using (await _bottleneck.Enter(cancellationToken))
{
var connection = await GetConnection(context);
TransportMessage receivedTransportMessage;
using (var selectCommand = connection.CreateCommand())
{
selectCommand.CommandText = $@"
UPDATE {_tableName} SET process_id = @processId WHERE recipient = @recipient AND `visible` < now() AND `expiration` > now() AND process_id IS NULL ORDER BY `priority` ASC, `id` ASC LIMIT 1;
SELECT `id`, `headers`, `body` FROM {_tableName} WHERE process_id = @processId ORDER BY ID LIMIT 1;
DELETE FROM {_tableName} WHERE process_id = @processId;";
selectCommand.Parameters.Add(selectCommand.CreateParameter("recipient", DbType.String, _inputQueueName));
selectCommand.Parameters.Add(selectCommand.CreateParameter("processId", DbType.Guid, Guid.NewGuid()));
try
{
using (var reader = await selectCommand.ExecuteReaderAsync(cancellationToken))
{
if (!await reader.ReadAsync(cancellationToken))
{
return(null);
}
var headers = reader["headers"];
var headersDictionary = HeaderSerializer.Deserialize((byte[])headers);
var body = (byte[])reader["body"];
receivedTransportMessage = new TransportMessage(headersDictionary, body);
}
}
catch (MySqlException sqlException) when(sqlException.Number == OperationCancelledNumber)
{
// ADO.NET does not throw the right exception when the task gets cancelled - therefore we need to do this:
throw new TaskCanceledException("Receive operation was cancelled", sqlException);
}
}
return(receivedTransportMessage);
}
}
/// <inheritdoc />
public async Task <TransportMessage> Receive(ITransactionContext context, CancellationToken cancellationToken)
{
using (await _receiveBottleneck.Enter(cancellationToken))
{
var connection = await GetConnection(context);
TransportMessage receivedTransportMessage;
using (var selectCommand = connection.Connection.CreateCommand())
{
selectCommand.CommandText = $"rebus_dequeue_{_tableName}";
selectCommand.CommandType = CommandType.StoredProcedure;
selectCommand.Parameters.Add(new OracleParameter("recipientQueue", OracleDbType.VarChar, _inputQueueName, ParameterDirection.Input));
selectCommand.Parameters.Add(new OracleParameter("output", OracleDbType.Cursor, ParameterDirection.Output));
selectCommand.InitialLobFetchSize = -1;
try
{
selectCommand.ExecuteNonQuery();
using (var reader = (selectCommand.Parameters["output"].Value as OracleCursor).GetDataReader()){
if (!await reader.ReadAsync(cancellationToken))
{
return(null);
}
var headers = reader["headers"];
var headersDictionary = HeaderSerializer.Deserialize((byte[])headers);
var body = (byte[])reader["body"];
receivedTransportMessage = new TransportMessage(headersDictionary, body);
}
}
catch (OracleException exception) when(exception.Code == OperationCancelledNumber)
{
// ADO.NET does not throw the right exception when the task gets cancelled - therefore we need to do this:
throw new TaskCanceledException("Receive operation was cancelled", exception);
}
}
return(receivedTransportMessage);
}
}
public void DataHandle()
{
while (true)
{
if (receiveMsgs.Count > 0)
{
DataPacket packet = new DataPacket();
//패킷을 Dequeue 한다 패킷 : 메시지 타입 + 메시지 내용, 소켓
lock (receiveLock)
{
try
{
packet = receiveMsgs.Dequeue();
}
catch
{
Console.WriteLine("DataHandler::DataHandle.Dequeue 에러");
}
}
HeaderData headerData = new HeaderData();
HeaderSerializer headerSerializer = new HeaderSerializer();
headerSerializer.SetDeserializedData(packet.msg);
headerSerializer.Deserialize(ref headerData);
ResizeByteArray(0, UnityServer.packetSource + UnityServer.packetId, ref packet.msg);
//Dictionary에 등록된 델리게이트 메소드에서 PacketId를 반환받는다.
if (m_notifier.TryGetValue(headerData.id, out recvNotifier))
{
recvNotifier(packet);
}
else
{
Console.WriteLine("DataHandler::DataHandle.TryGetValue 에러 ");
Console.WriteLine("패킷 출처 : " + headerData.source);
Console.WriteLine("패킷 ID : " + headerData.id);
}
}
}
}
public void Can_round_trip_headers()
{
var input = new Dictionary <string, string>
{
{
"key 1",
"value 1"
},
{
"key 2",
"value 2"
}
};
var serialized = HeaderSerializer.Serialize(input);
Approver.Verify(serialized);
var deserialize = HeaderSerializer.Deserialize(serialized);
CollectionAssert.AreEquivalent(input, deserialize);
}
//Udp 데이터 수신
public void UdpReceiveDataCallback(IAsyncResult asyncResult)
{
AsyncData asyncData = (AsyncData)asyncResult.AsyncState;
udpSock = asyncData.sock;
try
{
Debug.Log("메시지 받음");
asyncData.msgSize = (short)udpSock.EndReceive(asyncResult);
Debug.Log(asyncData.EP);
}
catch (Exception e)
{
Debug.Log("연결 끊김 :" + e.Message);
udpSock.Close();
}
if (asyncData.msgSize > 0)
{
byte[] msgSize = ResizeByteArray(0, NetworkManager.packetLength, ref asyncData.msg);
Array.Resize(ref asyncData.msg, BitConverter.ToInt16(msgSize, 0) + NetworkManager.packetSource + NetworkManager.packetId);
HeaderData headerData = new HeaderData();
HeaderSerializer headerSerializer = new HeaderSerializer();
headerSerializer.SetDeserializedData(asyncData.msg);
headerSerializer.Deserialize(ref headerData);
DataPacket packet = new DataPacket(headerData, asyncData.msg, asyncData.EP);
lock (receiveLock)
{ //큐에 삽입
Debug.Log("Enqueue Message Length : " + asyncData.msg.Length);
msgs.Enqueue(packet);
}
//다시 수신 준비
asyncData = new AsyncData(udpSock, asyncData.EP);
udpSock.BeginReceiveFrom(asyncData.msg, 0, AsyncData.msgMaxSize, SocketFlags.None, ref asyncData.EP, new AsyncCallback(UdpReceiveDataCallback), asyncData);
}
}
public void ReceivePacket(byte[] data)
{
PacketHeader header = new PacketHeader();
HeaderSerializer serializer = new HeaderSerializer();
bool ret = serializer.Deserialize(data, ref header);
if (ret == false)
{
// 패킷으로서 인식할 수 없으므로 폐기합니다.
return;
}
if (m_udp != null && m_udp.IsCommunicating() == true)
{
// 통신상대로부터 첫 수신 시에 상호 통신할 수 있도록 접속 통지를 합니다.
if (m_handler != null && m_eventOccured == false)
{
NetEventState state = new NetEventState();
state.type = NetEventType.Connect;
state.result = NetEventResult.Success;
state.endPoint = m_udp.GetRemoteEndPoint();
Debug.Log("Event handler call.");
m_handler(state);
m_eventOccured = true;
}
}
int packetId = (int)header.packetId;
if (m_notifier.ContainsKey(packetId) &&
m_notifier[packetId] != null)
{
int headerSize = Marshal.SizeOf(typeof(PacketHeader));//sizeof(PacketId) + sizeof(int);
byte[] packetData = new byte[data.Length - headerSize];
Buffer.BlockCopy(data, headerSize, packetData, 0, packetData.Length);
m_notifier[packetId]((PacketId)packetId, packetData);
}
}
public void HeaderSerializer_CanRoundTrip()
{
var header = new Header()
{
Type = PayloadTypes.Request,
PayloadLength = 168,
Id = Guid.Parse("68e999ca-a651-40f4-ad8f-3aaf781862b4"),
End = true,
};
var buffer = new byte[1024];
const int offset = 0;
var length = HeaderSerializer.Serialize(header, buffer, offset);
var result = HeaderSerializer.Deserialize(buffer, 0, length);
Assert.Equal(header.Type, result.Type);
Assert.Equal(header.PayloadLength, result.PayloadLength);
Assert.Equal(header.Id, result.Id);
Assert.Equal(header.End, result.End);
}
/// <inheritdoc />
public async Task <TransportMessage> Receive(ITransactionContext context, CancellationToken cancellationToken)
{
using (await _receiveBottleneck.Enter(cancellationToken))
{
var connection = GetConnection(context);
TransportMessage receivedTransportMessage;
using (var selectCommand = connection.Connection.CreateCommand())
{
selectCommand.CommandText = $"{_table.Prefix}rebus_dequeue_{_table.Name}";
selectCommand.CommandType = CommandType.StoredProcedure;
selectCommand.Parameters.Add(new OracleParameter("recipientQueue", OracleDbType.Varchar2, _inputQueueName, ParameterDirection.Input));
selectCommand.Parameters.Add(new OracleParameter("now", _rebusTime.Now.ToOracleTimeStamp()));
selectCommand.Parameters.Add(new OracleParameter("output", OracleDbType.RefCursor, ParameterDirection.Output));
selectCommand.InitialLOBFetchSize = -1;
selectCommand.ExecuteNonQuery();
using (var reader = (selectCommand.Parameters["output"].Value as OracleRefCursor).GetDataReader())
{
if (!reader.Read())
{
return(null);
}
var headers = reader["headers"];
var headersDictionary = HeaderSerializer.Deserialize((byte[])headers);
var body = (byte[])reader["body"];
receivedTransportMessage = new TransportMessage(headersDictionary, body);
}
}
return(receivedTransportMessage);
}
}
/// <summary>
/// Receives the next message by querying the messages table for a message with a recipient matching this transport's <see cref="Address"/>
/// </summary>
public async Task <TransportMessage> Receive(ITransactionContext context, CancellationToken cancellationToken)
{
using (await _bottleneck.Enter(cancellationToken))
{
var connection = await GetConnection(context);
TransportMessage receivedTransportMessage;
using (var selectCommand = connection.CreateCommand())
{
selectCommand.CommandText = $@"
SET NOCOUNT ON
;WITH TopCTE AS (
SELECT TOP 1
[id],
[headers],
[body]
FROM [{_tableName}] M WITH (ROWLOCK, READPAST)
WHERE M.[recipient] = @recipient
AND M.[visible] < getdate()
AND M.[expiration] > getdate()
ORDER
BY [priority] ASC,
[id] ASC
)
DELETE FROM TopCTE
OUTPUT deleted.[id] as [id],
deleted.[headers] as [headers],
deleted.[body] as [body]
" ;
selectCommand.Parameters.Add("recipient", SqlDbType.NVarChar, RecipientColumnSize).Value = _inputQueueName;
try
{
using (var reader = await selectCommand.ExecuteReaderAsync(cancellationToken))
{
if (!await reader.ReadAsync(cancellationToken))
{
return(null);
}
var headers = reader["headers"];
var headersDictionary = HeaderSerializer.Deserialize((byte[])headers);
var body = (byte[])reader["body"];
receivedTransportMessage = new TransportMessage(headersDictionary, body);
}
}
catch (SqlException sqlException) when(sqlException.Number == OperationCancelledNumber)
{
// ADO.NET does not throw the right exception when the task gets cancelled - therefore we need to do this:
throw new TaskCanceledException("Receive operation was cancelled", sqlException);
}
}
return(receivedTransportMessage);
}
}
public Dictionary <string, string> Deserialize(byte[] bytes)
{
return(_utf8HeaderSerializer.Deserialize(bytes));
}
private async Task ReceivePacketsAsync()
{
bool isClosed = false;
int length;
DisconnectedEventArgs disconnectArgs = null;
while (_receiver != null && _receiver.IsConnected && !isClosed)
{
// receive a single packet
try
{
// read the header
int headerOffset = 0;
while (headerOffset < TransportConstants.MaxHeaderLength)
{
length = await _receiver.ReceiveAsync(_receiveHeaderBuffer, headerOffset, TransportConstants.MaxHeaderLength - headerOffset).ConfigureAwait(false);
if (length == 0)
{
throw new TransportDisconnectedException("Stream closed while reading header bytes");
}
headerOffset += length;
}
// deserialize the bytes into a header
var header = HeaderSerializer.Deserialize(_receiveHeaderBuffer, 0, TransportConstants.MaxHeaderLength);
// read the payload
var contentStream = _getStream(header);
var buffer = PayloadTypes.IsStream(header) ?
new byte[header.PayloadLength] :
_receiveContentBuffer;
int offset = 0;
if (header.PayloadLength > 0)
{
do
{
// read in chunks
int count = Math.Min(header.PayloadLength - offset, TransportConstants.MaxPayloadLength);
// read the content
length = await _receiver.ReceiveAsync(buffer, offset, count).ConfigureAwait(false);
if (length == 0)
{
throw new TransportDisconnectedException("Stream closed while reading payload bytes");
}
if (contentStream != null)
{
// write chunks to the contentStream if it's not a stream type
if (!PayloadTypes.IsStream(header))
{
await contentStream.WriteAsync(buffer, offset, length).ConfigureAwait(false);
}
}
offset += length;
}while (offset < header.PayloadLength);
// give the full payload buffer to the contentStream if it's a stream
if (contentStream != null && PayloadTypes.IsStream(header))
{
((PayloadStream)contentStream).GiveBuffer(buffer, length);
}
}
_receiveAction(header, contentStream, offset);
}
catch (TransportDisconnectedException de)
{
isClosed = true;
disconnectArgs = new DisconnectedEventArgs()
{
Reason = de.Reason,
};
}
catch (Exception e)
{
isClosed = true;
disconnectArgs = new DisconnectedEventArgs()
{
Reason = e.Message,
};
}
}
Disconnect(disconnectArgs);
}
/// <summary>
/// Deserialize msmq-message from the extension property
/// </summary>
public Dictionary <string, string> Deserialize(Message msmqMessage)
{
return(_utf8HeaderSerializer.Deserialize(msmqMessage.Extension));
}
public async Task <TransportMessage> Receive(ITransactionContext context)
{
using (await _bottleneck.Enter())
{
var connection = await GetConnection(context);
long? idOfMessageToDelete;
TransportMessage receivedTransportMessage;
using (var selectCommand = connection.CreateCommand())
{
selectCommand.CommandText =
string.Format(@"
SELECT TOP 1
[id],
[headers],
[body]
FROM [{0}]
WITH (UPDLOCK, READPAST, ROWLOCK)
WHERE
[recipient] = @recipient
AND [expiration] > getdate()
ORDER BY
[priority] ASC,
[id] asc
", _tableName);
selectCommand.Parameters.Add("recipient", SqlDbType.NVarChar, RecipientColumnSize).Value =
_inputQueueName;
using (var reader = await selectCommand.ExecuteReaderAsync())
{
if (!await reader.ReadAsync())
{
return(null);
}
var headers = reader["headers"];
var headersDictionary = _headerSerializer.Deserialize((byte[])headers);
idOfMessageToDelete = (long)reader["id"];
var body = (byte[])reader["body"];
receivedTransportMessage = new TransportMessage(headersDictionary, body);
}
}
if (!idOfMessageToDelete.HasValue)
{
return(null);
}
using (var deleteCommand = connection.CreateCommand())
{
deleteCommand.CommandText = string.Format("DELETE FROM [{0}] WHERE [id] = @id", _tableName);
deleteCommand.Parameters.Add("id", SqlDbType.BigInt).Value = idOfMessageToDelete;
await deleteCommand.ExecuteNonQueryAsync();
}
return(receivedTransportMessage);
}
}
