Files and Directories

Size of Folder in Bytes (Deep or Shallow)

2009-05-30T07:04:00.000-07:00

using System;
using System.IO;

public class Folder {
private static double sizeInBytes;

public static double Size(string directory, bool deep) {
DirectoryInfo dir = new DirectoryInfo(directory);
foreach(FileInfo f in dir.GetFiles()) {
sizeInBytes += f.Length;
}
if(deep) {
foreach(DirectoryInfo d in dir.GetDirectories()) {
Size(d.FullName, deep);
}
}
return sizeInBytes;
}

static void Main() {
Console.WriteLine("The total folder size in bytes is {0}", Folder.Size(@"c:\sonysys", true));
}
}

Ini File class

2009-05-30T07:03:00.001-07:00

using System;
using System.Collections.Generic;
using System.Text;

//This namespace is for easy INI reading ad writing, designed to be practically errorless, you dont need to worry about things like if .exists .add .set etc, just .set
//XML is similar to INI, but not as simple and easily modified by humans
//INI is ideal for server settings etc.

//any keys found NOT under a group header will be put in group MAIN

//WARNING: THIS INI FILE DOES NOT SUPPORT COMMENTS
//FORMAT IS AS FOLLOWS:
//[GROUP]
//item1=True
//item2=some text here
//[GROUP2]
//soemthing=3
using System.IO;
namespace EasyINI
{
//A class to handle all file IO for multiple savable settings
//This class will create on-demand, an INI file of settings, keys need not be added before being assigned
public class INIFile
{
//this class handles the saving and loading of the file
protected string fname;
protected List inigroupnames;
protected List inigroups;

public INIFile(string @filename)
{
fname = filename;
inigroups = new List();
inigroupnames = new List();
reloadFile();
}

public INIGroup Group(string name)
{
name = name.ToUpper();
int i = inigroupnames.IndexOf(name);
if (i == -1)
{
return null;
}
else
{
return inigroups[i];
}
}

public void setValue(string group, string key, string value)
{
addGroup(group); //create the group (if not already existing)
Group(group).setValue(key, value); //set the value
}

public string getValue(string group, string key)
{
group = group.ToUpper();
key = key.ToLower();
if (inigroupnames.IndexOf(group) == -1)
{
return string.Empty;
}
else
{
return Group(group).getValue(key);
}
}

public void addGroup(string group)
{
group = group.ToUpper();
if (inigroupnames.IndexOf(group) == -1)
{
inigroupnames.Add(group);
inigroups.Add(new INIGroup(this));
}
}

public bool saveFile() //bool returned indicates the success of the save process
{
try
{
FileStream strm = new FileStream(fname, FileMode.Create, FileAccess.Write);
StreamWriter W = new StreamWriter(strm);
if(inigroupnames.Count > 0)
{
for (int i = 0; i < inigroupnames.Count; i++)
{
INIGroup grp = inigroups[i];
if (grp.getCount() > 0) //only save this group if it has content
{
W.WriteLine("[" + inigroupnames[i] + "]");
for (int k = 0; k < grp.getCount(); k++)
W.WriteLine(grp.getKey(k) + @"=" + grp.getValue(k));
W.WriteLine(" ");
}
}
}
W.Close();
strm.Close();
return true;
}
catch
{
return false;
}
}

public void reloadFile()
{
inigroups.Clear();
inigroupnames.Clear();

if (File.Exists(fname))
{
string strline;
string currentGroup = "MAIN";
FileStream strm = new FileStream(fname, FileMode.Open, FileAccess.Read);
StreamReader R = new StreamReader(strm);
while (R.EndOfStream != true)
{
strline = R.ReadLine(); //get line
if (strline.StartsWith("["))
{
//this is a group header
currentGroup = strline.Substring(1, strline.Length - 2);
}
else
{
//this is a key=value entry
string[] keyval = strline.Split('=');
if (keyval.Length == 2)
setValue(currentGroup, keyval[0], keyval[1]);
}
}
R.Close();
strm.Close();
}
}
}

//This sub-class is used by the INIFile class, it handles the keys and values within an INI group
public class INIGroup
{
//this class handles the settings of values
protected INIFile owner;
public List inikeys;
public List inivalues;
public INIGroup(INIFile parent)
{
owner = parent;
inikeys = new List();
inivalues = new List();
}

public void setValue(string key, string value)
{
key = key.ToLower();
int i = inikeys.IndexOf(key);
if (i == -1)
{
inikeys.Add(key);
inivalues.Add(value);
}
else
{
inivalues[i] = value;
}
owner.saveFile();
}

public string getValue(string key)
{
key = key.ToLower();
int i = inikeys.IndexOf(key);
if (i == -1)
{
return string.Empty;
}
else
{
return inivalues[i];
}
}

public string getKey(int index)
{
if (index > -1 && index < getCount())
{
return inikeys[index];
}
else
{
//out of range
throw new IndexOutOfRangeException("Index was out of range, must be non-negative and less than total key count");
}
}

public string getValue(int index)
{
if (index > -1 && index < getCount())
{
return inivalues[index];
}
else
{
//out of range
throw new IndexOutOfRangeException("Index was out of range, must be non-negative and less than total key count");
}
}

public int getCount()
{
return inikeys.Count;
}

}
}

