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;
}
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return false;
}
}
/// <summary>
/// Returns a bool
conversion of the passed in string
/// </summary>
/// <param
name="stream">string to
convert/coerce</param>
/// <returns>
/// bool representation of
passed-in string
/// </returns>
public
static bool
CoerceToBool(string
stream)
{
try
{
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 false;
case m_n:
return false;
case m_y:
return true;
case m_No:
return false;
case m_Yes:
return true;
default:
return false;
}
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return false;
}
}
/// <summary>
/// Evaluates whether
passed-in string contains any characters/
/// digits/symbols. Trims spaces
before
checking.
/// </summary>
/// <param
name="stream">string to check</param>
/// <returns>
/// bool indicating whether
argument is void of characters/
/// digits/symbols
///</returns>
public
static bool
IsEmpty(string
stream)
{
try
{
if (stream == null
|| stream == string.Empty
|| stream.Trim() == string.Empty)
return true;
else
return false;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return false;
}
}
/// <summary>
/// Checks each character
of the string for any character other
/// than a digit, or a dollar
sign or a percentage sign. If any
/// are found, returns false
indicating that the stream is NOT
///
a number
/// </summary>
/// <param
name="stream">
/// The stream of
characters (string) to check
/// </param>
/// <returns>
/// True/False value
indicating whether the string can be
/// coerced to a number
/// </returns>
public
static bool
IsNumber(string
stream)
{
try
{
if (stream == null
|| stream == string.Empty)
return false;
string character = string.Empty;
//set a
string up of all characters that
may indicate
//that
the stream
is a number, or a formatted number:
string validCharacters = m_Digits +
m_Period +
m_DollarSign + m_Comma;
for (int
i = 0;
i < stream.Length; i++)
{
character = stream.Substring(i, 1);
if
(!validCharacters.Contains(character))
return false;
}
return true;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return false;
}
}
/// <summary>
/// Checks the string to
see whether it is a number & if it is,
/// then it checks whether
there is formatting applied to that #
/// </summary>
/// <param
name="stream">
/// The stream of
characters (string) to check
/// </param>
/// <returns>
/// True/False value
indicating whether the string is a number
/// that is formatted (contains
digits and number formatting)
/// </returns>
public
static bool
IsFormattedNumber(string
stream)
{
try
{
if (stream == null
|| stream == string.Empty)
return false;
string character = string.Empty;
//set a
string up of all characters that
may indicate
that
//the
stream
is a number, or a formatted number:
string validCharacters = m_Digits +
m_Period +
m_DollarSign + m_PercentSign +
m_Comma;
for (int
i = 0;
i < stream.Length; i++)
{
character = stream.Substring(i, 1);
if
(!validCharacters.Contains(character))
//the
stream contains non-numeric
characters:
return false;
}
//at this
point, each single character is a
number OR
an
//allowable symbol, but we
must see whether those
//characters
contain a
formatting character:
string formattingCharacters =
m_DollarSign +
m_PercentSign + m_Comma;
for (int
i = 0;
i < stream.Length; i++)
{
if
(formattingCharacters.Contains(character))
return true;
}
//still
here? then the stream is a number,
but NOT a
//formatted number
return false;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return false;
}
}
/// <summary>
/// Checks whether string can be coerced into a
DateTime value
/// </summary>
/// <param
name="stream">The string to check/// </param>
/// <returns>
/// bool indicating
whether stream can be converted to a date
/// </returns>
public
static bool
IsDate(string
stream)
{
try
{
if (stream == null
|| stream == string.Empty)
return false;
DateTime checkDate = new DateTime();
bool dateType = true;
try
{
checkDate = DateTime.Parse(stream);
}
catch
{
dateType = false;
}
return dateType;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return false;
}
}
/// <summary>
///
Checks the string to
see whether it is a number and if it is,
/// then
it checks whether
there is a decimal in that number.
/// </summary>
/// <param name="stream">
/// The
stream of
characters (string) to check
/// </param>
/// <returns>
///
True/False value
indicating whether the string is a
///
double---must be a
number, and include a decimal
/// in
order to pass the
test
/// </returns>
public static
bool IsDouble(string
stream)
{
try
{
if (stream == null
|| stream == string.Empty)
return false;
if (!IsNumber(stream))
return false;
//at this
point each character is a number
OR an
allowable
//symbol;
we
must see whether the string
holds the
decimal:
if (stream.Contains(m_Period))
return true;
//still
here? the stream is a #,
but does
NOT have a decimal
return false;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return false;
}
}
/// <summary>
///
Checks string to see if
it matches a TypeCode string and returns
/// that
TypeCode, or
returns TypeCode.Empty if there is no match
/// </summary>
/// <param name="dataTypeString">
///
String representation
of a TypeCode (string, int, bool...)
/// </param>
/// <returns>TypeCode
that maps to the dataTypeString</returns>
public static
TypeCode GetDataType(string
dataTypeString)
{
try
{
switch (dataTypeString.ToLower())
{
// todo:
isn't there a better way for guid?
case m_GUID:
return TypeCode.Object;
case m_Boolean1:
return TypeCode.Boolean;
case m_Boolean2:
return TypeCode.Boolean;
case m_Byte:
return TypeCode.Byte;
case m_Char:
return TypeCode.Char;
case m_DateTime:
return TypeCode.DateTime;
case m_DBNull:
return TypeCode.DBNull;
case m_Decimal:
return TypeCode.Decimal;
case m_Double:
return TypeCode.Double;
case m_Empty:
return TypeCode.Empty;
case m_Int16_1:
return TypeCode.Int16;
case m_Int16_2:
return TypeCode.Int16;
case m_Int32_1:
return TypeCode.Int32;
case m_Int32_2:
return TypeCode.Int32;
case m_Int32_3:
return TypeCode.Int32;
case m_Int64_1:
return TypeCode.Int64;
case m_Int64_2:
return TypeCode.Int64;
case m_Object:
return TypeCode.Object;
case m_SByte:
return TypeCode.SByte;
case m_Single:
return TypeCode.Single;
case m_String:
return TypeCode.String;
case m_UInt16:
return TypeCode.UInt16;
case m_UInt32:
return TypeCode.UInt32;
case m_UInt64:
return TypeCode.UInt64;
default:
return TypeCode.Empty;
}
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return TypeCode.Empty;
}
}
#endregion
#region
StringConversions
/// <summary>
///
Returns a date, as
coerced from the string argument. Will raise
/// an
error, if the string
cannot be coerced
///
----so, use IsDate in
this same class FIRST
/// </summary>
/// <param name="stream">string to get date value from</param>
/// <returns>a
DateTime
object</returns>
public static
DateTime GetDate(string
stream)
{
DateTime dateValue = new DateTime();
try
{
dateValue = DateTime.Parse(stream);
return dateValue;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return dateValue;
}
}
/// <summary>
///
Returns an int, as
coerced from the string argument.
/// Will
raise an error, if
the string cannot be coerced
///
----so, use IsNumber in
this same class FIRST
/// </summary>
/// <param name="stream">string to get int value from</param>
/// <returns>an
int
object</returns>
public static
int GetInteger(string
stream)
{
try
{
int number = 0;
if (!IsNumber(stream))
return number;
//still
here? check to see if it is
formatted:
if (IsFormattedNumber(stream))
{
//it's
formatted; replace the
format
characters
//with
nothing (retain the decimal so as
not to
change
//the
intended
value
stream = stream.Replace(m_Comma, string.Empty);
stream = stream.Replace(m_DollarSign, string.Empty);
stream = stream.Replace(m_PercentSign, string.Empty);
}
//we've
removed superfluous formatting
characters, if
they
//did exist, now
let's round it/convert it, and return
it:
number = Convert.ToInt32(stream);
return number;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return 0;
}
}
/// <summary>
///
Returns a double, as
coerced from the string argument.
/// Will
raise an error, if
the string cannot be coerced
///
----so, use IsNumber in
this same class FIRST
/// </summary>
/// <param name="stream">string to get double value from</param>
/// <returns>a
double
object</returns>
public static
double GetDouble(string
stream)
{
try
{
double number = 0;
if (!IsNumber(stream))
return number;
//still
here? check to see if it is
formatted:
if (IsFormattedNumber(stream))
{
//it's
formatted; replace the
format
characters
//with
nothing (retain the decimal so as not to change
//the
intended
value)
stream = stream.Replace(m_Comma, string.Empty);
stream = stream.Replace(m_DollarSign, string.Empty);
stream =
stream.Replace(m_PercentSign, string.Empty);
}
//we've
removed superfluous formatting
characters, if
they
//did exist, now
let's round it/convert it, and return
it:
number = Convert.ToDouble(stream);
return number;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return 0;
}
}
#endregion
#region
StringEdits
/// <summary>
///
Iterates thru an entire
string, and sets the first letter of
/// each
word to
uppercase, and all
ensuing letters to lowercase
/// </summary>
/// <param name="stream">The
string to alter the
case of</param>
/// <returns>
/// Same
string w/uppercase initial letters & others as lowercase
/// </returns>
public static
string MixCase(string
stream)
{
try
{
string newString = string.Empty;
string character = string.Empty;
string preceder = string.Empty;
for (int
i = 0;
i < stream.Length; i++)
{
character = stream.Substring(i, 1);
if (i > 0)
{
//look at
the character immediately before
current
preceder = stream.Substring(i - 1, 1);
//remove
white space character from
predecessor
if (preceder.Trim() == string.Empty)
//the
preceding character WAS white
space, so
//we'll
change the current character to
UPPER
character = character.ToUpper();
else
//the
preceding character was NOT white
space,
//we'll
force the current character to
LOWER
character = character.ToLower();
}
else
//index
is 0, thus we are at the first
character
character = character.ToUpper();
//add the
altered character to the new
string:
newString += character;
}
return newString;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return null;
}
}
/// <summary>
///
Iterates thru a string, and removes anything set to clean.
///
Except---Does NOT remove anything in exceptionsToAllow
/// </summary>
/// <param name="stream">
/// The
string to clean</param>
/// <returns>
/// The
same string,
missing all elements that were set to clean
///
(except when a
character was listed in exceptionsToAllow)
/// </returns>
public static
string Clean(string
stream, bool cleanWhiteSpace,
bool cleanDigits, bool
cleanLetters, string
exceptionsToAllow)
{
try
{
string newString = string.Empty;
string character = string.Empty;
string blessed = string.Empty;
if (!cleanDigits)
blessed += m_Digits;
if (!cleanLetters)
blessed += m_Letters;
blessed += exceptionsToAllow;
//we set
the comparison string to lower
//and
will compare each character's lower
case
version
//against
the comparison string, without
//altering
the original case of the
character
blessed = blessed.ToLower();
for (int
i = 0;
i < stream.Length; i++)
{
character = stream.Substring(i, 1);
if
(blessed.Contains(character.ToLower()))
//add the
altered character to the new
string:
newString += character;
else if
(character.Trim() == string.Empty
&&
!cleanWhiteSpace)
newString += character;
}
return newString;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return null;
}
}
#endregion
#region
StringLocators
/// <summary>
///
Parses a file system or
url path, and locates the file name
/// </summary>
/// <param name="fullPath">
///
String indicating a
file system or url path to a file
/// </param>
/// <param name="includeFileExtension">
///
Whether to return file extension in addition to file name
/// </param>
/// <returns>
/// File
name, if found,
and extension if requested, and located
/// </returns>
public static
string GetFileNameFromPath(string
fullPath,
bool includeFileExtension)
{
try
{
bool url =
fullPath.Contains(m_ForwardSlash);
string search = string.Empty;
if (url)
search = m_ForwardSlash;
else
search = m_BackSlash;
string portion = string.Empty;
int decimals =
GetKeyCharCount(fullPath,
m_Period);
if (decimals >= 1)
//get all
text to the RIGHT of the LAST
slash:
portion = GetExactPartOfString(fullPath, search, false,
false, false);
else
return string.Empty;
if (includeFileExtension)
return portion;
search = m_Period;
portion = GetExactPartOfString(portion, search, false,
true,
false);
return portion;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return null;
}
}
/// <summary>
///
Parses a url or file
stream string, to get and return the
/// path
portion (sans the
file name and extension)
/// </summary>
/// <param name="fullPath">
/// A
string indicating a
file system path or a url. Can
///
contain a file
name/extension.
/// </param>
/// <returns>
/// The
original path minus
the file name and extension,
/// if it
had existed, with
no extension will return
/// the
original string,
plus an optional slash
/// </returns>
public static
string GetFolderPath(string
fullPath)
{
try
{
bool url =
fullPath.Contains(m_ForwardSlash);
string slash = string.Empty;
if (url)
slash = m_ForwardSlash;
else
slash = m_BackSlash;
string fileName =
GetFileNameFromPath(fullPath,
true);
//use
tool to return all text to the LEFT
of the file
name
string portion =
GetStringBetween(fullPath, string.Empty,
fileName);
//add the
pertinent slash to the end of the
string;
if (portion.Length > 0 &&
portion.Substring(
portion.Length - 1, 1) != slash)
portion += slash;
return portion;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return null;
}
}
/// <summary>
///
Useful to pinpoint
exact string between whatever
///
characters/string you
wish to grab text from
/// </summary>
/// <param name="stream">
///
string from which to
cull subtext from
/// </param>
/// <param name="from">
///
string that precedes
the text you are looking for
/// </param>
/// <param name="to">
///
string that follows the
text you are looking for
/// </param>
/// <returns>
/// The
string between
point x and point y
/// </returns>
public static
string GetStringBetween(string
stream, string from,
string
to)
{
try
{
string subField = string.Empty;
subField = RightOf(stream, from);
subField = LeftOf(subField, to);
return subField;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return null;
}
}
/// <summary>
/// Will
return the text to
the LEFT of indicated substring
/// </summary>
/// <param name="stream">
///
string from which to
cull a portion of text
/// </param>
/// <param name="stringToStopAt">
///
string that indicates
what char or string to stop at
/// </param>
/// <returns>
/// The
string to the left
of point x (stringToStopAt)
/// </returns>
public static
string LeftOf(string
stream, string stringToStopAt)
{
try
{
if (stringToStopAt == null
|| stringToStopAt == string.Empty)
return stream;
int stringLength = stream.Length;
int findLength =
stringToStopAt.Length;
stringToStopAt = stringToStopAt.ToLower();
string temp = stream.ToLower();
int i = temp.IndexOf(stringToStopAt);
if ((i <= -1) &&
(stringToStopAt !=
temp.Substring(0, findLength))
|| (i == -1))
return stream;
string result = stream.Substring(0,
i);
return result;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return null;
}
}
/// <summary>
/// Will
return the text to
the RIGHT of whatever substring you indicate
/// </summary>
/// <param name="stream">
///
string from which to
cull a portion of text
/// </param>
/// <param name="stringToStartAfter">
///
string that indicates
what char or string to start after
/// </param>
/// <returns>
/// The
string to the right
of point x (stringToStartAfter)
/// </returns>
public static
string RightOf(string
stream, string stringToStartAfter)
{
try
{
if (stringToStartAfter == null || stringToStartAfter == string.Empty)
return stream;
stringToStartAfter = stringToStartAfter.ToLower();
string
temp =
stream.ToLower();
int findLength =
stringToStartAfter.Length;
int i =
temp.IndexOf(stringToStartAfter);
if ((i <= -1) &&
(stringToStartAfter
!= temp.Substring(0, findLength))
|| (i == -1))
return stream;
string result =
stream.Substring(i + findLength, stream.Length - (i + findLength));
return result;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return null;
}
}
/// <summary>
///
Searches a string for
every single instance of the passed-in
/// field
delimiters, and
returns all the values between those
///
delimiters, as a List
object
/// </summary>
/// <param name="streamToSearch">string to search</param>
/// <param name="leftFieldDelimiter">string to start at</param>
/// <param name="rightFieldDelimiter">string to stop at</param>
/// <returns>A
List
object of strings</returns>
public static
List<string>
GetEachFieldValue(string
streamToSearch,
string leftFieldDelimiter, string rightFieldDelimiter)
{
string search = streamToSearch;
string field = string.Empty;
List<string>
fields = new List<string>();
while (!string.IsNullOrEmpty(search)
&& search.Contains(leftFieldDelimiter)
&& search.Contains(rightFieldDelimiter))
{
//get the
val and add to list
field = GetStringBetween(search, leftFieldDelimiter,
rightFieldDelimiter);
if (!string.IsNullOrEmpty(field))
fields.Add(field);
//shorten
the search string and continue
search = RightOf(search, field + rightFieldDelimiter);
}
return fields;
}
/// <summary>
///
Instructions on using
arguments:
/// Set
firstInstance =
true, to stop at first instance of locateChar
/// If
firstInstance =
false, then the LAST instance of locateChar will be used
/// Set
fromLeft = true, to
return string from the left of locateChar
/// If
fromLeft = false,
then the string from the right of locateChar
/// will
be returned.
/// Set
caseSensitive to
true/false for case-sensitivity
///
EXAMPLES:
///
GetPartOfString('aunt
jemima', 'm', 'true', 'true')
/// will
return 'aunt je'
///
GetPartOfString('aunt
jemima', 'm', 'true', 'false')
/// </summary>
/// <param name="stream">
/// The
string from which
to cull a portion of text
/// </param>
/// <param name="locateChar">
/// The
character or string
that is the marker
/// for
which to grab text
(from left or right depending
/// on
other argument)
/// </param>
/// <param name="firstInstance">
///
Whether or not to get
the substring from the first
///
encountered instance of
the locateChar argument
/// </param>
/// <param name="fromLeft">
///
Whether to search from
the left. If set to false,
/// then
the string will be
searched from the right.
/// </param>
/// <param name="caseSensitive">
///
Whether to consider
case (upper/lower)
/// </param>
/// <returns>
/// A
portion of the input
string, based on ensuing arguments
/// </returns>
public static
string GetExactPartOfString(string
stream, string locateChar,
bool firstInstance, bool
fromLeft, bool caseSensitive)
{
try
{
stream = stream.ToString();
string tempStream = string.Empty;
string tempLocateChar = string.Empty;
if (!caseSensitive)
{ //case
doesn't matter, convert to lower:
tempStream = stream.ToLower();
tempLocateChar = locateChar.ToLower();
}
//default
charCnt to 1; for first inst of
locateChar:
int charCount = 1;
if (firstInstance == false)
//get
number of times char exists in string:
if (caseSensitive)
charCount = GetKeyCharCount(stream, locateChar);
else
charCount = GetKeyCharCount(tempStream, tempLocateChar);
//get
position of first/last inst of char
in str:
int position = 0;
if (caseSensitive)
position = GetCharPosition(stream, locateChar, charCount);
else
position = GetCharPosition(tempStream, tempLocateChar, charCount);
string result = string.Empty;
//chk
that character exists in str:
if (position == -1)
result = string.Empty;
else
{
//char
exists, proceed:
int streamLength = stream.Length;
if (fromLeft == true)
//return
string from left:
result = stream.Substring(0, position);
else
{
//return
string from right:
position += 1;
result = stream.Substring(position, streamLength - position);
}
}
return result;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return null;
}
}
/// <summary>
///
Returns the number of
times, that the key character is found
/// in
the stream string
/// </summary>
/// <param name="stream">
///
string in which to
locate key character
/// </param>
/// <param name="keyChar">
/// key
character: the
string or char to count inside the stream
/// </param>
/// <returns>
/// The
number of times the
string or char was located
/// </returns>
public static
int GetKeyCharCount(string
stream, string keyChar)
{
try
{
string current;
int keyCount = 0;
for (int
i = 0; i < stream.Length; i++)
{
current = stream.Substring(i, 1);
if (current == keyChar)
keyCount += 1;
}
if (keyCount <= 0)
return -1;
else
return keyCount;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return -1;
}
}
/// <summary>
/// Is
CASE-SENSITIVE
///
Returns x position of
sChar in sstream, where x = iCharInst.
/// If:
getCharPos('pineapple', 'p', 3) Then: 6 is returned
/// </summary>
/// <param name="stream">
///
string in which to
pinpoint the character (or string) position
/// </param>
/// <param name="charToPinpoint">character or string to locate</param>
/// <param name="whichCharInstance">
///
Number indicating WHICH
instance of the character/string to locate
/// </param>
/// <returns>
/// The
index of the
character or string found inside the input string.
/// Will
return -1 if the
string/character is not found, or if the
///
instance number is not
found
/// </returns>
public static
int GetCharPosition(string
stream, string charToPinpoint, int whichCharInstance)
{
try
{
string current;
int keyCharCount = 0;
for (int
i = 0;
i < stream.Length; i++)
{
current = stream.Substring(i, 1);
//was
BLOCKED SCRIPT sCurr = sstream.charAt(i);
if (current == charToPinpoint)
{
keyCharCount
+= 1;
if (keyCharCount == whichCharInstance)
return i;
}
}
return -1;
}
catch (Exception
ex)
{
//ErrorTool.ProcessError(ex);
return -1;
}
}
#endregion
}
}
Until
next time..................