public void GetDirectories(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
fs.CreateDirectory(@"SOMEDIR\CHILD\GCHILD");
fs.CreateDirectory(@"A.DIR");
Assert.Equal(2, fs.Root.GetDirectories().Length);
DiscDirectoryInfo someDir = fs.Root.GetDirectories(@"SoMeDir")[0];
Assert.Equal(1, fs.Root.GetDirectories("SOMEDIR").Length);
Assert.Equal("SOMEDIR", someDir.Name);
Assert.Equal(1, someDir.GetDirectories("*.*").Length);
Assert.Equal("CHILD", someDir.GetDirectories("*.*")[0].Name);
Assert.Equal(2, someDir.GetDirectories("*.*", SearchOption.AllDirectories).Length);
Assert.Equal(4, fs.Root.GetDirectories("*.*", SearchOption.AllDirectories).Length);
Assert.Equal(2, fs.Root.GetDirectories("*.*", SearchOption.TopDirectoryOnly).Length);
Assert.Equal(1, fs.Root.GetDirectories("*.DIR", SearchOption.AllDirectories).Length);
Assert.Equal(@"A.DIR\", fs.Root.GetDirectories("*.DIR", SearchOption.AllDirectories)[0].FullName);
Assert.Equal(1, fs.Root.GetDirectories("GCHILD", SearchOption.AllDirectories).Length);
Assert.Equal(@"SOMEDIR\CHILD\GCHILD\", fs.Root.GetDirectories("GCHILD", SearchOption.AllDirectories)[0].FullName);
}
void ExtractDirectory(DiscDirectoryInfo Dinfo, string RootPath, string PathinISO)
{
if (!string.IsNullOrWhiteSpace(PathinISO))
{
PathinISO += "\\" + Dinfo.Name;
}
RootPath += "\\" + Dinfo.Name;
AppendDirectory(RootPath);
foreach (DiscDirectoryInfo dinfo in Dinfo.GetDirectories())
{
ExtractDirectory(dinfo, RootPath, PathinISO);
}
foreach (DiscFileInfo finfo in Dinfo.GetFiles())
{
using (Stream FileStr = finfo.OpenRead())
{
using (FileStream Fs = File.Create(RootPath + "\\" + finfo.Name)) // Here you can Set the BufferSize Also e.g. File.Create(RootPath + "\\" + finfo.Name, 4 * 1024)
{
metroProgressBar1.Increment(1);
metroLabel2.Text = metroProgressBar1.Value.ToString() + " %";
metroLabel2.Refresh();
metroTextBox1.Text = finfo.Name.ToString();
metroTextBox1.Refresh();
FileStr.CopyTo(Fs, 8 * 1024); // Buffer Size is 4 * 1024 but you can modify it in your code as per your need
}
}
}
}
public void ExtractDirectory(DiscDirectoryInfo Dinfo, string RootPath, string PathinISO)
{
if (!string.IsNullOrWhiteSpace(PathinISO))
{
PathinISO += "\\" + Dinfo.Name;
}
RootPath += "\\" + Dinfo.Name;
AppendDirectory(RootPath);
foreach (DiscDirectoryInfo dinfo in Dinfo.GetDirectories())
{
ExtractDirectory(dinfo, RootPath, PathinISO);
}
foreach (DiscFileInfo finfo in Dinfo.GetFiles())
{
using (Stream FileStr = finfo.OpenRead())
{
char[] charsToRemove = { ';', '1' };
string fileName = finfo.Name.TrimEnd(charsToRemove);
using (FileStream Fs = File.Create(RootPath + "\\" + fileName))
{
FileStr.CopyTo(Fs, 4 * 1024);
Console.WriteLine(fileName + " was extracted.");
}
}
}
}
/**************************************************************************************************************
* Extract ISO 9660
*************************************************************************************************************/
private void ExtractDirectoryISO9660(DiscDirectoryInfo Dinfo, string RootPath, string PathinISO)
{
try
{
if (!string.IsNullOrWhiteSpace(PathinISO))
{
PathinISO += "\\" + Dinfo.Name;
}
RootPath += "\\" + Dinfo.Name;
AppendDirectoryISO9660(RootPath);
foreach (DiscDirectoryInfo dinfo in Dinfo.GetDirectories())
{
ExtractDirectoryISO9660(dinfo, RootPath, PathinISO);
}
foreach (DiscFileInfo finfo in Dinfo.GetFiles())
{
using (Stream FileStr = finfo.OpenRead())
{
using (FileStream Fs = File.Create(RootPath + "\\" + finfo.Name)) // Here you can Set the BufferSize Also e.g. File.Create(RootPath + "\\" + finfo.Name, 4 * 1024)
{
FileStr.CopyTo(Fs, 4 * 1024); // Buffer Size is 4 * 1024 but you can modify it in your code as per your need
}
}
}
}
catch (Exception oEx)
{
BootmanLog.LogError(LogTextBox, "Error Extracting ISO: " + oEx.Message);
}
}
public void DirectoryInfo()
{
FatFileSystem fs = FatFileSystem.FormatFloppy(new MemoryStream(), FloppyDiskType.HighDensity, "FLOPPY_IMG ");
DiscDirectoryInfo fi = fs.GetDirectoryInfo(@"SOMEDIR");
Assert.IsNotNull(fi);
}
void ExtractDirectory(DiscDirectoryInfo Dinfo, string RootPath, string PathinISO)
{
if (!string.IsNullOrWhiteSpace(PathinISO))
{
PathinISO += "\\" + Dinfo.Name;
}
RootPath += "\\" + Dinfo.Name;
AppendDirectory(RootPath);
foreach (DiscDirectoryInfo dinfo in Dinfo.GetDirectories())
{
ExtractDirectory(dinfo, RootPath, PathinISO);
}
var test = Dinfo.GetFiles();
foreach (DiscFileInfo finfo in test)
{
using (Stream FileStr = finfo.OpenRead())
{
using (FileStream Fs = File.Create(RootPath + "\\" + finfo.Name))
{
Progress_Bar.Increment(1 / test.Length);
Progress_Number.Text = Progress_Bar.Value.ToString() + " %";
Progress_Number.Refresh();
FileStr.CopyTo(Fs, 8 * 1024);
}
}
}
}
public void GetDirectories()
{
CDBuilder builder = new CDBuilder();
builder.AddDirectory(@"SOMEDIR\CHILD\GCHILD");
builder.AddDirectory(@"A.DIR");
CDReader fs = new CDReader(builder.Build(), false);
Assert.AreEqual(2, fs.Root.GetDirectories().Length);
DiscDirectoryInfo someDir = fs.Root.GetDirectories(@"SoMeDir")[0];
Assert.AreEqual(1, fs.Root.GetDirectories("SOMEDIR").Length);
Assert.AreEqual("SOMEDIR", someDir.Name);
Assert.AreEqual(1, someDir.GetDirectories("*.*").Length);
Assert.AreEqual("CHILD", someDir.GetDirectories("*.*")[0].Name);
Assert.AreEqual(2, someDir.GetDirectories("*.*", SearchOption.AllDirectories).Length);
Assert.AreEqual(4, fs.Root.GetDirectories("*.*", SearchOption.AllDirectories).Length);
Assert.AreEqual(2, fs.Root.GetDirectories("*.*", SearchOption.TopDirectoryOnly).Length);
Assert.AreEqual(1, fs.Root.GetDirectories("*.DIR", SearchOption.AllDirectories).Length);
Assert.AreEqual(@"A.DIR\", fs.Root.GetDirectories("*.DIR", SearchOption.AllDirectories)[0].FullName);
Assert.AreEqual(1, fs.Root.GetDirectories("GCHILD", SearchOption.AllDirectories).Length);
Assert.AreEqual(@"SOMEDIR\CHILD\GCHILD\", fs.Root.GetDirectories("GCHILD", SearchOption.AllDirectories)[0].FullName);
}
protected override void RenameItem(string path, string newName)
{
object obj = FindItemByPath(Utilities.NormalizePath(path), true, false);
DiscFileSystemInfo fsiObj = obj as DiscFileSystemInfo;
if (fsiObj == null)
{
WriteError(new ErrorRecord(
new InvalidOperationException("Cannot move items to this location"),
"BadParentForNewItem",
ErrorCategory.InvalidArgument,
newName));
return;
}
string newFullName = Path.Combine(Path.GetDirectoryName(fsiObj.FullName.TrimEnd('\\')), newName);
if (obj is DiscDirectoryInfo)
{
DiscDirectoryInfo dirObj = (DiscDirectoryInfo)obj;
dirObj.MoveTo(newFullName);
}
else
{
DiscFileInfo fileObj = (DiscFileInfo)obj;
fileObj.MoveTo(newFullName);
}
}
public static Stream CreatePsPath(SessionState session, string filePath)
{
string parentPath = session.Path.ParseParent(filePath, null);
string childName = session.Path.ParseChildName(filePath);
var parentItems = session.InvokeProvider.Item.Get(parentPath);
if (parentItems.Count > 1)
{
throw new IOException(string.Format(CultureInfo.InvariantCulture, "PowerShell path {0} is ambiguous", parentPath));
}
else if (parentItems.Count < 1)
{
throw new DirectoryNotFoundException("No such directory");
}
DirectoryInfo parentAsDir = parentItems[0].BaseObject as DirectoryInfo;
if (parentAsDir != null)
{
return(File.Create(Path.Combine(parentAsDir.FullName, childName)));
}
DiscDirectoryInfo parentAsDiscDir = parentItems[0].BaseObject as DiscDirectoryInfo;
if (parentAsDiscDir != null)
{
return(parentAsDiscDir.FileSystem.OpenFile(Path.Combine(parentAsDiscDir.FullName, childName), FileMode.Create, FileAccess.ReadWrite));
}
throw new FileNotFoundException("Path is not a directory", parentPath);
}
private void ParseCd(DiscDirectoryInfo pathDir = null)
{
if (pathDir == null)
{
pathDir = GetDirectoryInfo("\\");
Range <long, long> r = PathToClusters("\\").First();
directoryMembers.Add(new DirectoryMemberInformation(pathDir.FullName, r.Offset, r.Count.RoundToSector(),
0, false)
{
Added = true
});
}
foreach (DiscDirectoryInfo dir in pathDir.GetDirectories())
{
DirectoryRecord rec = dir.Entry.Record;
long offset = rec.LocationOfExtent;
long count = rec.DataLength;
directoryMembers.Add(new DirectoryMemberInformation(dir.FullName, offset, count.RoundToSector(), 0, false));
ParseCd(dir);
}
foreach (DiscFileInfo f in pathDir.GetFiles())
{
ReaderDirectory rdr = f.Entry.Parent;
// Fetch all cluster information from the parent
IEnumerable <ReaderDirEntry> entries = rdr.GetEntriesByName(f.Entry.FileName);
long offset = f.Entry.Record.LocationOfExtent;
long count = entries.Sum(e => e.Record.DataLength);
directoryMembers.Add(new DirectoryMemberInformation(f.FullName, offset, count.RoundToSector(), count, true));
}
}
private void CreateNewDisk()
{
string[] typeAndVariant = Type.Split('-');
if (typeAndVariant.Length < 1 || typeAndVariant.Length > 2)
{
WriteError(new ErrorRecord(
new ArgumentException("Invalid Type of disk"),
"BadDiskType",
ErrorCategory.InvalidArgument,
null));
return;
}
long size;
if (!DiscUtils.Common.Utilities.TryParseDiskSize(Size, out size))
{
WriteError(new ErrorRecord(
new ArgumentException("Unable to parse the disk size"),
"BadDiskSize",
ErrorCategory.InvalidArgument,
null));
return;
}
string type = typeAndVariant[0];
string variant = typeAndVariant.Length > 1 ? typeAndVariant[1] : null;
string child;
PSObject parentObj = ResolveNewDiskPath(out child);
VirtualDisk disk = null;
if (parentObj.BaseObject is DirectoryInfo)
{
string path = Path.Combine(((DirectoryInfo)parentObj.BaseObject).FullName, child);
using (VirtualDisk realDisk = VirtualDisk.CreateDisk(type, variant, path, size, null, null)) { }
disk = new OnDemandVirtualDisk(path, FileAccess.ReadWrite);
}
else if (parentObj.BaseObject is DiscDirectoryInfo)
{
DiscDirectoryInfo ddi = (DiscDirectoryInfo)parentObj.BaseObject;
string path = Path.Combine(ddi.FullName, child);
using (VirtualDisk realDisk = VirtualDisk.CreateDisk(ddi.FileSystem, type, variant, path, size, null, null)) { }
disk = new OnDemandVirtualDisk(ddi.FileSystem, path, FileAccess.ReadWrite);
}
else
{
WriteError(new ErrorRecord(
new DirectoryNotFoundException("Cannot create a virtual disk in that location"),
"BadDiskLocation",
ErrorCategory.InvalidArgument,
null));
return;
}
WriteObject(disk, false);
}
public void DirectoryInfo()
{
CDBuilder builder = new CDBuilder();
CDReader fs = new CDReader(builder.Build(), false);
DiscDirectoryInfo fi = fs.GetDirectoryInfo(@"SOMEDIR");
Assert.NotNull(fi);
}
public void CreateInvalid_Characters(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscDirectoryInfo dirInfo = fs.GetDirectoryInfo("SOME\0DIR");
Assert.Throws <IOException>(() => dirInfo.Create());
}
public void CreateInvalid_Long(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscDirectoryInfo dirInfo = fs.GetDirectoryInfo(new String('X', 256));
Assert.Throws <IOException>(() => dirInfo.Create());
}
internal Iso9960Directory(DiscDirectoryInfo directory, VfsDevice device, VfsEntry parent = null)
: base(directory.Name, device, parent)
{
_directory = directory;
Attributes = directory.Attributes;
DateAccessed = directory.LastAccessTimeUtc;
DateCreated = directory.CreationTimeUtc;
DateModified = directory.LastWriteTimeUtc;
}
public void Create(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscDirectoryInfo dirInfo = fs.GetDirectoryInfo("SOMEDIR");
dirInfo.Create();
Assert.Equal(1, fs.Root.GetDirectories().Length);
}
public FatFileSystemDirectory(FatFileSystemProvider fs, string path, OpenDirectoryMode mode)
{
ParentFileSystem = fs;
FullPath = path;
Mode = mode;
path = FatFileSystemProvider.ToDiscUtilsPath(PathTools.Normalize(path));
DirInfo = fs.Fs.GetDirectoryInfo(path);
}
void BrowseDirectory(DiscDirectoryInfo Dinfo, string RootPath, string PathinISO, DiscDirectoryInfo ComparingNode)
{
if (Dinfo.FullName == ComparingNode.FullName)
{
metroListView1.Items.Clear();
foreach (DiscDirectoryInfo dinfo in Dinfo.GetDirectories())
{
ListViewItem.ListViewSubItem[] subItems = null;
ListViewItem item = null;
item = new ListViewItem(dinfo.Name, 0);
subItems = new ListViewItem.ListViewSubItem[]
{new ListViewItem.ListViewSubItem(item, "Directory"),
new ListViewItem.ListViewSubItem(item,
dinfo.LastAccessTime.ToShortDateString())};
item.SubItems.AddRange(subItems);
metroListView1.Items.Add(item);
currentFolder = Dinfo;
textBox1.Text = Dinfo.FullName;
//DiscDirectoryInfo nodeDirInfo;
//for (int i = 0; i<treeView1.Nodes.Count; i++)
//{
// nodeDirInfo = (DiscDirectoryInfo)treeView1.Nodes[i].Tag;
// if (nodeDirInfo.FullName == Dinfo.FullName)
// treeView1.Nodes[i].Expand();
// else treeView1.Nodes[0].NextVisibleNode.Expand();
//}
}
foreach (DiscFileInfo finfo in Dinfo.GetFiles())
{
ListViewItem.ListViewSubItem[] subItems = null;
ListViewItem item = null;
item = new ListViewItem(finfo.Name, 1);
subItems = new ListViewItem.ListViewSubItem[]
{ new ListViewItem.ListViewSubItem(item, "File"),
new ListViewItem.ListViewSubItem(item,
finfo.LastAccessTime.ToShortDateString())};
item.SubItems.AddRange(subItems);
metroListView1.Items.Add(item);
}
} else
{
foreach (DiscDirectoryInfo dinfo in Dinfo.GetDirectories())
{
if (dinfo.FullName == ComparingNode.FullName)
{
metroListView1.Items.Clear();
BrwsDirectory(dinfo, RootPath, PathinISO, ComparingNode);
}
BrowseDirectory(dinfo, RootPath, PathinISO, ComparingNode);
}
}
}
public void SimpleSearch()
{
CDBuilder builder = new CDBuilder();
builder.AddFile(@"SOMEDIR\CHILDDIR\GCHILDIR\FILE.TXT", new byte[0]);
CDReader fs = new CDReader(builder.Build(), false);
DiscDirectoryInfo di = fs.GetDirectoryInfo(@"SOMEDIR\CHILDDIR");
DiscFileInfo[] fis = di.GetFiles("*.*", SearchOption.AllDirectories);
}
public void CreateRecursive(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscDirectoryInfo dirInfo = fs.GetDirectoryInfo(@"SOMEDIR\CHILDDIR");
dirInfo.Create();
Assert.Equal(1, fs.Root.GetDirectories().Length);
Assert.Equal(1, fs.GetDirectoryInfo(@"SOMEDIR").GetDirectories().Length);
Assert.Equal("CHILDDIR", fs.GetDirectoryInfo(@"SOMEDIR").GetDirectories()[0].Name);
}
private static void ShowDir(DiscDirectoryInfo dirInfo, int indent)
{
Console.WriteLine("{0}{1,-50} [{2}]", new String(' ', indent), dirInfo.FullName, dirInfo.CreationTimeUtc);
foreach (DiscDirectoryInfo subDir in dirInfo.GetDirectories())
{
ShowDir(subDir, indent + 0);
}
foreach (DiscFileInfo file in dirInfo.GetFiles())
{
Console.WriteLine("{0}{1,-50} [{2}]", new String(' ', indent), file.FullName, file.CreationTimeUtc);
}
}
/// <summary>
/// The recursive files.
/// </summary>
/// <param name="path">
/// The path.
/// </param>
/// <returns>
/// </returns>
private static List <DiscUtilFile> RecursiveFiles(DiscDirectoryInfo path)
{
var returnFiles = new List <DiscUtilFile>();
foreach (DiscFileInfo file in path.GetFiles())
{
var newFile = new DiscUtilFile();
newFile.FileName = file.FullName;
newFile.FileSize = file.Length;
returnFiles.Add(newFile);
}
return(returnFiles);
}
private void GetChildren(string path, bool recurse, bool namesOnly)
{
if (string.IsNullOrEmpty(path))
{
return;
}
object obj = FindItemByPath(path, false, true);
if (obj is VirtualDisk)
{
VirtualDisk vd = (VirtualDisk)obj;
EnumerateDisk(vd, path, recurse, namesOnly);
}
else if (obj is LogicalVolumeInfo)
{
LogicalVolumeInfo lvi = (LogicalVolumeInfo)obj;
bool dispose;
DiscFileSystem fs = GetFileSystem(lvi, out dispose);
try
{
if (fs != null)
{
EnumerateDirectory(fs.Root, path, recurse, namesOnly);
}
}
finally
{
if (dispose && fs != null)
{
fs.Dispose();
}
}
}
else if (obj is DiscDirectoryInfo)
{
DiscDirectoryInfo ddi = (DiscDirectoryInfo)obj;
EnumerateDirectory(ddi, path, recurse, namesOnly);
}
else
{
WriteError(new ErrorRecord(
new InvalidOperationException("Unrecognized object type: " + (obj != null ? obj.GetType() : null)),
"UnknownObjectType",
ErrorCategory.ParserError,
obj));
}
}
public void Exists(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
DiscDirectoryInfo dirInfo = fs.GetDirectoryInfo(@"SOMEDIR\CHILDDIR");
dirInfo.Create();
Assert.True(fs.GetDirectoryInfo(@"\").Exists);
Assert.True(fs.GetDirectoryInfo(@"SOMEDIR").Exists);
Assert.True(fs.GetDirectoryInfo(@"SOMEDIR\CHILDDIR").Exists);
Assert.True(fs.GetDirectoryInfo(@"SOMEDIR\CHILDDIR\").Exists);
Assert.False(fs.GetDirectoryInfo(@"NONDIR").Exists);
Assert.False(fs.GetDirectoryInfo(@"SOMEDIR\NONDIR").Exists);
}
public void LastWriteTime(NewFileSystemDelegate fsFactory)
{
DiscFileSystem fs = fsFactory();
fs.CreateDirectory("DIR");
DiscDirectoryInfo di = fs.GetDirectoryInfo("DIR");
DateTime baseTime = DateTime.Now - TimeSpan.FromMinutes(10);
di.LastWriteTime = baseTime;
fs.CreateDirectory(@"DIR\CHILD");
Assert.True(baseTime < di.LastWriteTime);
}
private void EnumerateDirectory(DiscDirectoryInfo parent, string basePath, bool recurse, bool namesOnly)
{
foreach (var dir in parent.GetDirectories())
{
WriteItemObject(namesOnly ? dir.Name : (object)dir, MakePath(basePath, dir.Name), true);
if (recurse)
{
EnumerateDirectory(dir, MakePath(basePath, dir.Name), recurse, namesOnly);
}
}
foreach (var file in parent.GetFiles())
{
WriteItemObject(namesOnly ? file.Name : (object)file, MakePath(basePath, file.Name), false);
}
}
private string[] GetFiles(DiscDirectoryInfo directory)
{
List <string> result = new List <string>();
foreach (DiscFileInfo file in directory.GetFiles())
{
result.Add(file.FullName);
}
foreach (DiscDirectoryInfo dir in directory.GetDirectories())
{
result.AddRange(GetFiles(dir));
}
return(result.ToArray());
}
private void metroTile1_Click(object sender, EventArgs e)
{
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
PopulateTreeView(openFileDialog1.SafeFileName, openFileDialog1.FileName.Replace(openFileDialog1.SafeFileName, ""));
using (FileStream ISOStream = File.Open(openFileDialog1.FileName, FileMode.Open))
{
CDReader Reader = new CDReader(ISOStream, true, true);
metroListView1.Items.Clear();
BrowseDirectory(Reader.Root, ExtPath + Path.GetFileNameWithoutExtension(ISONameFile) + "\\", "", Reader.Root);
metroListView1.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
DiscDirectoryInfo nodeDirInfo = (DiscDirectoryInfo)treeView1.Nodes[0].Tag;
textBox1.Text = nodeDirInfo.FullName;
}
}
}
void treeView1_NodeMouseClick(object sender,
TreeNodeMouseClickEventArgs e)
{
using (FileStream ISOStream = File.Open(openFileDialog1.FileName, FileMode.Open))
{
CDReader Reader = new CDReader(ISOStream, true, true);
metroListView1.Items.Clear();
TreeNode newSelected = e.Node;
DiscDirectoryInfo nodeDirInfo = (DiscDirectoryInfo)newSelected.Tag;
BrowseDirectory(Reader.Root, ExtPath + Path.GetFileNameWithoutExtension(ISONameFile) + "\\", "", nodeDirInfo);
textBox1.Text = nodeDirInfo.FullName;
currentFolder = nodeDirInfo;
Reader.Dispose();
}
metroListView1.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
}
private void GoBackDirectory(DiscDirectoryInfo Dinfo, string path, DiscDirectoryInfo ComparingNode)
{
if (Dinfo.FullName == textBox1.Text)
{
BrwsDirectory(Dinfo.Parent, ExtPath + Path.GetFileNameWithoutExtension(ISONameFile) + "\\", "", Dinfo.Parent);
textBox1.Text = Dinfo.Parent.FullName;
}
else
{
foreach (DiscDirectoryInfo disc in Dinfo.GetDirectories())
{
GoBackDirectory(disc, path, ComparingNode);
}
}
}
private void EnumerateDirectory(DiscDirectoryInfo parent, string basePath, bool recurse, bool namesOnly)
{
foreach (var dir in parent.GetDirectories())
{
WriteItemObject(namesOnly ? dir.Name : (object)dir, MakePath(basePath, dir.Name), true);
if (recurse)
{
EnumerateDirectory(dir, MakePath(basePath, dir.Name), recurse, namesOnly);
}
}
foreach (var file in parent.GetFiles())
{
WriteItemObject(namesOnly ? file.Name : (object)file, MakePath(basePath, file.Name), false);
}
}
private void DoCopy(DiscDirectoryInfo srcDir, string srcFileName, DiscDirectoryInfo destDir, string destFileName, bool recurse)
{
string srcPath = Path.Combine(srcDir.FullName, srcFileName);
string destPath = Path.Combine(destDir.FullName, destFileName);
if ((srcDir.FileSystem.GetAttributes(srcPath) & FileAttributes.Directory) == 0)
{
DoCopyFile(srcDir.FileSystem, srcPath, destDir.FileSystem, destPath);
}
else
{
DoCopyDirectory(srcDir.FileSystem, srcPath, destDir.FileSystem, destPath);
if (recurse)
{
DoRecursiveCopy(srcDir.FileSystem, srcPath, destDir.FileSystem, destPath);
}
}
}
