using System;
using System.IO;

public class ReadWriteApp
{
    public static void Main(string[] args)
    {
        FileStream s = new FileStream("Bar.txt", FileMode.Create);
        StreamWriter w = new StreamWriter(s);
        w.Write("Hello World");
        w.Close();
   
        s = new FileStream("Bar.txt", FileMode.Open);
        StreamReader r = new StreamReader(s);
        string t;
        while ((t = r.ReadLine()) != null)
        {
            Console.WriteLine(t);
        }
        w.Close();
    }
}

   
     

   
  

using System;
using System.IO;
using System.Text;

public class TextFileTest {

    private static void Main() {
        FileStream fs = new FileStream("test.txt", FileMode.Create);

        StreamWriter w = new StreamWriter(fs, Encoding.UTF8);

        w.WriteLine(1.2M);
        w.WriteLine("string");
        w.WriteLine('!');
        w.Flush();
        w.Close();
        fs.Close();

        fs = new FileStream("test.txt", FileMode.Open);
        StreamReader r = new StreamReader(fs, Encoding.UTF8);

        Console.WriteLine(Decimal.Parse(r.ReadLine()));
        Console.WriteLine(r.ReadLine());
        Console.WriteLine(Char.Parse(r.ReadLine()));

        r.Close();
        fs.Close();
    }
}

   
     

   
 
#region License and Copyright
/* -------------------------------------------------------------------------
 * Dotnet Commons IO
 *
 *
 * This library is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU Lesser General Public License as published by 
 * the Free Software Foundation; either version 2.1 of the License, or 
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License 
 * for more details. 
 *
 * You should have received a copy of the GNU Lesser General Public License 
 * along with this library; if not, write to the 
 * 
 * Free Software Foundation, Inc., 
 * 59 Temple Place, 
 * Suite 330, 
 * Boston, 
 * MA 02111-1307 
 * USA 
 * 
 * -------------------------------------------------------------------------
 */
#endregion

using System;
using System.IO;

namespace Dotnet.Commons.IO
{
  /// <summary>
  /// This class provides basic facilities for manipulating temporary files.
  /// </summary>
  /// <remarks>
  /// This class includes code developed by
    /// ThoughtWorks, Inc. (<a href="http://www.thoughtworks.com/">http://www.thoughtworks.com/</a>).
  /// </remarks>
  public sealed class TempFileUtils
  {
    private TempFileUtils() {}


    /// <summary>
    /// Create a temporary directory based on an object type
    /// </summary>
    /// <param name="obj"></param>
    /// <returns></returns>
    public static string CreateTempDir(object obj)
    {
      return CreateTempDir(obj.GetType().FullName);
    }


    /// <summary>
    /// Create a temporary directory based on a given directory name
    /// </summary>
    /// <param name="dirname"></param>
    /// <returns></returns>
    public static string CreateTempDir(string dirname)
    {
      return CreateTempDir(dirname, true);
    }

    /// <summary>
    /// Create a temporary directory given a directory name
    /// </summary>
    /// <param name="dirname"></param>
    /// <param name="overwrite">overwrite the entire directory if set to true</param>
    /// <returns></returns>
    public static string CreateTempDir(string dirname, bool overwrite)
    {      
      if (overwrite)
      {
        DeleteTempDir(dirname);
      }
      return Directory.CreateDirectory(GetTempPath(dirname)).FullName;
    }

    /// <summary>
    /// Get the temporary directory name, which is a combine of the current
    /// system temporary directory and a supplied directory name.
    /// </summary>
    /// <param name="dirname"></param>
    /// <returns></returns>
    public static string GetTempPath(string dirname)
    {
      return Path.Combine(Path.GetTempPath(), dirname);
    }

    /// <summary>
    /// Get the temporary directory path, which is a combine of the current
    /// system temporary directory (eg. C:Temp)
    /// and an object whose Type is to be used as a temporary folder name.
    /// </summary>
    /// <param name="obj">object to be used for creating a temporary folder name</param>
    /// <returns></returns>
    public static string GetTempPath(object obj)
    {
      return GetTempPath(obj.GetType().FullName);
    }


    /// <summary>
    /// Get the full file path of a file in the temporary directory.
    /// </summary>
    /// <param name="dirname"></param>
    /// <param name="filename"></param>
    /// <returns></returns>
    public static string GetTempFilePath(string dirname, string filename)
    {
      return Path.Combine(GetTempPath(dirname),filename);
    }


    /// <summary>
    /// Clear the entire temporary directory and delete the directory when it is empty.
    /// </summary>
    /// <param name="dirname"></param>
    /// <returns></returns>
    public static bool DeleteTempDir(string dirname)
    {
      string tempDir = GetTempPath(dirname);
      if (Directory.Exists(tempDir))
      {
        Directory.Delete(tempDir, true); 
        return true;
      }
      else
        return false;
    }
    
    /// <summary>
    /// Clear the entire temporary directory and delete the directory when it is empty.
    /// </summary>
    /// <param name="obj"></param>
    /// <returns></returns>
    public static bool DeleteTempDir(object obj)
    {
      return DeleteTempDir(obj.GetType().FullName);
    }

