I was working on a data synchronizing application the other day. I needed to write to a file for the export, write to a string builder for logging and analysis, and write to the console for debugging. I know that it's pretty common that I'll need to write to more than 1 text stream at the same time, so I figured I could write a quick proxy application to write to a collection of TextWriters.Please comment on this post and let me know how this TextWriterProxy article helped you.Here's what I came up with:
1 using System.Collections.Generic;
2 using System.Text;
3 using System.IO;
4
5 namespace ESG.Utilities
6 { 7 public class TextWriterProxy : TextWriter
8 { 9 // store TextWriters here
10 private List<TextWriter> _writers = new List<TextWriter>();
11
12 #region Properties
13
14 /// <summary>
15 /// This property returns Encoding.Default. The TextWriters in the
16 /// TextWriterProxy collection can have any encoding. However, this
17 /// property is required.
18 /// </summary>
19 public override Encoding Encoding { get { return Encoding.Default; } } 20
21 /// <summary>
22 /// Gets or sets the line terminator string used by the TextWriters in
23 /// the TextWriterProxy collection.
24 /// </summary>
25 public override string NewLine
26 { 27 get
28 { 29 return base.NewLine;
30 }
31
32 set
33 { 34 foreach (TextWriter tw in _writers)
35 tw.NewLine = value;
36
37 base.NewLine = value;
38 }
39 }
40
41 #endregion
42
43 #region Methods
44
45 /// <summary>
46 /// Add a new TextWriter to the TextWriterProxy collection. Setting properties
47 /// or calling methods on the TextWriterProxy will perform the same action on
48 /// each TextWriter in the collection.
49 /// </summary>
50 /// <param name="writer">The TextWriter to add to the collection</param>
51 public void Add(TextWriter writer)
52 { 53 // don't add a TextWriter that's already in the collection
54 if (!_writers.Contains(writer))
55 _writers.Add(writer);
56 }
57
58 /// <summary>
59 /// Remove a TextWriter from the TextWriterProxy collection.
60 /// </summary>
61 /// <param name="writer">The TextWriter to remove from the collection</param>
62 /// <returns>True if the TextWriter was found and removed; False if not.</returns>
63 public bool Remove(TextWriter writer)
64 { 65 return _writers.Remove(writer);
66 }
67
68
69 // this is the only Write method that needs to be overridden
70 // because all of the Write methods in a TextWriter ultimately
71 // end up calling Write(char)
72
73 /// <summary>
74 /// Write a character to the text stream of each TextWriter in the
75 /// TextWriterProxy collection.
76 /// </summary>
77 /// <param name="value">The char to write</param>
78 public override void Write(char value)
79 { 80 foreach (TextWriter tw in _writers)
81 tw.Write(value);
82
83 base.Write(value);
84 }
85
86 /// <summary>
87 /// Closes the TextWriters in the TextWriterProxy as well as the
88 /// TextWriterProxy instance and releases any system resources
89 /// associated with them.
90 /// </summary>
91 public override void Close()
92 { 93 foreach (TextWriter tw in _writers)
94 tw.Close();
95
96 base.Close();
97 }
98
99 /// <summary>
100 /// Releases all resources used by the TextWriterProxy and by the
101 /// TextWriters in the TextWriterProxy collection.
102 /// </summary>
103 /// <param name="disposing">Pertains only to the TextWriterProxy instance:
104 /// true to release both managed and unmanaged resources; false to release
105 /// only unmanaged resources.</param>
106 protected override void Dispose(bool disposing)
107 { 108 foreach (TextWriter tw in _writers)
109 tw.Dispose();
110
111 base.Dispose(disposing);
112 }
113
114 /// <summary>
115 /// Clears all buffers for each TextWriter in the TextWriterProxy
116 /// collection and causes all buffered data to be written
117 /// to the underlying device.
118 /// </summary>
119 public override void Flush()
120 { 121 foreach (TextWriter tw in _writers)
122 tw.Flush();
123
124 base.Flush();
125 }
126
127 #endregion
128 }
129 }
So far, it works great. It cleans up a lot of my code and gives me the option to write to any number of TextWriters with only one call. Further, if you are calling a method that takes a TextWriter as a parameter, you can pass the TextWriterProxy to it because it extends the TextWriter class. Here's what the usage syntax looks like:
1 // create a TextWriterProxy instance
2 TextWriterProxy proxy = new TextWriterProxy();
3
4 // add the Console.Out TextWriter
5 proxy.Add(Console.Out);
6
7 // you can still write directly to console
8 Console.WriteLine(string.Empty.PadRight(80, '='));
9
10 // add a StreamWriter for a FileStream
11 FileStream fs = new FileStream("C:\\TestExportFileAutoGen.abx", FileMode.Create); 12 StreamWriter resultWriter = new StreamWriter(fs);
13 proxy.Add(resultWriter);
14
15 // add a StringWriter for a StringBuilder
16 StringBuilder sb = new StringBuilder();
17 StringWriter resultStringWriter = new StringWriter(sb);
18 proxy.Add(resultStringWriter);
19
20 // call a method that takes a TextWriter
21 ClientSync.GenerateSessionDataExport("Sync.ServerExport", proxy); 22
23 // write directly to the TextWriterProxy
24 proxy.WriteLine("Export Complete!"); 25
26 // close all of my writers
27 proxy.Close();
And there you have it. A TextWriterProxy class to write to multiple TextWriters at once.
