/// <summary>
/// Creates and routes a packet with data from a binary stream.
/// </summary>
public void DeserializeAndRoutePacket(int nodeId, NodePacketType packetType, INodePacketTranslator translator)
{
// PERF: Not using VerifyThrow to avoid boxing of packetType in the non-error case
if (!_packetFactories.ContainsKey(packetType))
{
ErrorUtilities.ThrowInternalError("No packet handler for type {0}", packetType);
}
PacketFactoryRecord record = _packetFactories[packetType];
record.DeserializeAndRoutePacket(nodeId, translator);
}
/// <summary>
/// Translate the TargetOutputs for the target finished event.
/// </summary>
private static void TranslateTargetFinishedEvent(INodePacketTranslator translator, TargetFinishedEventArgs finishedEvent)
{
List<TaskItem> targetOutputs = null;
if (translator.Mode == TranslationDirection.WriteToStream)
{
if (finishedEvent.TargetOutputs != null)
{
targetOutputs = new List<TaskItem>();
foreach (TaskItem item in finishedEvent.TargetOutputs)
{
targetOutputs.Add(item);
}
}
}
translator.Translate<TaskItem>(ref targetOutputs, TaskItem.FactoryForDeserialization);
if (translator.Mode == TranslationDirection.ReadFromStream)
{
finishedEvent.TargetOutputs = targetOutputs;
}
}
/// <summary>
/// Translates the packet to/from binary form.
/// </summary>
/// <param name="translator">The translator to use.</param>
public void Translate(INodePacketTranslator translator)
{
translator.Translate(ref _nodeId);
translator.Translate(ref _startupDirectory);
translator.TranslateDictionary(ref _buildProcessEnvironment, StringComparer.OrdinalIgnoreCase);
translator.TranslateCulture(ref _culture);
translator.TranslateCulture(ref _uiCulture);
translator.TranslateDotNet(ref _appDomainSetup);
translator.Translate(ref _lineNumberOfTask);
translator.Translate(ref _columnNumberOfTask);
translator.Translate(ref _projectFileOfTask);
translator.Translate(ref _taskName);
translator.Translate(ref _taskLocation);
translator.TranslateDictionary(ref _taskParameters, StringComparer.OrdinalIgnoreCase, TaskParameter.FactoryForDeserialization);
translator.Translate(ref _continueOnError);
}
/// <summary>
/// Private constructor for deserialization
/// </summary>
private BuildRequest(INodePacketTranslator translator)
{
Translate(translator);
}
/// <summary>
/// Writes the packet to the serializer.
/// Always send as ints, even if ushorts are being used: otherwise it'd
/// need a byte to discriminate and the savings would be microscopic.
/// </summary>
void INodePacketTranslatable.Translate(INodePacketTranslator translator)
{
ErrorUtilities.VerifyThrow(translator.Mode == TranslationDirection.WriteToStream, "write only");
string file = File;
int line = Line;
int column = Column;
translator.Translate(ref file);
translator.Translate(ref line);
translator.Translate(ref column);
}
/// <summary>
/// Factory for serialization.
/// </summary>
static internal WorkUnitResult FactoryForDeserialization(INodePacketTranslator translator)
{
return new WorkUnitResult(translator);
}
/// <summary>
/// The class factory for deserialization.
/// </summary>
internal static BuildParameters FactoryForDeserialization(INodePacketTranslator translator)
{
return new BuildParameters(translator);
}
/// <summary>
/// Serializes or deserializes a packet.
/// </summary>
public void Translate(INodePacketTranslator translator)
{
translator.TranslateEnum(ref _reason, (int)_reason);
translator.TranslateDotNet(ref _exception);
}
/// <summary>
/// Constructor for deserialization
/// </summary>
private BuildResult(INodePacketTranslator translator)
{
((INodePacketTranslatable)this).Translate(translator);
}
/// <summary>
/// Function for serialization.
/// </summary>
void INodePacketTranslatable.Translate(INodePacketTranslator translator)
{
translator.Translate(ref _toolsVersion);
translator.Translate(ref _toolsPath);
translator.TranslateProjectPropertyInstanceDictionary(ref _properties);
translator.TranslateProjectPropertyInstanceDictionary(ref _environmentProperties);
translator.TranslateProjectPropertyInstanceDictionary(ref _globalProperties);
translator.TranslateDictionary(ref _subToolsets, StringComparer.OrdinalIgnoreCase, SubToolset.FactoryForDeserialization);
translator.Translate(ref _overrideTasksPath);
translator.Translate(ref _defaultOverrideToolsVersion);
}
public static INodePacket FactoryForDeserialization(INodePacketTranslator translator)
{
return(new SdkResolverResponse(translator));
}
public void Translate(INodePacketTranslator translator)
{
translator.Translate(ref _fullPath);
translator.Translate(ref _version);
}
public SdkResolverResponse(INodePacketTranslator translator)
{
Translate(translator);
}
/// <summary>
/// Private constructor for deserialization
/// </summary>
private TargetResult(INodePacketTranslator translator)
{
((INodePacketTranslatable)this).Translate(translator);
}
/// <summary>
/// Factory for the serializer.
/// </summary>
static internal ItemsStore FactoryForDeserialization(INodePacketTranslator translator)
{
return(new ItemsStore(translator));
}
/// <summary>
/// Factory for serialization.
/// </summary>
static internal INodePacket FactoryForDeserialization(INodePacketTranslator translator)
{
return new BuildRequest(translator);
}
/// <summary>
/// Factory for serialization
/// </summary>
static internal INodePacket FactoryForDeserialization(INodePacketTranslator translator)
{
return(new BuildResult(translator));
}
/// <summary>
/// Factory for deserialization.
/// </summary>
internal static INodePacket FactoryForDeserialization(INodePacketTranslator translator)
{
TaskHostTaskCancelled taskCancelled = new TaskHostTaskCancelled();
taskCancelled.Translate(translator);
return taskCancelled;
}
/// <summary>
/// Private constructor for deserialization
/// </summary>
private BuildRequestConfiguration(INodePacketTranslator translator)
{
Translate(translator);
}
/// <summary>
/// Private constructor for translation
/// </summary>
private BuildParameters(INodePacketTranslator translator)
{
((INodePacketTranslatable)this).Translate(translator);
}
/// <summary>
/// Factory for serialization.
/// </summary>
static internal INodePacket FactoryForDeserialization(INodePacketTranslator translator)
{
return(new BuildRequestConfiguration(translator));
}
public void Translate(INodePacketTranslator translator)
{
ErrorUtilities.VerifyThrow(translator.Mode == TranslationDirection.WriteToStream, "write only");
string assemblyName = AssemblyName;
string assemblyFile = AssemblyFile;
translator.Translate(ref assemblyName);
translator.Translate(ref assemblyFile);
}
/// <summary>
/// Write the given ITaskItem, using the given write translator
/// </summary>
private void WriteITaskItem(INodePacketTranslator translator, ITaskItem wrappedItem)
{
ErrorUtilities.VerifyThrow(translator.Mode == TranslationDirection.WriteToStream, "Cannot call this method when reading!");
if (!TranslateNullable(translator, wrappedItem))
{
return;
}
string escapedItemSpec;
string escapedDefiningProject;
IDictionary wrappedMetadata;
bool wrappedMetadataIsEscaped;
ITaskItem2 wrappedItemAsITaskItem2 = wrappedItem as ITaskItem2;
if (wrappedItemAsITaskItem2 != null)
{
escapedItemSpec = wrappedItemAsITaskItem2.EvaluatedIncludeEscaped;
escapedDefiningProject = wrappedItemAsITaskItem2.GetMetadataValueEscaped(FileUtilities.ItemSpecModifiers.DefiningProjectFullPath);
wrappedMetadata = wrappedItemAsITaskItem2.CloneCustomMetadataEscaped();
wrappedMetadataIsEscaped = true;
}
else
{
// We know that the ITaskItem constructor expects an escaped string, and that ITaskItem.ItemSpec
// is expected to be unescaped, so make sure we give the constructor what it wants.
escapedItemSpec = EscapingUtilities.Escape(wrappedItem.ItemSpec);
escapedDefiningProject = EscapingUtilities.EscapeWithCaching(wrappedItem.GetMetadata(FileUtilities.ItemSpecModifiers.DefiningProjectFullPath));
wrappedMetadata = wrappedItem.CloneCustomMetadata();
wrappedMetadataIsEscaped = false;
}
Dictionary <string, string> escapedGenericWrappedMetadata = wrappedMetadata as Dictionary <string, string>;
if (escapedGenericWrappedMetadata == null)
{
escapedGenericWrappedMetadata = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
foreach (object key in wrappedMetadata.Keys)
{
string value = (string)wrappedMetadata[key];
if (!wrappedMetadataIsEscaped)
{
value = (value == null) ? value : EscapingUtilities.Escape(value);
}
escapedGenericWrappedMetadata.Add((string)key, value);
}
}
else if (!wrappedMetadataIsEscaped)
{
foreach (KeyValuePair <string, string> entry in escapedGenericWrappedMetadata)
{
escapedGenericWrappedMetadata[entry.Key] = entry.Value == null ? entry.Value : EscapingUtilities.Escape(entry.Value);
}
}
translator.Translate(ref escapedItemSpec);
translator.Translate(ref escapedDefiningProject);
translator.TranslateDictionary(ref escapedGenericWrappedMetadata, StringComparer.OrdinalIgnoreCase);
}
/// <summary>
/// Constructor for serialization.
/// </summary>
private ItemsStore(INodePacketTranslator translator)
{
Translate(translator);
}
/// <summary>
/// Deserializes and routes a packer to the appropriate handler.
/// </summary>
/// <param name="nodeId">The node from which the packet was received.</param>
/// <param name="packetType">The packet type.</param>
/// <param name="translator">The translator to use as a source for packet data.</param>
void INodePacketFactory.DeserializeAndRoutePacket(int nodeId, NodePacketType packetType, INodePacketTranslator translator)
{
_packetFactory.DeserializeAndRoutePacket(nodeId, packetType, translator);
}
/// <summary>
/// Factory for serialization.
/// </summary>
static internal TargetResult FactoryForDeserialization(INodePacketTranslator translator)
{
return(new TargetResult(translator));
}
void INodePacketTranslatable.Translate(INodePacketTranslator translator)
{
// all subclasses should be translateable
ErrorUtilities.ThrowInternalErrorUnreachable();
}
/// <summary>
/// Translator constructor
/// </summary>
private WorkUnitResult(INodePacketTranslator translator)
{
((INodePacketTranslatable)this).Translate(translator);
}
internal static ProjectTargetInstanceChild FactoryForDeserialization(INodePacketTranslator translator)
{
return(translator.FactoryForDeserializingTypeWithName <ProjectTargetInstanceChild>());
}
/// <summary>
/// Factory for deserialization.
/// </summary>
internal static INodePacket FactoryForDeserialization(INodePacketTranslator translator)
{
TaskHostConfiguration configuration = new TaskHostConfiguration();
configuration.Translate(translator);
return configuration;
}
/// <summary>
/// Constructor for deserialization
/// </summary>
protected LogMessagePacketBase(INodePacketTranslator translator)
{
Translate(translator);
}
/// <summary>
/// Reads/writes this packet
/// </summary>
public void Translate(INodePacketTranslator translator)
{
translator.Translate(ref _submissionId);
translator.Translate(ref _configurationId);
translator.Translate(ref _globalRequestId);
translator.Translate(ref _parentGlobalRequestId);
translator.Translate(ref _nodeRequestId);
translator.Translate(ref _targets);
translator.Translate(ref _parentBuildEventContext);
translator.Translate(ref _buildEventContext);
translator.TranslateEnum(ref _buildRequestDataFlags, (int)_buildRequestDataFlags);
// UNDONE: (Compat) Serialize the host object.
}
/// <summary>
/// Reads the logging packet from the translator.
/// </summary>
internal void ReadFromStream(INodePacketTranslator translator)
{
#if FEATURE_BINARY_SERIALIZATION
if (LoggingEventType.CustomEvent != _eventType)
{
_buildEvent = GetBuildEventArgFromId();
// The other side is telling us whether the event knows how to log itself, or whether we're going to have
// to do it manually
int packetVersion = s_defaultPacketVersion;
translator.Translate(ref packetVersion);
bool eventCanSerializeItself = true;
translator.Translate(ref eventCanSerializeItself);
if (eventCanSerializeItself)
{
MethodInfo methodInfo = null;
lock (s_readMethodCache)
{
if (!s_readMethodCache.TryGetValue(_eventType, out methodInfo))
{
Type eventDerivedType = _buildEvent.GetType();
methodInfo = eventDerivedType.GetMethod("CreateFromStream", BindingFlags.NonPublic | BindingFlags.Instance);
s_readMethodCache.Add(_eventType, methodInfo);
}
}
ArgsReaderDelegate readerMethod = (ArgsReaderDelegate)CreateDelegateRobust(typeof(ArgsReaderDelegate), _buildEvent, methodInfo);
readerMethod(translator.Reader, packetVersion);
if (_eventType == LoggingEventType.TargetFinishedEvent && _targetFinishedTranslator != null)
{
_targetFinishedTranslator(translator, (TargetFinishedEventArgs)_buildEvent);
}
}
else
{
_buildEvent = ReadEventFromStream(_eventType, translator);
}
}
else
{
string fileLocation = null;
translator.Translate(ref fileLocation);
bool resolveAssembly = false;
lock (s_lockObject)
{
if (!s_customEventsLoaded.Contains(fileLocation))
{
resolveAssembly = true;
}
// If we are to resolve the assembly add it to the list of assemblies resolved
if (resolveAssembly)
{
s_customEventsLoaded.Add(fileLocation);
}
}
#if FEATURE_APPDOMAIN
if (resolveAssembly)
{
s_resolver = new TaskEngineAssemblyResolver();
s_resolver.InstallHandler();
s_resolver.Initialize(fileLocation);
}
#endif
try
{
translator.TranslateDotNet(ref _buildEvent);
}
finally
{
#if FEATURE_APPDOMAIN
if (resolveAssembly)
{
s_resolver.RemoveHandler();
s_resolver = null;
}
#endif
}
}
#else
translator.TranslateBuildEventArgs(ref _buildEvent);
#endif
_eventType = GetLoggingEventId(_buildEvent);
}
/// <summary>
/// Translates the packet to/from binary form.
/// </summary>
/// <param name="translator">The translator to use.</param>
public void Translate(INodePacketTranslator translator)
{
// Do nothing -- this packet doesn't contain any parameters.
}
/// <summary>
/// Given a build event that is presumed to be 2.0 (due to its lack of a "WriteToStream" method) and its
/// LoggingEventType, serialize that event to the stream.
/// </summary>
private void WriteEventToStream(BuildEventArgs buildEvent, LoggingEventType eventType, INodePacketTranslator translator)
{
string message = buildEvent.Message;
string helpKeyword = buildEvent.HelpKeyword;
string senderName = buildEvent.SenderName;
translator.Translate(ref message);
translator.Translate(ref helpKeyword);
translator.Translate(ref senderName);
// It is essential that you translate in the same order during writing and reading
switch (eventType)
{
case LoggingEventType.BuildMessageEvent:
WriteBuildMessageEventToStream((BuildMessageEventArgs)buildEvent, translator);
break;
case LoggingEventType.TaskCommandLineEvent:
WriteTaskCommandLineEventToStream((TaskCommandLineEventArgs)buildEvent, translator);
break;
case LoggingEventType.BuildErrorEvent:
WriteBuildErrorEventToStream((BuildErrorEventArgs)buildEvent, translator);
break;
case LoggingEventType.BuildWarningEvent:
WriteBuildWarningEventToStream((BuildWarningEventArgs)buildEvent, translator);
break;
case LoggingEventType.ProjectStartedEvent:
WriteExternalProjectStartedEventToStream((ExternalProjectStartedEventArgs)buildEvent, translator);
break;
case LoggingEventType.ProjectFinishedEvent:
WriteExternalProjectFinishedEventToStream((ExternalProjectFinishedEventArgs)buildEvent, translator);
break;
default:
ErrorUtilities.ThrowInternalError("Not Supported LoggingEventType {0}", eventType.ToString());
break;
}
}
/// <summary>
/// Private constructor for serialization.
/// </summary>
private Toolset(INodePacketTranslator translator)
{
((INodePacketTranslatable)this).Translate(translator);
}
/// <summary>
/// Serialize ExternalProjectFinished Event Argument to the stream
/// </summary>
private void WriteExternalProjectFinishedEventToStream(ExternalProjectFinishedEventArgs externalProjectFinishedEventArgs, INodePacketTranslator translator)
{
string projectFile = externalProjectFinishedEventArgs.ProjectFile;
translator.Translate(ref projectFile);
bool succeeded = externalProjectFinishedEventArgs.Succeeded;
translator.Translate(ref succeeded);
}
/// <summary>
/// Factory for deserialization.
/// </summary>
static internal Toolset FactoryForDeserialization(INodePacketTranslator translator)
{
Toolset toolset = new Toolset(translator);
return toolset;
}
/// <summary>
/// ExternalProjectStartedEvent
/// </summary>
private void WriteExternalProjectStartedEventToStream(ExternalProjectStartedEventArgs externalProjectStartedEventArgs, INodePacketTranslator translator)
{
string projectFile = externalProjectStartedEventArgs.ProjectFile;
translator.Translate(ref projectFile);
string targetNames = externalProjectStartedEventArgs.TargetNames;
translator.Translate(ref targetNames);
}
/// <summary>
/// Implementation of the serialization mechanism.
/// </summary>
void INodePacketTranslatable.Translate(INodePacketTranslator translator)
{
translator.Translate(ref _buildId);
/* No build thread priority during translation. We specifically use the default (which is ThreadPriority.Normal) */
translator.TranslateDictionary(ref _buildProcessEnvironment, StringComparer.OrdinalIgnoreCase);
translator.TranslateCulture(ref _culture);
translator.Translate(ref _defaultToolsVersion);
translator.Translate(ref _disableInProcNode);
translator.Translate(ref _enableNodeReuse);
translator.TranslateProjectPropertyInstanceDictionary(ref _environmentProperties);
/* No forwarding logger information sent here - that goes with the node configuration */
translator.TranslateProjectPropertyInstanceDictionary(ref _globalProperties);
/* No host services during translation */
/* No loggers during translation */
translator.Translate(ref _maxNodeCount);
translator.Translate(ref _memoryUseLimit);
translator.Translate(ref _nodeExeLocation);
/* No node id during translation */
translator.Translate(ref _onlyLogCriticalEvents);
translator.Translate(ref s_startupDirectory);
translator.TranslateCulture(ref _uiCulture);
translator.Translate(ref _toolsetProvider, Microsoft.Build.Evaluation.ToolsetProvider.FactoryForDeserialization);
translator.Translate(ref _useSynchronousLogging);
translator.Translate(ref _shutdownInProcNodeOnBuildFinish);
translator.Translate(ref _logTaskInputs);
translator.Translate(ref _logInitialPropertiesAndItems);
// ProjectRootElementCache is not transmitted.
// ResetCaches is not transmitted.
// LegacyThreadingSemantics is not transmitted.
}
/// <summary>
/// Write a Build Error message into the translator
/// </summary>
private void WriteBuildErrorEventToStream(BuildErrorEventArgs buildErrorEventArgs, INodePacketTranslator translator)
{
string code = buildErrorEventArgs.Code;
translator.Translate(ref code);
int columnNumber = buildErrorEventArgs.ColumnNumber;
translator.Translate(ref columnNumber);
int endColumnNumber = buildErrorEventArgs.EndColumnNumber;
translator.Translate(ref endColumnNumber);
int endLineNumber = buildErrorEventArgs.EndLineNumber;
translator.Translate(ref endLineNumber);
string file = buildErrorEventArgs.File;
translator.Translate(ref file);
int lineNumber = buildErrorEventArgs.LineNumber;
translator.Translate(ref lineNumber);
string subCategory = buildErrorEventArgs.Subcategory;
translator.Translate(ref subCategory);
}
static public AssemblyLoadInfo FactoryForTranslation(INodePacketTranslator translator)
{
string assemblyName = null;
string assemblyFile = null;
translator.Translate(ref assemblyName);
translator.Translate(ref assemblyFile);
return Create(assemblyName, assemblyFile);
}
/// <summary>
/// Deserializes and routes a packet. Not used in the in-proc node.
/// </summary>
public void DeserializeAndRoutePacket(int nodeId, NodePacketType packetType, INodePacketTranslator translator)
{
// Not used
ErrorUtilities.ThrowInternalErrorUnreachable();
}
/// <summary>
/// Takes a serializer, deserializes the packet and routes it to the appropriate handler.
/// </summary>
/// <param name="nodeId">The node from which the packet was received.</param>
/// <param name="packetType">The packet type.</param>
/// <param name="translator">The translator containing the data from which the packet should be reconstructed.</param>
public void DeserializeAndRoutePacket(int nodeId, NodePacketType packetType, INodePacketTranslator translator)
{
if (_nodeIdToPacketFactory.ContainsKey(nodeId))
{
_nodeIdToPacketFactory[nodeId].DeserializeAndRoutePacket(nodeId, packetType, translator);
}
else
{
_localPacketFactory.DeserializeAndRoutePacket(nodeId, packetType, translator);
}
}
public void DeserializeAndRoutePacket(int nodeId, NodePacketType packetType, INodePacketTranslator translator)
{
throw new NotImplementedException();
}
/// <summary>
/// Factory method for deserialization
/// </summary>
internal static NodeShutdown FactoryForDeserialization(INodePacketTranslator translator)
{
NodeShutdown shutdown = new NodeShutdown();
shutdown.Translate(translator);
return shutdown;
}
/// <summary>
/// Performs the actual translation
/// </summary>
private void InternalTranslate(INodePacketTranslator translator)
{
translator.Translate(ref _result, WorkUnitResult.FactoryForDeserialization);
translator.Translate(ref _targetFailureDoesntCauseBuildFailure);
translator.Translate(ref _itemsStore, ItemsStore.FactoryForDeserialization);
}
/// <summary>
/// Takes a serializer, deserializes the packet and routes it to the appropriate handler.
/// </summary>
/// <param name="nodeId">The node from which the packet was received.</param>
/// <param name="packetType">The packet type.</param>
/// <param name="translator">The translator containing the data from which the packet should be reconstructed.</param>
public void DeserializeAndRoutePacket(int nodeId, NodePacketType packetType, INodePacketTranslator translator)
{
_packetFactory.DeserializeAndRoutePacket(nodeId, packetType, translator);
}
/// <summary>
/// Takes a serializer, deserializes the packet and routes it to the appropriate handler.
/// </summary>
/// <param name="nodeId">The node from which the packet was received.</param>
/// <param name="packetType">The packet type.</param>
/// <param name="translator">The translator containing the data from which the packet should be reconstructed.</param>
public void DeserializeAndRoutePacket(int nodeId, NodePacketType packetType, INodePacketTranslator translator)
{
throw new NotSupportedException("not used");
}
/// <summary>
/// Serialize the packet
/// </summary>
public void Translate(INodePacketTranslator translator)
{
throw new NotImplementedException();
}
/// <summary>
/// Translator.
/// </summary>
public void Translate(INodePacketTranslator translator)
{
translator.TranslateEnum(ref _resultCode, (int)_resultCode);
translator.TranslateEnum(ref _actionCode, (int)_actionCode);
translator.TranslateDotNet(ref _exception);
}
/// <summary>
/// Factory for serialization.
/// Custom factory is needed because this class is abstract and uses a factory pattern.
/// </summary>
internal static IElementLocation FactoryForDeserialization(INodePacketTranslator translator)
{
string file = null;
int line = 0;
int column = 0;
translator.Translate(ref file);
translator.Translate(ref line);
translator.Translate(ref column);
return Create(file, line, column);
}
/// <summary>
/// Sends the specified packet to this node.
/// </summary>
/// <param name="packet">The packet to send.</param>
public void SendData(INodePacket packet)
{
MemoryStream writeStream = new MemoryStream();
INodePacketTranslator writeTranslator = NodePacketTranslator.GetWriteTranslator(writeStream);
try
{
writeStream.WriteByte((byte)packet.Type);
// Pad for the packet length
writeStream.Write(BitConverter.GetBytes((int)0), 0, 4);
packet.Translate(writeTranslator);
// Now plug in the real packet length
writeStream.Position = 1;
writeStream.Write(BitConverter.GetBytes((int)writeStream.Length - 5), 0, 4);
#if FALSE
if (trace) // Avoid method call
{
CommunicationsUtilities.Trace(nodeId, "Sending Packet of type {0} with length {1}", packet.Type.ToString(), writeStream.Length - 5);
}
#endif
byte[] writeStreamBuffer = writeStream.GetBuffer();
for (int i = 0; i < writeStream.Length; i += MaxPacketWriteSize)
{
int lengthToWrite = Math.Min((int)writeStream.Length - i, MaxPacketWriteSize);
if ((int)writeStream.Length - i <= MaxPacketWriteSize)
{
// We are done, write the last bit asynchronously. This is actually the general case for
// most packets in the build, and the asynchronous behavior here is desirable.
#if FEATURE_APM
_serverToClientStream.BeginWrite(writeStreamBuffer, i, lengthToWrite, PacketWriteComplete, null);
#else
_serverToClientStream.WriteAsync(writeStreamBuffer, i, lengthToWrite);
#endif
return;
}
else
{
// If this packet is longer that we can write in one go, then we need to break it up. We can't
// return out of this function and let the rest of the system continue because another operation
// might want to send data immediately afterward, and that could result in overlapping writes
// to the pipe on different threads.
#if FEATURE_APM
IAsyncResult result = _serverToClientStream.BeginWrite(writeStream.GetBuffer(), i, lengthToWrite, null, null);
_serverToClientStream.EndWrite(result);
#else
_serverToClientStream.Write(writeStreamBuffer, i, lengthToWrite);
#endif
}
}
}
catch (IOException e)
{
// Do nothing here because any exception will be caught by the async read handler
CommunicationsUtilities.Trace(_nodeId, "EXCEPTION in SendData: {0}", e);
}
catch (ObjectDisposedException) // This happens if a child dies unexpectedly
{
// Do nothing here because any exception will be caught by the async read handler
}
}