    /// <summary>
    /// Check if a file exists in a temporary directory.
    /// </summary>
    /// <param name="dirname"></param>
    /// <param name="filename"></param>
    /// <returns></returns>
    public static bool TempFileExists(string dirname, string filename)
    {
      return File.Exists(TempFileUtils.GetTempFilePath(dirname, filename));
    }

    /// <summary>
    /// Create a file in a temporary directory
    /// </summary>
    /// <param name="tempDir"></param>
    /// <param name="filename"></param>
    /// <returns></returns>
    public static string CreateTempTextFile(string tempDir, string filename)
    {    
      string path = CreateTempDir(tempDir, false);        
      path = Path.Combine(path, filename);      
      using (File.CreateText(path))
      {
        return path;
      }
    }

    /// <summary>
    /// Create a text file in a temporary directory and text write the content to the file
    /// </summary>
    /// <param name="tempDir"></param>
    /// <param name="filename"></param>
    /// <param name="content"></param>
    /// <returns></returns>
    public static string CreateTempTextFile(string tempDir, string filename, string content)
    {    
      string path = CreateTempDir(tempDir, false);        
      path = Path.Combine(path, filename);      
      using (StreamWriter stream = File.CreateText(path))
      {
        stream.Write(content);
      }
      return path;
    }

    /// <summary>
    /// Create a binary file in a temporary directory and write the binary content to the file
    /// </summary>
    /// <param name="tempDir"></param>
    /// <param name="filename"></param>
    /// <param name="content">binary content as an array of bytes</param>
    /// <returns></returns>
    public static string CreateTempBinaryFile(string tempDir, string filename, byte[] content)
    {
      string path = CreateTempDir(tempDir, false);        
      path = Path.Combine(path, filename);      
      using (Stream fs = new FileStream(path, FileMode.Create))
      {
        fs.Write(content, 0, content.Length);
        fs.Close();
      }      
      return path;
    }


    /// <summary>
    /// Update a temporary text file and append content to the end of the file.
    /// </summary>
    /// <param name="filename"></param>
    /// <param name="content"></param>
    public static void UpdateTempTextFile(string filename, string content)
    {
      using (StreamWriter writer = File.AppendText(filename)) 
      {
        writer.Write(content);
      }
    }

    /// <summary>
    /// Delete a file 
    /// </summary>
    /// <param name="path"></param>
    public static void DeleteTempFile(string path)
    {
      if (path != null &amp;&amp; File.Exists(path))
      {
        File.Delete(path);
      }
    }

    /// <summary>
    /// Get the current System temporary directory
    /// </summary>
    /// <returns></returns>
    public static string GetSystemTempDirectory()
    {
      return Path.GetTempPath();
    }


    /// <summary>
    /// Get the directory setting from the Environment variable "TEMP"
    /// </summary>
    /// <returns></returns>
    public static string GetEnvTempDirectory()
    {
      return Environment.GetEnvironmentVariable("TEMP");
    }
  }
}

   
     

using System;
using System.IO;

class Class1 {
public static string Pad(string s, int len) {
string temp = s;
for (int i = s.Length; i < len; ++i) temp = "0" + temp; return temp; } static void Main(string[] args) { StreamReader sr = new StreamReader("c:a.txt"); string line = ""; int nCounter = 0; int nOffset = 0; while ((line = sr.ReadLine()) != null) { for (int i = 0; i < line.Length; ++i) { int c = (int)line[i]; string fmt = String.Format("{0:x}", c); if (fmt.Length == 1) fmt = Pad(fmt, 2); if (nOffset % 16 == 0) { string offsetFmt = nOffset.ToString(); System.Console.Write(Pad(offsetFmt, 5) + ": "); } System.Console.Write(fmt + " "); if (nCounter == 15) { System.Console.Write(" "); nCounter = 0; } else nCounter++; nOffset++; } } } } [/csharp]

   


using System;
using System.IO;
using System.Text;
class StringReadWriteApp {
    static void Main(string[] args) {
        StringWriter w = new StringWriter();
        w.WriteLine("Sing a song of {0} pence", 6);
        string s = "A pocket full of rye";
        w.Write(s);
        w.Write(w.NewLine);
        w.Write(String.Format(4 + " and " + 20 + " blackbirds"));
        w.Write(new StringBuilder(" baked in a pie"));
        w.WriteLine();
        w.Close();
        Console.WriteLine(w);
    }
}
           
          

   
 

// crudwork
// Copyright 2004 by Steve T. Pham (http://www.crudwork.com)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with This program.  If not, see <http://www.gnu.org/licenses/>.

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.CodeDom.Compiler;
using System.Text.RegularExpressions;

namespace crudwork.Utilities
{
  /// <summary>
  /// File Utility
  /// </summary>
  public static class FileUtil
  {


