void IDataImport.SendMessage(IDataMessage message)
{
if (!this.useBuffering)
{
base.WrappedObject.SendMessage(message);
return;
}
DataMessageOpcode value;
byte[] array;
message.Serialize(this.useCompression, out value, out array);
this.writer.Write((int)value);
if (array != null)
{
this.writer.Write(array.Length);
this.writer.Write(array);
this.uncompressedSize += 8 + array.Length;
}
else
{
this.writer.Write(0);
this.uncompressedSize += 8;
}
this.bufferCount++;
if (this.gzipStream != null)
{
this.gzipStream.Flush();
}
if (this.dataBuffer.Length >= (long)this.minBatchSize)
{
this.FlushBuffers(false);
}
}
MessageRec IMailbox.SaveSyncState(byte[] key, string syncState)
{
MrsTracer.ProxyClient.Function("RemoteMailbox.SaveSyncState", new object[0]);
if (!(this is RemoteDestinationMailbox))
{
throw new UnsupportedRemoteServerVersionWithOperationPermanentException(base.MrsProxyClient.ServerName, base.ServerVersion.ToString(), "IMailbox_SaveSyncState");
}
this.VerifyMailboxConnection();
IDataExport dataExport = new PagedTransmitter(syncState, base.MrsProxyClient.UseCompression);
DataExportBatch dataExportBatch = dataExport.ExportData();
long handle = base.MrsProxy.IDestinationMailbox_SaveSyncState2(base.Handle, key, dataExportBatch);
if (!dataExportBatch.IsLastBatch)
{
using (IDataImport dataImport = new RemoteDataImport(base.MrsProxy, handle, null))
{
do
{
dataExportBatch = dataExport.ExportData();
IDataMessage message = DataMessageSerializer.Deserialize(dataExportBatch.Opcode, dataExportBatch.Data, base.MrsProxyClient.UseCompression);
dataImport.SendMessage(message);
}while (!dataExportBatch.IsLastBatch);
}
}
return(null);
}
private void FlushBufferedOperations()
{
while (this.pendingOperations.Count > 0)
{
IDataMessage message = this.pendingOperations.Dequeue();
base.WrappedObject.SendMessage(message);
}
}
IDataMessage IDataImport.SendMessageAndWaitForReply(IDataMessage request)
{
this.UpdateTracker(request);
IDataMessage dataMessage = this.destination.SendMessageAndWaitForReply(request);
this.UpdateTracker(dataMessage);
return(dataMessage);
}
void IDataImport.SendMessage(IDataMessage message)
{
this.SpinUpTransmitterThread();
this.WaitUntilDataIsProcessed();
this.currentMessage = message;
this.eventBufferIsAvailableToAccept.Reset();
this.eventWakeUpTransmitter.Set();
}
void IDataImport.SendMessage(IDataMessage message)
{
DataMessageOpcode opcode;
byte[] data;
message.Serialize(base.MrsProxyClient.UseCompression, out opcode, out data);
base.MrsProxy.IDataImport_ImportBuffer(base.Handle, (int)opcode, data);
}
public static void ExportRoutine(IMailboxReplicationProxyService mrsProxy, long dataExportHandle, IDataImport destProxy, DataExportBatch firstBatch, bool useCompression)
{
try
{
DataExportBatch dataExportBatch;
do
{
if (firstBatch != null)
{
dataExportBatch = firstBatch;
firstBatch = null;
}
else
{
if (TestIntegration.Instance.AbortConnectionDuringFX)
{
MailboxReplicationProxyClient mailboxReplicationProxyClient = (MailboxReplicationProxyClient)mrsProxy;
mailboxReplicationProxyClient.Abort();
}
dataExportBatch = mrsProxy.DataExport_ExportData2(dataExportHandle);
if (dataExportBatch.IsLastBatch)
{
dataExportHandle = 0L;
}
}
bool flag = false;
try
{
if (dataExportBatch.Opcode != 0)
{
IDataMessage message = DataMessageSerializer.Deserialize(dataExportBatch.Opcode, dataExportBatch.Data, useCompression);
destProxy.SendMessage(message);
}
if (dataExportBatch.FlushAfterImport)
{
destProxy.SendMessageAndWaitForReply(FlushMessage.Instance);
}
flag = true;
}
finally
{
if (!flag && dataExportHandle != 0L)
{
MrsTracer.ProxyClient.Error("Exception was thrown during import/flush, canceling export.", new object[0]);
mrsProxy.DataExport_CancelExport(dataExportHandle);
dataExportHandle = 0L;
}
}
}while (!dataExportBatch.IsLastBatch);
}
finally
{
if (dataExportHandle != 0L)
{
mrsProxy.CloseHandle(dataExportHandle);
}
}
}
void IDataImport.SendMessage(IDataMessage message)
{
MrsTracer.ProxyService.Function("DataExport.SendMessage", new object[0]);
this.CheckForCancel();
message.Serialize(this.service.UseCompression, out this.nextOpcode, out this.nextBuffer);
this.result = DataExport.DataExportResult.MoreData;
this.eventDataAvailable.Set();
this.WaitForTheNextCall();
}
private void UpdateTracker(IDataMessage message)
{
if (this.job.ProgressTracker != null && message != null)
{
uint size = (uint)message.GetSize();
this.job.ProgressTracker.AddBytes(size);
MRSResource.Cache.GetInstance(MRSResource.Id.ObjectGuid, this.job.WorkloadTypeFromJob).Charge(size);
}
}
IDataMessage IDataImport.SendMessageAndWaitForReply(IDataMessage message)
{
((IDataImport)this).SendMessage(new AsynchronousTransmitter.AsyncTransmitterWaitForReplyMessage(message));
this.WaitUntilDataIsProcessed();
IDataMessage result = this.replyMessage;
this.replyMessage = null;
return(result);
}
private void BufferOrSendMessage(IDataMessage msg)
{
if (msg is FxProxyPoolCloseEntryMessage || msg is FxProxyPoolOpenFolderMessage || msg is FxProxyPoolCreateItemMessage || msg is FxProxyPoolOpenItemMessage)
{
this.pendingOperations.Enqueue(msg);
return;
}
this.FlushBufferedOperations();
base.WrappedObject.SendMessage(msg);
}
void IDataImport.SendMessage(IDataMessage message)
{
FxProxyImportBufferMessage fxProxyImportBufferMessage = message as FxProxyImportBufferMessage;
if (fxProxyImportBufferMessage != null)
{
base.WrappedObject.ProcessRequest(fxProxyImportBufferMessage.Opcode, fxProxyImportBufferMessage.Buffer);
return;
}
throw new UnexpectedErrorPermanentException(-2147024809);
}
byte[] IMapiFxProxy.GetObjectData()
{
IDataMessage dataMessage = base.WrappedObject.SendMessageAndWaitForReply(FxProxyGetObjectDataRequestMessage.Instance);
FxProxyGetObjectDataResponseMessage fxProxyGetObjectDataResponseMessage = dataMessage as FxProxyGetObjectDataResponseMessage;
if (fxProxyGetObjectDataResponseMessage == null)
{
throw new UnexpectedErrorPermanentException(-2147024809);
}
return(fxProxyGetObjectDataResponseMessage.Buffer);
}
IFxProxy IDestinationMailbox.GetFxProxy()
{
MrsTracer.ProxyClient.Function("RemoteDestinationMailbox.GetFxProxy", new object[0]);
base.VerifyMailboxConnection();
byte[] data;
long handle = base.MrsProxy.IDestinationMailbox_GetFxProxy(base.Handle, out data);
IDataMessage getDataResponseMsg = FxProxyGetObjectDataResponseMessage.Deserialize(DataMessageOpcode.FxProxyGetObjectDataResponse, data, base.MrsProxyClient.UseCompression);
BufferedTransmitter destination = new BufferedTransmitter(new RemoteDataImport(base.MrsProxy, handle, getDataResponseMsg), base.ExportBufferSizeKB, true, base.MrsProxyClient.UseBuffering, base.MrsProxyClient.UseCompression);
AsynchronousTransmitter destination2 = new AsynchronousTransmitter(destination, true);
return(new FxProxyTransmitter(destination2, true));
}
List <byte[]> IFxProxyPool.GetUploadedMessageIDs()
{
this.EnsureFolderDataCached();
this.FlushBufferedOperations();
IDataMessage dataMessage = base.WrappedObject.SendMessageAndWaitForReply(FxProxyPoolGetUploadedIDsRequestMessage.Instance);
FxProxyPoolGetUploadedIDsResponseMessage fxProxyPoolGetUploadedIDsResponseMessage = dataMessage as FxProxyPoolGetUploadedIDsResponseMessage;
if (fxProxyPoolGetUploadedIDsResponseMessage == null)
{
throw new UnexpectedErrorPermanentException(-2147024809);
}
return(fxProxyPoolGetUploadedIDsResponseMessage.EntryIDs);
}
IDataMessage IDataImport.SendMessageAndWaitForReply(IDataMessage message)
{
if (!this.useBuffering)
{
return(base.WrappedObject.SendMessageAndWaitForReply(message));
}
if (message is FlushMessage)
{
this.FlushBuffers(true);
return(null);
}
return(base.WrappedObject.SendMessageAndWaitForReply(message));
}
IDataMessage IDataImport.SendMessageAndWaitForReply(IDataMessage message)
{
if (message is FxProxyGetObjectDataRequestMessage)
{
return(new FxProxyGetObjectDataResponseMessage(base.WrappedObject.GetObjectData()));
}
if (message is FlushMessage)
{
base.WrappedObject.Flush();
return(null);
}
throw new UnexpectedErrorPermanentException(-2147024809);
}
IFxProxyPool IDestinationMailbox.GetFxProxyPool(ICollection <byte[]> folderIds)
{
MrsTracer.ProxyClient.Function("RemoteDestinationMailbox.GetFxProxyPool", new object[0]);
base.VerifyMailboxConnection();
List <byte[]> list = new List <byte[]>(folderIds);
byte[] data;
long handle = base.MrsProxy.IDestinationMailbox_GetFxProxyPool(base.Handle, list.ToArray(), out data);
IDataMessage getDataResponseMsg = FxProxyPoolGetFolderDataResponseMessage.Deserialize(DataMessageOpcode.FxProxyPoolGetFolderDataResponse, data, base.MrsProxyClient.UseCompression);
BufferedTransmitter destination = new BufferedTransmitter(new RemoteDataImport(base.MrsProxy, handle, getDataResponseMsg), base.ExportBufferSizeKB, true, base.MrsProxyClient.UseBuffering, base.MrsProxyClient.UseCompression);
AsynchronousTransmitter destination2 = new AsynchronousTransmitter(destination, true);
return(new FxProxyPoolTransmitter(destination2, true, base.ServerVersion));
}
private void EnsureFolderDataCached()
{
if (this.folderDataMap != null)
{
return;
}
IDataMessage dataMessage = base.WrappedObject.SendMessageAndWaitForReply(FxProxyPoolGetFolderDataRequestMessage.Instance);
FxProxyPoolGetFolderDataResponseMessage fxProxyPoolGetFolderDataResponseMessage = dataMessage as FxProxyPoolGetFolderDataResponseMessage;
if (fxProxyPoolGetFolderDataResponseMessage == null)
{
throw new UnexpectedErrorPermanentException(-2147024809);
}
this.folderDataMap = fxProxyPoolGetFolderDataResponseMessage.FolderData;
}
public DataExport(IDataMessage getDataResponseMsg, MailboxReplicationProxyService service)
{
this.getDataResponseMsg = getDataResponseMsg;
this.nextOpcode = DataMessageOpcode.None;
this.nextBuffer = null;
this.result = DataExport.DataExportResult.Done;
this.exportFailure = null;
this.exportThread = null;
this.eventDataAvailable = new AutoResetEvent(false);
this.eventDataProcessed = new AutoResetEvent(false);
this.cancelExport = false;
this.service = service;
this.lastReturnWasTimeout = false;
this.storedOpcode = 0;
this.storedData = null;
}
void IDataImport.SendMessage(IDataMessage message)
{
MessageExportResultsMessage messageExportResultsMessage = message as MessageExportResultsMessage;
if (messageExportResultsMessage == null)
{
base.WrappedObject.SendMessage(message);
return;
}
this.MissingMessages = messageExportResultsMessage.MissingMessages;
this.BadMessages = messageExportResultsMessage.BadMessages;
foreach (BadMessageRec badMessageRec in this.BadMessages)
{
badMessageRec.Failure = FailureRec.Create(new RemotePermanentException(new LocalizedString(badMessageRec.XmlData), null));
}
}
void IDataImport.SendMessage(IDataMessage message)
{
PagedDataMessage pagedDataMessage = message as PagedDataMessage;
if (pagedDataMessage == null)
{
throw new InputDataIsInvalidPermanentException();
}
if (pagedDataMessage.Buffer != null)
{
this.chunks.Add(pagedDataMessage.Buffer);
this.totalDataSize += pagedDataMessage.Buffer.Length;
}
if (pagedDataMessage.IsLastChunk)
{
byte[] array;
if (this.chunks.Count == 0)
{
array = null;
}
else if (this.chunks.Count == 1)
{
array = this.chunks[0];
}
else
{
array = new byte[this.totalDataSize];
int num = 0;
foreach (byte[] array2 in this.chunks)
{
array2.CopyTo(array, num);
num += array2.Length;
}
}
if (this.blobDoneDelegate != null)
{
if (this.useCompression)
{
array = CommonUtils.DecompressData(array);
}
this.blobDoneDelegate(array);
return;
}
string data = CommonUtils.UnpackString(array, this.useCompression);
this.stringDoneDelegate(data);
}
}
IDataMessage IDataImport.SendMessageAndWaitForReply(IDataMessage message)
{
if (message is FlushMessage)
{
base.MrsProxy.IDataImport_Flush(base.Handle);
return(null);
}
if (message is FxProxyGetObjectDataRequestMessage && this.getDataResponseMsg is FxProxyGetObjectDataResponseMessage)
{
return(this.getDataResponseMsg);
}
if (message is FxProxyPoolGetFolderDataRequestMessage && this.getDataResponseMsg is FxProxyPoolGetFolderDataResponseMessage)
{
return(this.getDataResponseMsg);
}
throw new UnsupportedRemoteServerVersionWithOperationPermanentException(base.MrsProxyClient.ServerName, base.ServerVersion.ToString(), "IDataImport_GetObjectData");
}
void IDataImport.SendMessage(IDataMessage message)
{
if (!this.useBuffering)
{
base.WrappedObject.SendMessage(message);
return;
}
BufferBatchMessage bufferBatchMessage = message as BufferBatchMessage;
if (bufferBatchMessage == null)
{
base.WrappedObject.SendMessage(message);
return;
}
if (bufferBatchMessage.Buffer != null)
{
byte[] buffer;
if (this.useCompression)
{
buffer = CommonUtils.DecompressData(bufferBatchMessage.Buffer);
}
else
{
buffer = bufferBatchMessage.Buffer;
}
using (MemoryStream memoryStream = new MemoryStream(buffer))
{
using (BinaryReader binaryReader = new BinaryReader(memoryStream))
{
while (memoryStream.Position < memoryStream.Length)
{
int opcode = CommonUtils.ReadInt(binaryReader);
byte[] data = CommonUtils.ReadBlob(binaryReader);
IDataMessage message2 = DataMessageSerializer.Deserialize(opcode, data, this.useCompression);
base.WrappedObject.SendMessage(message2);
}
}
}
}
if (bufferBatchMessage.FlushAfterImport)
{
base.WrappedObject.SendMessageAndWaitForReply(FlushMessage.Instance);
}
}
IFxProxy IDestinationFolder.GetFxProxy(FastTransferFlags flags)
{
byte[] data;
long handle;
if (base.ServerVersion[30])
{
handle = base.MrsProxy.IDestinationFolder_GetFxProxy2(base.Handle, (int)flags, out data);
}
else
{
handle = base.MrsProxy.IDestinationFolder_GetFxProxy(base.Handle, out data);
}
IDataMessage getDataResponseMsg = FxProxyGetObjectDataResponseMessage.Deserialize(DataMessageOpcode.FxProxyGetObjectDataResponse, data, base.MrsProxyClient.UseCompression);
BufferedTransmitter destination = new BufferedTransmitter(new RemoteDataImport(base.MrsProxy, handle, getDataResponseMsg), this.exportBufferSizeKB, true, base.MrsProxyClient.UseBuffering, base.MrsProxyClient.UseCompression);
AsynchronousTransmitter destination2 = new AsynchronousTransmitter(destination, true);
return(new FxProxyTransmitter(destination2, true));
}
public void Process(IDataMessage data)
{
//simply dispatch the data to the correct method
switch (data.DataType)
{
case DataType.Accelerometer:
Process(data as AccelerometerData);
break;
case DataType.Touch:
Process(data as TouchData);
break;
case DataType.Text:
Process(data as TextData);
break;
case DataType.Tap:
Process(data as TapData);
break;
}
}
IDataMessage IDataImport.SendMessageAndWaitForReply(IDataMessage message)
{
MrsTracer.ProxyService.Function("DataExport.SendMessageAndWaitForReply", new object[0]);
if (message is FlushMessage)
{
this.CheckForCancel();
this.result = DataExport.DataExportResult.Flush;
this.eventDataAvailable.Set();
this.WaitForTheNextCall();
return(null);
}
if (message is FxProxyGetObjectDataRequestMessage && this.getDataResponseMsg is FxProxyGetObjectDataResponseMessage)
{
return(this.getDataResponseMsg);
}
if (message is FxProxyPoolGetFolderDataRequestMessage && this.getDataResponseMsg is FxProxyPoolGetFolderDataResponseMessage)
{
return(this.getDataResponseMsg);
}
throw new UnexpectedErrorPermanentException(-2147024809);
}
void ISourceMailbox.SetMailboxSyncState(string syncState)
{
MrsTracer.ProxyClient.Function("RemoteSourceMailbox.SetMailboxSyncState", new object[0]);
base.VerifyMailboxConnection();
IDataExport dataExport = new PagedTransmitter(syncState, base.MrsProxyClient.UseCompression);
DataExportBatch dataExportBatch = dataExport.ExportData();
long handle = base.MrsProxy.ISourceMailbox_SetMailboxSyncState(base.Handle, dataExportBatch);
if (!dataExportBatch.IsLastBatch)
{
using (IDataImport dataImport = new RemoteDataImport(base.MrsProxy, handle, null))
{
do
{
dataExportBatch = dataExport.ExportData();
IDataMessage message = DataMessageSerializer.Deserialize(dataExportBatch.Opcode, dataExportBatch.Data, base.MrsProxyClient.UseCompression);
dataImport.SendMessage(message);
}while (!dataExportBatch.IsLastBatch);
}
}
}
/// <summary>
/// Sends the specified data message to the server.
/// </summary>
/// <param name="data">The data message to send.</param>
public void Send(IDataMessage data)
{
Guard();
_logger.Trace("Send request for data {0}", data.DataType);
lock (_messageQueue)
{
if (_isSending)
{
_messageQueue.Enqueue(data);
}
else
{
SendDataMessage(data);
}
}
}
private void RaiseDataMessageReceivedEvent(IDataMessage dataMessage)
{
_logger.Trace("Raising event DataMessageReceived");
_synchronizationContext.Post(o =>
{
var handlers = DataMessageReceived;
if (handlers != null)
{
handlers(this, new DataMessageEventArgs(dataMessage));
}
}, null);
}
IDataMessage IDataImport.SendMessageAndWaitForReply(IDataMessage message)
{
return(base.WrappedObject.SendMessageAndWaitForReply(message));
}
public RemoteDataImport(IMailboxReplicationProxyService mrsProxy, long handle, IDataMessage getDataResponseMsg) : base(mrsProxy, handle)
{
this.getDataResponseMsg = getDataResponseMsg;
}
void IDataImport.SendMessage(IDataMessage message)
{
FxProxyPoolOpenFolderMessage fxProxyPoolOpenFolderMessage = message as FxProxyPoolOpenFolderMessage;
if (fxProxyPoolOpenFolderMessage != null)
{
this.ClearCurrentObjectsReferences();
this.currentFolder = base.WrappedObject.GetFolderProxy(fxProxyPoolOpenFolderMessage.Buffer);
return;
}
FxProxyPoolCreateFolderMessage fxProxyPoolCreateFolderMessage = message as FxProxyPoolCreateFolderMessage;
if (fxProxyPoolCreateFolderMessage != null)
{
this.ClearCurrentObjectsReferences();
this.currentFolder = base.WrappedObject.CreateFolder(fxProxyPoolCreateFolderMessage.Data);
return;
}
FxProxyPoolSetItemPropertiesMessage fxProxyPoolSetItemPropertiesMessage = message as FxProxyPoolSetItemPropertiesMessage;
if (fxProxyPoolSetItemPropertiesMessage != null)
{
if (fxProxyPoolSetItemPropertiesMessage.Props != null)
{
if (this.currentMessage != null)
{
this.currentMessage.SetItemProperties(fxProxyPoolSetItemPropertiesMessage.Props);
return;
}
if (this.currentFolder != null)
{
this.currentFolder.SetItemProperties(fxProxyPoolSetItemPropertiesMessage.Props);
return;
}
base.WrappedObject.SetItemProperties(fxProxyPoolSetItemPropertiesMessage.Props);
}
return;
}
if (this.currentFolder == null)
{
throw new FolderIsMissingTransientException();
}
FxProxyPoolOpenItemMessage fxProxyPoolOpenItemMessage = message as FxProxyPoolOpenItemMessage;
if (fxProxyPoolOpenItemMessage != null)
{
this.currentMessage = this.CurrentFolder.OpenMessage(fxProxyPoolOpenItemMessage.Buffer);
return;
}
FxProxyPoolCreateItemMessage fxProxyPoolCreateItemMessage = message as FxProxyPoolCreateItemMessage;
if (fxProxyPoolCreateItemMessage != null)
{
this.currentMessage = this.CurrentFolder.CreateMessage(fxProxyPoolCreateItemMessage.CreateFAI);
return;
}
FxProxyPoolDeleteItemMessage fxProxyPoolDeleteItemMessage = message as FxProxyPoolDeleteItemMessage;
if (fxProxyPoolDeleteItemMessage != null)
{
this.CurrentFolder.DeleteMessage(fxProxyPoolDeleteItemMessage.Buffer);
return;
}
FxProxyPoolCloseEntryMessage fxProxyPoolCloseEntryMessage = message as FxProxyPoolCloseEntryMessage;
if (fxProxyPoolCloseEntryMessage != null)
{
if (this.currentMessage != null)
{
this.currentMessage.Dispose();
this.currentMessage = null;
return;
}
if (this.currentFolder != null)
{
this.currentFolder.Dispose();
this.currentFolder = null;
}
return;
}
else
{
FxProxyPoolSetPropsMessage fxProxyPoolSetPropsMessage = message as FxProxyPoolSetPropsMessage;
if (fxProxyPoolSetPropsMessage != null)
{
this.CurrentEntry.SetProps(fxProxyPoolSetPropsMessage.PropValues);
return;
}
FxProxyPoolSetExtendedAclMessage fxProxyPoolSetExtendedAclMessage = message as FxProxyPoolSetExtendedAclMessage;
if (fxProxyPoolSetExtendedAclMessage != null)
{
this.CurrentFolder.SetItemProperties(new FolderAcl(fxProxyPoolSetExtendedAclMessage.AclFlags, fxProxyPoolSetExtendedAclMessage.AclData));
return;
}
FxProxyPoolSaveChangesMessage fxProxyPoolSaveChangesMessage = message as FxProxyPoolSaveChangesMessage;
if (fxProxyPoolSaveChangesMessage != null)
{
this.CurrentMessage.SaveChanges();
return;
}
FxProxyPoolWriteToMimeMessage fxProxyPoolWriteToMimeMessage = message as FxProxyPoolWriteToMimeMessage;
if (fxProxyPoolWriteToMimeMessage != null)
{
this.CurrentMessage.WriteToMime(fxProxyPoolWriteToMimeMessage.Buffer);
return;
}
FxProxyImportBufferMessage fxProxyImportBufferMessage = message as FxProxyImportBufferMessage;
if (fxProxyImportBufferMessage != null)
{
this.CurrentEntry.ProcessRequest(fxProxyImportBufferMessage.Opcode, fxProxyImportBufferMessage.Buffer);
return;
}
throw new UnexpectedErrorPermanentException(-2147024809);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DataMessageEventArgs"/> class.
/// </summary>
/// <param name="dataMessage">The data message.</param>
public DataMessageEventArgs(IDataMessage dataMessage)
{
DataMessage = dataMessage;
}
private void SendDataMessage(IDataMessage data)
{
_logger.Trace("Sending data message {0}", data.DataType);
_isSending = true;
var rawData = data.ToByteArray();
// take a look whether we need to throttle sending
if (MinMillisecondsBetweenMessages > 0)
{
var now = DateTime.Now;
var elapsed = now - _lastMessageSent;
var diff = MinMillisecondsBetweenMessages - (int)Math.Floor(elapsed.TotalMilliseconds);
if (diff > 0)
{
Thread.Sleep(diff);
}
}
if (data.MustBeDelivered)
{
Socket.SendAsync(rawData);
}
else
{
_udpSender.SendToAsync(rawData);
}
// store reference time
_lastMessageSent = DateTime.Now;
}
