C# System.IO.TextWriter.WriteLine方法代码示例

 internal static void PrintStackTrace(this Exception e, TextWriter writer)
 {
     writer.WriteLine(e.ToString());
     string trace = e.StackTrace ?? string.Empty;
     foreach (string line in trace.Split('\n', '\r'))
     {
         if (!string.IsNullOrEmpty(line))
             writer.WriteLine("        " + line);
     }
 }

		public override void Emit(IProcessorArchitecture arch, TextWriter writer)
		{
			EmitRegisters(arch, "// DataOut:", DataOut, writer);
            writer.WriteLine();
			EmitFlagGroup(arch, "// DataOut (flags):", grfOut, writer);
            writer.WriteLine();
            SymbolicIn.Emit(arch, "// SymbolicIn:", writer);
            writer.WriteLine();
            EmitLocals("// LocalsOut:", writer);
            if (TerminatesProcess)
                writer.WriteLine("// Terminates process");
		}

 protected override void DumpChildren(TextWriter Out, uint Depth)
 {
     foreach (VEntry e in Fields.Values) {
     Indent(Out, Depth);
     Out.Write(e.Name);
     Out.WriteLine(" =");
     e.Value.Dump(Out, Depth+1);
     }
 }

 protected override void DumpChildren(TextWriter Out, uint Depth)
 {
     foreach (Element e in Elements) {
     e.First.Dump(Out, Depth);
     if (e.ArrowPos != null) {
         Indent(Out, Depth+1);
         Out.WriteLine("->");
         e.Second.Dump(Out, Depth+1);
     }
     }
 }

 /// <summary>
 /// Runs the test.
 /// </summary>
 /// <param name="name">Name.</param>
 /// <param name="testMethod">Test method.</param>
 /// <param name="output">Output.</param>
 public static void RunTest(string name, Action testMethod, TextWriter output = null)
 {
     if (output == null)
         output = Console.Out;
     string _oldNL = output.NewLine;
     try
     {
         output.WriteLine(_runTestFormatStart, name);
         testMethod();
         output.WriteLine(_runTestFormatSuccess, name);
     }
     catch (FaultException<ExceptionDetail> ex)
     {
         output.WriteLine(_runTestFormatError, name);
         output.WriteLine(_runTestFormatException, ex.GetType().FullName, ex.Message, ex.StackTrace);
         foreach (DictionaryEntry de in ex.Data)
             output.Write("\t{0} = {1}\n", de.Key.ToString(), de.Value.ToString());
         int indent = 0;
         for (ExceptionDetail detail = ex.Detail; detail != null; detail = detail.InnerException)
             output.WriteLine(string.Concat(" ------ Inner Exception ------\n",
                 string.Format(_runTestFormatException, detail.Type, detail.Message, detail.StackTrace))
                 .Replace("\n", string.Concat("\n", new string(' ', ++indent * 2))).TrimStart('\n'));
     }
     catch (Exception ex)
     {
         output.WriteLine(_runTestFormatError, name);
         output.WriteLine(_runTestFormatException, ex.GetType().FullName, ex.Message, ex.StackTrace);
         foreach (DictionaryEntry de in ex.Data)
             output.Write("\t{0} = {1}\n", de.Key.ToString(), de.Value.ToString());
         int indent = 0;
         for (Exception innerEx = ex.InnerException; innerEx != null; innerEx = innerEx.InnerException)
             output.WriteLine(string.Concat("\n ------ Inner Exception ------\n",
                 string.Format(_runTestFormatException, innerEx.GetType().FullName, innerEx.Message, innerEx.StackTrace))
                 .Replace("\n", string.Concat("\n", new string(' ', ++indent * 2))).TrimStart('\n'));
     }
     finally
     {
         output.NewLine = _oldNL;			// you COULD wrap this in a using() if you write a class implementing IDisposable with this line in Dispose()
     }
 }

 public void Dump(TextWriter Out, uint Depth)
 {
     Indent(Out, Depth);
     Out.WriteLine(DumpHeader());
     DumpChildren(Out, Depth+1);
 }

 private void DisplayVersion(TextWriter stdout)
 {
     stdout.WriteLine("Pickles version {0}", Assembly.GetExecutingAssembly().GetName().Version);
 }

        private void EmitLocals(string caption, TextWriter writer)
        {
            if (StackVarsOut.Count <= 0)
                return;

            writer.Write(caption);
            SortedList<string, string> list = new SortedList<string, string>();
            foreach (KeyValuePair<Storage, int> de in StackVarsOut)
            {
                Storage id = (Storage)de.Key;
                StringWriter sb = new StringWriter();
                id.Write(sb);
                string sName = sb.ToString();

                list[sName] = string.Format("{0}({1})", sName, de.Value);
            }
            foreach (string s in list.Values)
            {
                writer.Write(" ");
                writer.Write(s);
            }
            writer.WriteLine();
        }

 /// <summary>
 /// Writes flow state that is true on entry to the basic block.
 /// </summary>
 /// <param name="arch"></param>
 /// <param name="writer"></param>
 public void WriteBefore(IProcessorArchitecture arch, TextWriter writer)
 {
     SymbolicIn.Emit(arch, "// SymbolicIn:", writer);
     writer.WriteLine();
 }

 /// <summary>
 /// Writes flow state that is true on exit from the basic block.
 /// </summary>
 /// <param name="arch"></param>
 /// <param name="writer"></param>
 public void WriteAfter(IProcessorArchitecture arch, TextWriter writer)
 {
     EmitRegisters(arch, "// DataOut:", DataOut, writer);
     writer.WriteLine();
     EmitFlagGroup(arch, "// DataOut (flags):", grfOut, writer);
     writer.WriteLine();
     EmitLocals("// LocalsOut:", writer);
     if (TerminatesProcess)
         writer.WriteLine("// Terminates process");
 }

        private static void Stats(TextWriter writer)
        {
            MemoryManager memmgr = MemoryManager.Global;
            writer.WriteLine("-- Used: {0}", memmgr.UsedBytes);
            writer.WriteLine("-- Allocated: {0}", memmgr.AllocatedBytes);

            VirtualMemoryManager vmm = memmgr as VirtualMemoryManager;
            if (vmm != null)
                vmm.Dump(writer);
        }

 public virtual void PrintGrammar( TextWriter output )
 {
     ANTLRTreePrinter printer = new ANTLRTreePrinter( new Antlr.Runtime.Tree.CommonTreeNodeStream( grammarTree ) );
     //printer.setASTNodeClass( "org.antlr.tool.GrammarAST" );
     try
     {
         string g = printer.toString( this, false );
         output.WriteLine( g );
     }
     catch ( RecognitionException re )
     {
         ErrorManager.Error( ErrorManager.MSG_SYNTAX_ERROR, re );
     }
 }

            public TimedWriteLine(System.IO.TextWriter output, string testName = null)
            {
                this.output = output;

                this._testName = testName ??
                    new StackTrace(1, fNeedFileInfo: false).GetFrame(0).GetMethod().Name;

                output.WriteLine(_testName);
                _sw.Start();
            }

 public static void InitLog()
 {
     Writer = new System.IO.StreamWriter("log.log");
     Writer.WriteLine("----------log started------------");
 }

        private void LogSuspiciousResults()
        {
            LogWriter = System.IO.File.CreateText("E:\\temp\\sorata\\result.txt");
            foreach (MIPSEvaluator.Result res in MIPS.Results)
            {
                bool log = false;
                for (int i = 0; i < res.Arguments.Length; i++)
                    if ((res.Arguments[i] >> 24) == 0x04 || (res.Arguments[i] >> 24) == 0x05 || (res.Arguments[i] >> 24) == 0x06)
                        log = true;

                if (log) LogWriter.WriteLine(res.ToString());
            }
            LogWriter.Close();
        }