A couple of the methods I have used most in the following code segment return a List object, or an ArrayList of text found inside a file to inspect.
Other methods that I've used a lot edit an existing file from a specific line number, or retrieve the full text from a specific file.
I've overloaded the AddToFile() method to allow varying ways to edit a file. Let me know if you extend this tool; I like collaboration.
-aendenne
/*
* Author: aendenne
* Email: AutomateAnything@yahoo.com
* Create Date: April 21, 2007
* Last Modified Date: September 25,
2007
* Version: 1.1
*/
using
System;
using
System.Collections;
using
System.Collections.Generic;
using System.IO;
namespace YourNamespace.Tools
{
/// <summary>
/// Class that stores static methods to create,
access,
/// (especially read from) and manipulate files
/// </summary>
/// <remarks>
/// does NOT include good error-handling. this is
not a
/// recommended practice, please extend the
try/catch
statements...
/// i will post a simple error tool soon.
/// </remarks>
public
class FileTool
{
/// <summary>
/// string
constant to store message to return
/// if file
exists, and user does NOT wish to override
/// </summary>
private
const string
m_FileExistsMessage =
"The
file already exists: ";
/// <summary>
/// Gets
string indicating the current directory
/// </summary>
/// <returns>string
value of the current directory</returns>
public static
string
GetCurrentDirectory()
{
try
{
return
Directory.GetCurrentDirectory().ToString();
}
catch
(Exception ex)
{
//ErrorTool.ProcessError(ex);
//return
null;
throw
(ex);
}
}
/// <summary>
/// Creates a
file in path suggested, and writes the
/// contents
to that file
/// </summary>
/// <param
name="path">
/// string
value indicating path (include file name)
/// to store
new file in
/// </param>
/// <param
name="contents">
/// string
value storing the contents to write
/// to the new
file
/// </param>
/// <param
name="overwrite">
/// bool value
indicating whether to replace file in path
/// if one
already exists at that location
/// </param>
public static
void
WriteNewFile(string path,
string
contents, bool overwrite)
{
try
{
CreateNewFile(path, overwrite);
AddToFile(path, contents, true);
}
catch (Exception ex)
{
//ErrorTool.ProcessError(ex);
//return;
throw
(ex);
}
}
/// <summary>
/// Creates a
file at the indicated path
/// </summary>
/// <param
name="path">
/// string
value indicating where to store
/// the new
file (include file name)
/// </param>
/// <param
name="overwrite">
/// bool value
indicating whether to replace file in path
/// if one
already exists at that location
/// </param>
/// <returns>
/// bool value
indicating whether file was created
/// </returns>
public static bool CreateNewFile(string path, bool overwrite)
{
try
{
if
(File.Exists(path)
&& !overwrite)
{
//Exception
ex = new Exception(m_FileExistsMessage);
//ErrorTool.ProcessError(ex);
return false;
}
FileStream
file = new FileStream(
path, FileMode.Create);
file.Close();
return true;
}
catch
(Exception ex)
{
//ErrorTool.ProcessError(ex);
//return false;
throw(ex);
}
}
/// <summary>
/// Deletes
the file indicated from the system
/// </summary>
/// <param
name="path">
/// string
value indicating full file path to delete
/// </param>
private
static void
m_DeleteFile(string path)
{
try
{
if
(!File.Exists(path))
return;
File.Delete(path);
}
catch
(Exception ex)
{
//ErrorTool.ProcessError(ex);
//return;
throw
(ex);
}
}
/// <summary>
/// Checks
path to be sure it's a file, and if so,
/// makes that
file writeable (may have been read-only...)
/// </summary>
/// <param
name="path">
/// string
path/filename to set as editable
/// </param>
private
static void
m_MakeEditable(string path)
{
try
{
if
(!File.Exists(path))
{
return;
//filepath doesn't exist
}
FileAttributes
attributes = File.GetAttributes(path);
if
((attributes & FileAttributes.Directory)
!= 0)
{
return;
//it's a directory/folder
}
attributes = FileAttributes.Normal;
File.SetAttributes(path,
attributes);
}
catch
(Exception ex)
{
//ErrorTool.ProcessError(ex);
//return;
throw
(ex);
}
}
/// <summary>
/// Opens and
existing file, and adds to its contents
/// </summary>
/// <param
name="path">
/// string
value: full path/filename to add to
/// </param>
/// <param
name="appendage">
/// string
value: stream of characters/words to add
/// </param>
/// <param
name="newLine">
/// bool value
indicating whether to start at a new line
/// </param>
public static
void
AddToFile(string path,
string
appendage, bool newLine)
{
try
{
StreamWriter
writer = File.AppendText(path);
if
(newLine)
{
writer.WriteLine();
}
writer.Write(appendage);
writer.Close();
}
catch
(Exception ex)
{
//ErrorTool.ProcessError(ex);
//return;
throw
(ex);
}
}
/// <summary>
/// Opens a
file and adds the supplied text
/// to that
file at the specified line number
/// </summary>
/// <param
name="path">
/// String
indicating the file path, including
/// the name
of the file
/// </param>
/// <param
name="textToInsert">
/// String to
insert/add to the file
/// </param>
/// <param
name="lineNumber">
/// Zero-based
line number----if the text should
/// be added
at line 10, then pass 9
/// </param>
public static
void
AddToFile(string path,
string
textToInsert, int lineNumber)
{
try
{
ArrayList
lines = GetLinesFromFile(path);
if
(lines.Count > lineNumber)
{
lines.Insert(lineNumber, textToInsert);
}
else
{
lines.Add(textToInsert);
}
StreamWriter
writer = new StreamWriter(path);
foreach
(string lineToWrite in
lines)
{
writer.WriteLine(lineToWrite);
}
writer.Close();
}
catch
(Exception ex)
{
//ErrorTool.ProcessError(ex);
//return;
throw
(ex);
}
}
/// <summary>
/// Opens a
file and adds the supplied text
/// to that
file after the first line found,
/// that
contains the textToInsertAfter string.
/// Will add
at 0 (first line), if not found at all.
/// </summary>
/// <param
name="path">
/// String
indicating the file path, including
/// the name
of the file
/// </param>
/// <param
name="textToInsert">
/// String to
insert/add to the file
/// </param>
/// <param
name="textToInsertAfter">
/// Text to
place the new string after, will be
/// inserted
on the next line
/// </param>
public static
void
AddToFile(string path,
string
textToInsert, string
textToInsertAfter)
{
try
{
ArrayList
lines = GetLinesFromFile(path);
int
location = 0;
int
currentLine = 0;
foreach
(string lineToRead in
lines)
{
if
(lineToRead.Contains(textToInsertAfter))
{
location = currentLine
+ 1;
}
currentLine += 1;
}
lines.Insert(location,
textToInsert);
StreamWriter
writer = new StreamWriter(path);
foreach
(string lineToWrite in
lines)
{
writer.WriteLine(lineToWrite);
}
writer.Close();
}
catch
(Exception ex)
{
//ErrorTool.ProcessError(ex);
//return;
throw
(ex);
}
}
/// <summary>
/// Opens and existing
file, and adds to its contents
/// (adds at
the end of prior contents)
/// </summary>
/// <param
name="path">
/// string
value: full path/filename to add to
/// </param>
/// <param name="appendage">
/// string
value: stream of characters/words to add
/// </param>
public static
void
AddToFile(string path, string
appendage)
{
try
{
if
(!File.Exists(path))
{
CreateNewFile(path, true);
}
AddToFile(path, appendage, true);
}
catch
(Exception ex)
{
//ErrorTool.ProcessError(ex);
//return;
throw
(ex);
}
}
/// <summary>
/// Closes an
open FileStream object
/// </summary>
/// <param
name="fileToClose">FileStream to
close</param>
public static
void
CloseFile(FileStream
fileToClose)
{
try
{
fileToClose.Close();
}
catch
(Exception ex)
{
//ErrorTool.ProcessError(ex);
//return;
throw
(ex);
}
}
/// <remarks>
/// USES A METHOD FROM StringTool.cs!
/// Will not compile/execute without that file,
/// so remove/comment this method if you don't have
it
/// </remarks>
/// <summary>
/// Checks for
existence of a path
/// </summary>
/// <param
name="directoryPath">
/// string
value of path to check for
/// </param>
/// <returns>
/// bool value
indicating whether the requested path exists
/// </returns>
public static
bool
CheckForDirectory(string
directoryPath)
{
try
{
string
path = StringTool.GetFolderPath(directoryPath);
if (!Directory.Exists(path))
{
return
false;
}
else
{
return
true;
}
}
catch
(Exception ex)
{
//ErrorTool.ProcessError(ex);
//return;
throw
(ex);
}
}
/// <remarks>
/// USES A METHOD FROM StringTool.cs!
/// Will not compile/execute without that file,
/// so remove/comment this method if you don't have
it
/// </remarks>
/// <summary>
/// Creates a
directory (folder)
/// </summary>
/// <param
name="directoryPath">
/// string
value of path to create
/// </param>
public static
void
CreateDirectory(string directoryPath)
{
try
{
string
path = StringTool.GetFolderPath(directoryPath);
if (Directory.Exists(directoryPath))
{
return;
}
Directory.CreateDirectory(path);
}
catch
(Exception ex)
{
//ErrorTool.ProcessError(ex);
//return;
throw
(ex);
}
}
/// <remarks>
/// USES A METHOD FROM StringTool.cs!
/// Will not compile/execute without that file,
/// so remove/comment this method if you don't have
it
/// </remarks>
/// <summary>
/// Creates a
directory (folder) inside the path indicated
/// </summary>
/// <param
name="directoryPath">
/// string
value of path to create
/// </param>
/// <param
name="folderName">
/// string
name of the folder to create
/// </param>
public static
void
CreateDirectory(string directoryPath,
string
folderName)
{
try
{
string
path = StringTool.GetFolderPath(directoryPath);
path = path + folderName;
if
(Directory.Exists(directoryPath))
{
return;
}
Directory.CreateDirectory(path);
}
catch
(Exception ex)
{
//ErrorTool.ProcessError(ex);
//return;
throw
(ex);
}
}
/// <summary>
/// Grabs an
ArrayList of lines from filepath indicated
/// </summary>
/// <param
name="path">
/// string
value of filepath to get lines from
/// </param>
/// <returns>
/// ArrayList
object containing each string line in the file
/// </returns>
public static
ArrayList
GetLinesFromFile(string path)
{
try
{
ArrayList
lines = new ArrayList();
StreamReader
reader = new StreamReader(path);
string
currentLine = string.Empty;
while
((currentLine = reader.ReadLine()) != null)
{
lines.Add(currentLine);
}
reader.Close();
return
lines;
}
catch
(Exception ex)
{
//ErrorTool.ProcessError(ex);
//return;
throw
(ex);
}
}
/// <summary>
/// Grabs a
List of string lines from filepath indicated
/// </summary>
/// <param
name="path">
/// string
value of filepath to get lines from
/// </param>
/// <returns>
/// List
object containing each string line in the file
/// </returns>
public static
List<string> GetListOfLinesFromFile(string path)
{
try
{
List<string> lines = new
List<string>();
StreamReader
reader = new StreamReader(path);
string currentLine = string.Empty;
while
((currentLine = reader.ReadLine()) != null)
{
lines.Add(currentLine);
}
reader.Close();
return
lines;
}
catch
(Exception ex)
{
//ErrorTool.ProcessError(ex);
//return;
throw
(ex);
}
}
/// <summary>
/// Grabs all
text from filepath indicated
/// </summary>
/// <param
name="path">
/// string
value of filepath to get text from
/// </param>
/// <returns>
/// string
(just one) of all text in file
/// </returns>
public static
string
GetFullFileText(string path)
{
try
{
StreamReader
reader = new StreamReader(path);
string
text = reader.ReadToEnd();
reader.Close();
return
text;
}
catch
(Exception ex)
{
//ErrorTool.ProcessError(ex);
//return;
throw
(ex);
}
}
}
}
Not much verbiage necessary
to introduce a code file I'll paste below. It's all about string manipulation. There are
useful string functions in VB, and I have mimicked/extended some of
these.
The file includes string conversion functions, some data type identification functions,
some string edit functions,
and some string locater functions.
All methods in the class are static (one can call them without object
instantiation).
My favorites:
GetEachFieldValue:
Easily
grabs a list by parsing with any characters the developer chooses
GetExactPartOfString:
Extricates
a portion of a full stream of characters, based on a left and right
bound character of the developer's choice
GetFileNameFromPath:
Returns
just the filename, from inside
a full path. Developer can choose whether to include the extension, or
not.
Clean:
Purges
a string of any characters the developer wishes to remove. There is an
exceptions argument that allows fine-tuning.
/*
* Author: aendenne
* Email: AutomateAnything@yahoo.com
* Create Date: April 21, 2007
* Last Modified Date: August 14,
2007
* Version: 2.1
*/
using
System;
using
System.Collections.Generic;
namespace
YourNamespace.Tools
{
/// <summary>
/// Static class that exposes many string methods,
/// useful for string evaluation and edits
/// </summary>
public
static class
StringTool
{
#region
StringConstantsToHelpWithComparisons
private
const string
m_Letters = "abcdefghijklmnopqrstuvwxyz";
private
const string
m_Digits = "0123456789";
private
const string
m_ForwardSlash = "/";
private
const string
m_BackSlash = "\\";
private
const string
m_Period = ".";
private
const string
m_DollarSign = "$";
private
const string
m_PercentSign = "%";
private
const string
m_Comma = ",";
private
const string
m_Yes = "yes";
private
const string
m_No = "no";
private
const string
m_True = "true";
private
const string
m_False = "false";
private
const string
m_1 = "1";
private
const string
m_0 = "0";
private
const string
m_y = "y";
private
const string
m_n = "n";
#endregion
#region
DataTypeStringConstants
public
const string
m_GUID = "guid";
public
const string
m_Boolean1 = "boolean";
public
const string
m_Boolean2 = "bool";
public
const string
m_Byte = "byte";
public
const string
m_Char = "char";
public
const string
m_DateTime = "datetime";
public
const string
m_DBNull = "dbnull";
public
const string
m_Decimal = "decimal";
public
const string
m_Double = "double";
public
const string
m_Empty = "empty";
public
const string
m_Int16_1 = "int16";
public
const string
m_Int16_2 = "short";
public
const string
m_Int32_1 = "int32";
public
const string
m_Int32_2 = "int";
public
const string
m_Int32_3 = "integer";
public
const string
m_Int64_1 = "int64";
public
const string
m_Int64_2 = "long";
public
const string
m_Object = "object";
public
const string
m_SByte = "sbyte";
public
const string
m_Single = "single";
public
const string
m_String = "string";
public
const string
m_UInt16 = "uint16";
public
const string
m_UInt32 = "uint32";
public
const string
m_UInt64 = "uint64";
#endregion
#region
MethodsThatCheckDataType
/// <summary>
/// Evaluates whether
passed-in string can be converted to a bool
/// </summary>
/// <param
name="stream">string to check</param>
/// <returns>
/// bool indicating whether
stream is a bool (0, 1, true/True,
/// false/False)
/// </returns>
public
static bool
IsStandardBool(string
stream)
{
try
{
if (stream == null
|| stream == string.Empty)
return false;
stream = stream.Trim().ToLower();
switch (stream)
{
case m_0:
return true;
case m_1:
return true;
case m_True:
return true;
case m_False:
return true;
default:
return false;
}
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return false;
}
}
/// <summary>
/// Evaluates whether
string can can be COERCED to a bool
/// </summary>
/// <param
name="stream">string to check</param>
/// <returns>
/// bool indicating whether
argument is a standard or custom bool
/// (0, 1, true/True,
false/False) OR (y/Y, yes/Yes, n/N, no/NO)
/// </returns>
public
static bool
IsFriendlyBool(string
stream)
{
try
{
if (stream == null
|| stream == string.Empty)
return false;
stream = stream.Trim().ToLower();
switch (stream)
{
case m_0:
return true;
case m_1:
return true;
case m_True:
return true;
case m_False:
return true;
case m_n:
return true;
case m_y:
return true;
case m_No:
return true;
case m_Yes:
return true;
default:
return false;
&n