Browse For Folder in .NET 1.0

2009-05-30T07:02:00.001-07:00

//Have To Reference System.Design.dll

/*
Usage:
-
BrowseForFolder browse = new BrowseForFolder();
string savePath = browse.Show();
*/

using System;
using System.Windows.Forms;
using System.Windows.Forms.Design;
namespace iCode_Library.NET
{

public class BrowseForFolder: FolderNameEditor
{

FolderNameEditor.FolderBrowser dirBrowser;
public BrowseForFolder()
{
dirBrowser = new FolderNameEditor.FolderBrowser();
}
public string Show()
{
//set the Description label
dirBrowser.Description = "Select Folder";
dirBrowser.ShowDialog(); //show the Windows
return dirBrowser.DirectoryPath + @"\"; // return whatever path choosen
}

}
}

File Content To Array

2009-05-30T07:01:00.002-07:00

private ArrayList fileContentToArrayList(string filePath)
{

System.Collections.ArrayList arrListLines = new System.Collections.ArrayList();
//read the file content one by one
try
{
StreamReader fl = new StreamReader(filePath, System.Text.Encoding.ASCII);
//StreamReader fl = File.OpenText(filePath,);
string line = "";
while((line = fl.ReadLine()) != null )
{
arrListLines.Add(line);
}

}
catch(Exception e)
{
System.Windows.Forms.MessageBox.Show(e.Message, "Failed reading file");
return null;
}
return arrListLines;
}

Reading a text file with StreamReader

2009-05-30T07:01:00.001-07:00

// Reading a text file with StreamReader

private void ImportCountries()
{
string delimiter = ",";
string fileName = @"c:\countrylist3.csv";

StreamReader sr = new StreamReader(fileName);

try
{
while (sr.Peek() >= 0)
{
string r = sr.ReadLine();
string[] items = r.Split(delimiter.ToCharArray());
}
}
finally
{
sr.Close();
}
}

Write file to response stream

2009-05-30T07:00:00.001-07:00

// Wrtites temporary file to response stream and then delete

Response.Clear();
Response.ContentType = "image/tiff";
Response.AddHeader("Content-Disposition", "attachment; filename=imageFile.tiff");
Response.WriteFile(tempPath);
Response.Flush();
Response.Close();

if(File.Exists(tempPath))
{
File.Delete(tempPath);
}

Short/Long path conversion

2009-05-30T06:59:00.003-07:00

// Short/Long path conversion

// Long To Short Path/File Name:

[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern int GetShortPathName(
[MarshalAs(UnmanagedType.LPTStr)] string path,
[MarshalAs(UnmanagedType.LPTStr)] StringBuilder shortPath,
int shortPathLength
);

// ...

StringBuilder shortPath = new StringBuilder(1024);
GetShortPathName(textBoxFilename.Text, shortPath, shortPath.Capacity);

// Short To Long Path/File Names:

[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern int GetLongPathName(
[MarshalAs(UnmanagedType.LPTStr)]
string path,
[MarshalAs(UnmanagedType.LPTStr)]
StringBuilder longPath,
int longPathLength
);

Get file extension

2009-05-30T06:59:00.001-07:00

// Get file extension

FileInfo temp = new FileInfo(fileName);
if (temp.Extension.ToUpper() == ".DOC")
{
// ...
}

Wipe file

2009-05-30T06:58:00.001-07:00

// Wipe file

public static void Wipe(string fileName)
{
if (File.Exists(fileName))
{
File.SetAttributes(fileName, FileAttributes.Normal);
Random rnd = new Random((int)DateTime.Now.Ticks);
FileStream file = File.Open(fileName, FileMode.Open, FileAccess.Write);
int fileLength = (int)file.Length;
int offset = 0;

const int BUFFER_SIZE = 100;
byte[][] buffers = new byte[4][];
buffers[0] = new byte[BUFFER_SIZE];
buffers[1] = new byte[BUFFER_SIZE];
buffers[2] = new byte[BUFFER_SIZE];
buffers[3] = new byte[BUFFER_SIZE];

rnd.NextBytes(buffers[0]);
rnd.NextBytes(buffers[2]);
for (int i = 0; i < BUFFER_SIZE; i++)
{
buffers[1][i] = 0;
buffers[3][i] = 0xff;
}

while (offset < (fileLength - BUFFER_SIZE))
{
for (int i = 0; i < buffers.Length; i++)
{
file.Seek(offset, SeekOrigin.Begin);
file.Write(buffers[0], 0, BUFFER_SIZE);
file.Flush();
}
offset += 100;
}

for (int i = 0; i < buffers.Length; i++)
{
file.Seek(offset, SeekOrigin.Begin);
file.Write(buffers[0], 0, fileLength - offset);
file.Flush();
}

file.Close();

file = File.Open(fileName, FileMode.Truncate, FileAccess.Write);
file.Flush();
file.Close();

File.Delete(fileName);
}
}

File lock

2009-05-30T06:57:00.000-07:00

// Lock files so that no one else can access it:

// --------
// Method 1
// --------
string filename = "c:\\sample.htm";
FileStream stream = new FileStream(filename, FileMode.Open, FileAccess.Read,
FileShare.None); //locks file

// ...

stream.Close(); //unlocks file

// --------
// Method 1
// --------

string filename = "c:\\sample.htm";
FileStream stream = File.Open(filename, FileMode.Open);
stream.Lock(0, stream.Length); //locks file

// ...

stream.Unlock(0, stream.Length); //unlocks file

List Files in a Directory in C#

2009-05-30T06:56:00.000-07:00

// List Files in a Directory in C#

// You can get an array of files (their path) by using:
fileArray = Directory.GetFiles(yourPath);

// You can display all of the images in a directory by using:
ArrayList pics = new ArrayList();

string myFile;
string code;
const string YOUR_DIRECTORY = "/images/";

foreach (myFile in Directory.GetFiles(Server.MapPath(YOUR_DIRECTORY), "*.gif"))
{
image = YOUR_DIRECTORY + Path.GetFileName(myFile);
code = <"img src=\"" + image + "\">";

// add the image to your ArrayList
pics.Add(code);
}

// Bind the pics to a DataList
dlImages.DataSource = pics;
dlImages.DataBind;

Set a file as read-only

2009-05-30T06:51:00.000-07:00

public void SetReadOnly(string fullName, bool readOnly)
{
FileInfo filePath = new FileInfo(fullName);
try
{

if (filePath.Exists)
{
FileAttributes attr;
if (readOnly)
{
attr = (FileAttributes)
(filePath.Attributes | FileAttributes.ReadOnly);
}
else
{
attr = (FileAttributes)
(filePath.Attributes - FileAttributes.ReadOnly);
}
File.SetAttributes(filePath.FullName, attr);
}

}
catch (IOException e)
{
System.Diagnostics.Debug.WriteLine(e.Source);
System.Diagnostics.Debug.WriteLine(e.Message);
System.Diagnostics.Debug.WriteLine(e.StackTrace);
}
}

Write a binary file

2009-05-30T06:50:00.000-07:00

public bool WriteBinaryFile(string filePath, byte[] contents)
{
bool okok = true;

try
{
using (FileStream fs = new FileStream(filePath, FileMode.CreateNew))
{
using (BinaryWriter w = new BinaryWriter(fs))

{
w.Write(contents);
}

}
}
catch (IOException e)
{
okok = false;
}

return okok;

}

Recursively Search Directory for a File

2009-05-30T06:45:00.000-07:00

System.Collections.ArrayList files = new System.Collections.ArrayList();
DirSearch(@"C:",ref files);
//Method to Search Directory for specified file Type.Paste it outside the function
public void DirSearch(string sDir,ref System.Collections.ArrayList files)
{
try
{
foreach (string d in System.IO.Directory.GetDirectories(sDir))
{
foreach (string f in System.IO.Directory.GetFiles(d, "*.txt"))
{
files.Add(f);
}
DirSearch(d,ref files);
}
}
catch (System.Exception excpt)
{
Console.WriteLine(excpt.Message);
}
}

How to Read a Text File (with a single call to sReader.ReadToEnd())

2009-05-30T06:44:00.000-07:00

public static string getFileAsString(string fileName) {
StreamReader sReader = null;
string contents = null;
try {
FileStream fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read);
sReader = new StreamReader(fileStream);
contents = sReader.ReadToEnd();
} finally {
if(sReader != null) {
sReader.Close();
}
}
return contents;
}