/// <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>
        /// 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);
        }

 public void DeserializeAndRoutePacket(int nodeId, NodePacketType packetType, INodePacketTranslator translator)
 {
     throw new NotImplementedException();
 }

 /// <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>
 /// Serializes or deserializes a packet.
 /// </summary>
 public void Translate(INodePacketTranslator translator)
 {
     translator.TranslateEnum(ref _reason, (int)_reason);
     translator.TranslateDotNet(ref _exception);
 }

 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>
 /// The class factory for deserialization.
 /// </summary>
 internal static BuildParameters FactoryForDeserialization(INodePacketTranslator translator)
 {
     return new BuildParameters(translator);
 }

 /// <summary>
 /// Private constructor for deserialization
 /// </summary>
 private BuildRequest(INodePacketTranslator translator)
 {
     Translate(translator);
 }

 /// <summary>
 /// Factory for deserialization.
 /// </summary>
 internal static INodePacket FactoryForDeserialization(INodePacketTranslator translator)
 {
     TaskHostConfiguration configuration = new TaskHostConfiguration();
     configuration.Translate(translator);
     return configuration;
 }

 /// <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>
 /// Translator constructor
 /// </summary>
 private WorkUnitResult(INodePacketTranslator translator)
 {
     ((INodePacketTranslatable)this).Translate(translator);
 }

 /// <summary>
 /// Factory for serialization.
 /// </summary>
 static internal WorkUnitResult FactoryForDeserialization(INodePacketTranslator translator)
 {
     return new WorkUnitResult(translator);
 }

 /// <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>
 /// 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>
 /// Private constructor for translation
 /// </summary>
 private BuildParameters(INodePacketTranslator translator)
 {
     ((INodePacketTranslatable)this).Translate(translator);
 }

        /// <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>
        /// 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.
        }

        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>
 /// Factory for serialization.
 /// </summary>
 static internal INodePacket FactoryForDeserialization(INodePacketTranslator translator)
 {
     return new BuildRequest(translator);
 }