    #region Stream methods
    /// <summary>
    /// Read from stream
    /// </summary>
    /// <param name="s"></param>
    /// <returns></returns>
    public static string[] ReadStream(Stream s)
    {
      List<string> results = new List<string>();
      using (StreamReader r = new StreamReader(s))
      {
        while (!r.EndOfStream)
        {
          results.Add(r.ReadLine());
        }
        r.Close();
      }
      return results.ToArray();
    }

    /// <summary>
    /// Write to stream
    /// </summary>
    /// <param name="s"></param>
    /// <param name="value"></param>
    public static void WriteStream(Stream s, string value)
    {
      byte[] byteArray = ASCIIEncoding.UTF8.GetBytes(value);
      s.Write(byteArray, 0, byteArray.Length);
      s.Flush();
      s.Close();
    }
    #endregion
   }
}

   
     

///////////////////////////////////////////////////////////////////////////////////////////////
//
// This File is Part of the CallButler Open Source PBX (http://www.codeplex.com/callbutler
//
// Copyright (c) 2005-2008, Jim Heising
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation and/or
// other materials provided with the distribution.
//
// * Neither the name of Jim Heising nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////////////////////////

using System;
using System.IO;
using System.Collections;

namespace WOSI.Utilities
{
public class FifoStream : Stream
{
private const int BlockSize = 65536;
private const int MaxBlocksInCache = (3 * 1024 * 1024) / BlockSize;

private int m_Size;
private int m_RPos;
private int m_WPos;
private Stack m_UsedBlocks = new Stack();
private ArrayList m_Blocks = new ArrayList();

private byte[] AllocBlock()
{
byte[] Result = null;
Result = m_UsedBlocks.Count > 0 ? (byte[])m_UsedBlocks.Pop() : new byte[BlockSize];
return Result;
}
private void FreeBlock(byte[] block)
{
if (m_UsedBlocks.Count < MaxBlocksInCache) m_UsedBlocks.Push(block); } private byte[] GetWBlock() { byte[] Result = null; if (m_WPos < BlockSize && m_Blocks.Count > 0)
Result = (byte[])m_Blocks[m_Blocks.Count – 1];
else
{
Result = AllocBlock();
m_Blocks.Add(Result);
m_WPos = 0;
}
return Result;
}

// Stream members
public override bool CanRead
{
get { return true; }
}
public override bool CanSeek
{
get { return false; }
}
public override bool CanWrite
{
get { return true; }
}
public override long Length
{
get
{
lock (this)
return m_Size;
}
}
public override long Position
{
get { throw new InvalidOperationException(); }
set { throw new InvalidOperationException(); }
}
public override void Close()
{
Flush();
}
public override void Flush()
{
lock (this)
{
foreach (byte[] block in m_Blocks)
FreeBlock(block);
m_Blocks.Clear();
m_RPos = 0;
m_WPos = 0;
m_Size = 0;
}
}
public override void SetLength(long len)
{
throw new InvalidOperationException();
}
public override long Seek(long pos, SeekOrigin o)
{
throw new InvalidOperationException();
}
public override int Read(byte[] buf, int ofs, int count)
{
lock (this)
{
int Result = Peek(buf, ofs, count);
Advance(Result);
return Result;
}
}
public override void Write(byte[] buf, int ofs, int count)
{
lock (this)
{
int Left = count;
while (Left > 0)
{
int ToWrite = Math.Min(BlockSize – m_WPos, Left);
Array.Copy(buf, ofs + count – Left, GetWBlock(), m_WPos, ToWrite);
m_WPos += ToWrite;
Left -= ToWrite;
}
m_Size += count;
}
}

// extra stuff
public int Advance(int count)
{
lock (this)
{
int SizeLeft = count;
while (SizeLeft > 0 && m_Size > 0)
{
if (m_RPos == BlockSize)
{
m_RPos = 0;
FreeBlock((byte[])m_Blocks[0]);
m_Blocks.RemoveAt(0);
}
int ToFeed = m_Blocks.Count == 1 ? Math.Min(m_WPos – m_RPos, SizeLeft) : Math.Min(BlockSize – m_RPos, SizeLeft);
m_RPos += ToFeed;
SizeLeft -= ToFeed;
m_Size -= ToFeed;
}
return count – SizeLeft;
}
}
public int Peek(byte[] buf, int ofs, int count)
{
lock (this)
{
int SizeLeft = count;
int TempBlockPos = m_RPos;
int TempSize = m_Size;

int CurrentBlock = 0;
while (SizeLeft > 0 && TempSize > 0)
{
if (TempBlockPos == BlockSize)
{
TempBlockPos = 0;
CurrentBlock++;
}
int Upper = CurrentBlock < m_Blocks.Count - 1 ? BlockSize : m_WPos; int ToFeed = Math.Min(Upper - TempBlockPos, SizeLeft); Array.Copy((byte[])m_Blocks[CurrentBlock], TempBlockPos, buf, ofs + count - SizeLeft, ToFeed); SizeLeft -= ToFeed; TempBlockPos += ToFeed; TempSize -= ToFeed; } return count - SizeLeft; } } } } [/csharp]