Writes objects to an underlying output stream that have been decorated with a TypeIdAttribute. This class cannot be inherited.
Inheritance: DisposableBase, IObjectWriter
コード例 #1
0
        public void output_is_not_closed_when_writer_is_disposed()
        {
            var output = new MemoryStream();

            using(var writer = new DecoratedObjectWriter(output)) { }

            Assert.DoesNotThrow(() => output.Position = 0);
            output.Dispose();
            Assert.Throws<ObjectDisposedException>(() => output.Position = 0);
        }
コード例 #2
0
        private void Fixup(string srcPath, string dstPath)
        {
            Message message;
            var stats = new Statistics();
            var classifier = new MessageClassifier();
            var translator = new LiveMessageTranslator();

            using(var input = File.OpenRead(srcPath))
            using(var reader = new DecoratedObjectReader(input))
            using(var output = File.Create(dstPath))
            using(var writer = new DecoratedObjectWriter(output))
            {
                while(true)
                {
                    if((message = reader.Read<Message>()) == null)
                    {
                        break;
                    }
                    ++stats.Read;
                    if(classifier.IsTranslated(message))
                    {
                        ++stats.OrgTranslated;
                        continue;
                    }
                    writer.Write(message);
                    ++stats.Written;
                    if((message = translator.Translate(message)) != null)
                    {
                        if(message is CompositeMessage)
                        {
                            foreach(var component in ((CompositeMessage)message).Messages)
                            {
                                writer.Write(component);
                                ++stats.Written;
                                ++stats.NewTranslated;
                            }
                        }
                        else
                        {
                            writer.Write(message);
                            ++stats.Written;
                            ++stats.NewTranslated;
                        }
                    }
                }
                writer.Write(null);
            }

            stats.Print();
        }
コード例 #3
0
 private void ReadMessagesTask()
 {
     Log.Info("read task started");
     try
     {
         using(var buffer = new MemoryStream(4096))
         using(var writer = new DecoratedObjectWriter(buffer))
         {
             Message message;
             do
             {
                 ThrowIfCancellationRequested();
                 message = _messageReader.Read();
                 buffer.SetLength(0L);
                 writer.WriteMessage(message);
                 _pendingMessages.Add(buffer.ToArray());
                 _wakeUpMainTask.Set();
             } while(message != null);
             _pendingMessages.CompleteAdding();
             _wakeUpMainTask.Set();
         }
         Log.InfoFormat("completed reading messages");
     }
     catch(OperationCanceledException) { }
     catch(Exception exc)
     {
         Log.Fatal(exc);
         throw;
     }
     finally
     {
         Log.Info("read task stopped");
     }
 }
コード例 #4
0
 private void Accept(IAsyncResult iar)
 {
     using(var client = _lisenter.EndAcceptTcpClient(iar))
     using(var writer = new DecoratedObjectWriter(client.GetStream()))
     {
         foreach(var message in Messages)
         {
             writer.WriteMessage(message);
         }
         writer.Write(null);
     }
 }