I need a simple function which will take a FileInfo and a destination_directory_name as input, get the file path from the fileinfo and replicate it in the destination_directory_name passed as the second parameter.
for ex. filepath is "d:\recordings\location1\client1\job1\file1.ext
the function should create the directories in the destination_directory_name if they dont exist and copy the file after creating the directories.
System.IO.Directory.CreateDirectory can be used to create the final directory, it will also automatically create all folders in the path if they do not exist.
//Will create all three directories (if they do not already exist).
System.IO.Directory.CreateDirectory("C:\\First\\Second\\Third")
I'm using the following method for that purpose:
public static void CreateDirectory(DirectoryInfo directory)
{
if (!directory.Parent.Exists)
CreateDirectory(directory.Parent);
directory.Create();
}
Use it in this way:
// path is your file path
string directory = Path.GetDirectoryName(path);
CreateDirectory(new DirectoryInfo(directory));
Based on #NTDLS's answer here's a method that will replicate source to destination. It handles case where source is a file or a folder. Function name kind of stinks... lemme know if you think of a better one.
/// <summary>
/// Copies the source to the dest. Creating any neccessary folders in the destination path as neccessary.
///
/// For example:
/// Directory Example:
/// pSource = C:\somedir\conf and pDest=C:\somedir\backups\USER_TIMESTAMP\somedir\conf
/// all files\folders under source will be replicated to destination and any paths in between will be created.
/// </summary>
/// <param name="pSource">path to file or directory that you want to copy from</param>
/// <param name="pDest">path to file or directory that you want to copy to</param>
/// <param name="pOverwriteDest">if true, files/directories in pDest will be overwritten.</param>
public static void FileCopyWithReplicate(string pSource, string pDest, bool pOverwriteDest)
{
string destDirectory = Path.GetDirectoryName(pDest);
System.IO.Directory.CreateDirectory(destDirectory);
if (Directory.Exists(pSource))
{
DirectoryCopy(pSource, pDest,pOverwriteDest);
}
else
{
File.Copy(pSource, pDest, pOverwriteDest);
}
}
// From MSDN Aricle "How to: Copy Directories"
// Link: http://msdn.microsoft.com/en-us/library/bb762914.aspx
private static void DirectoryCopy(string sourceDirName, string destDirName, bool copySubDirs)
{
DirectoryInfo dir = new DirectoryInfo(sourceDirName);
DirectoryInfo[] dirs = dir.GetDirectories();
if (!dir.Exists)
{
throw new DirectoryNotFoundException(
"Source directory does not exist or could not be found: "
+ sourceDirName);
}
if (!Directory.Exists(destDirName))
{
Directory.CreateDirectory(destDirName);
}
FileInfo[] files = dir.GetFiles();
foreach (FileInfo file in files)
{
string temppath = Path.Combine(destDirName, file.Name);
file.CopyTo(temppath, true);
}
if (copySubDirs)
{
foreach (DirectoryInfo subdir in dirs)
{
string temppath = Path.Combine(destDirName, subdir.Name);
DirectoryCopy(subdir.FullName, temppath, copySubDirs);
}
}
}
Similar to the question, I am copying a folder structure from one destination and duplicating it to another. Sorry for posting to an old thread, but it may be useful for someone that ends up here.
Let's assume that we have an application that is standalone, and we need to copy the folder structure from an Input folder to an Output folder. The Input folder and Output folder is in the root directory of our application.
We can make a DirectoryInfo for the Input folder (structure we want to copy) like this:
DirectoryInfo dirInput = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory + "\\Input\\");
Our output folder location can be stored in a string.
string dirOutput = AppDomain.CurrentDomain.BaseDirectory + "\\Output\\";
This recursive method should handle the rest for us.
public static void ProcessDirectories(DirectoryInfo dirInput, string dirOutput)
{
string dirOutputfix = String.Empty;
foreach (DirectoryInfo di in dirInput.GetDirectories())
{
dirOutputfix = dirOutput + "\\" + di.Name);
if (!Directory.Exists(dirOutputfix))
{
try
{
Directory.CreateDirectory(dirOutputfix);
}
catch(Exception e)
{
throw (e);
}
}
ProcessDirectories(di, dirOutputfix);
}
}
This method can be easily modified to handle files also, but I designed it with only folders in mind for my project.
Now we just call the method with our dirInput and dirOutput.
ProcessDirectories(dirInput, dirOutput);
Related
I just followed this tutorial to delete a folder and its content
public ActionResult Product_Delete()
{
string idnumber = "07";
string path1 = #"~/Content/Essential_Folder/attachments_AR/" + idnumber;
DirectoryInfo attachments_AR = new DirectoryInfo(Server.MapPath(path1));
EmptyFolder(attachments_AR);
Directory.Delete(path1);
....
}
private void EmptyFolder(DirectoryInfo directory)
{
foreach (FileInfo file in directory.GetFiles())
{
file.Delete();
}
foreach (DirectoryInfo subdirectory in directory.GetDirectories())
{
EmptyFolder(subdirectory);
subdirectory.Delete();
}
}
But using this its deleting all the contnet in 07 folder, but its not deleting the 07 folder finally.
I'm getting error in this line Directory.Delete(path1);
Once I debug I can see run time error with below message
Could not find a part of the path 'C:\Program Files (x86)\IIS
Express\~\Content\Essential_Folder\attachments_AR\07'.
but path1 value is ~/Content/Essential_Folder/attachments_AR/07
The reason is that Directory.Delete cannot recognize ~ in the path.
You need to convert it to an absolute path using Server.MapPath() like you did it here:
DirectoryInfo attachments_AR = new DirectoryInfo(Server.MapPath(path1));
You may also want to convert it once, and use in both methods:
public ActionResult Product_Delete()
{
string idnumber = "07";
string mappedPath1 = Server.MapPath(#"~/Content/Essential_Folder/attachments_AR/" + idnumber);
DirectoryInfo attachments_AR = new DirectoryInfo(mappedPath1));
EmptyFolder(attachments_AR);
Directory.Delete(mappedPath1);
....
}
By the way, there is absolutely no need to remove files manually. You can use
public ActionResult Product_Delete()
{
string idnumber = "07";
string mappedPath = Server.MapPath(#"~/Content/Essential_Folder/attachments_AR/" + idnumber);
Directory.Delete(mappedPath, true);
}
which will remove all folders, subfolders and files recursively, and then will remove directory itself.
you cannot delete a directory by giving its physical path. from a web application using Directory.Delete(), so you have to convert it into absolute path by using Server.MapPath()
Use : Directory.Delete(Server.MapPath(path1));
Or you can use Like the following without using EmptyFolder() method :
DirectoryInfo dir = new DirectoryInfo(Server.MapPath(path1));
dir.GetFiles("*", SearchOption.AllDirectories).ToList().ForEach(file=>file.Delete());
// will delete all files in the folder and its sub folder
//so you don't need to iterate each sub folder and files in it
Directory.Delete(Server.MapPath(path1));
you should delete the directly using full path instead of relative path. Try with
Directory.Delete(attachments_AR.FullName);
Just take separate path of the folder in variable and pass this variable in Directory.Delete(.) Like :
var path = Server.MapPath(#"~/Test");
DirectoryInfo attachments_AR = new DirectoryInfo(path);
Directory.Delete(path);
Why don't you use method from Directory class (MSDN documentation):
public static void Delete(
string path,
bool recursive
)
Your code will be cleaner and simplier but much more important is that when building path manually you can achive path long limit. I get issue like this and solution was use this method.
Here is a solution what I did and it is deleting the root folder too:
public ActionResult Product_Delete()
{
string idnumber = "07";
string path1 = #"~/Content/Essential_Folder/attachments_AR/" + idnumber;
DirectoryInfo attachments_AR = new DirectoryInfo(Server.MapPath(path1));
EmptyFolder(attachments_AR);
if (attachments_AR.Exists && IsDirectoryEmpty(attachments_AR.FullName))
attachments_AR.Delete();
}
private static void EmptyFolder(DirectoryInfo directory)
{
foreach (FileInfo file in directory.GetFiles())
{
file.Delete();
}
foreach (DirectoryInfo subdirectory in directory.GetDirectories())
{
EmptyFolder(subdirectory);
subdirectory.Delete();
}
}
public static bool IsDirectoryEmpty(string path)
{
return !Directory.EnumerateFileSystemEntries(path).Any();
}
I am trying to write a program to keep multiple folders in sync. To do this, I need to copy and delete files and subfolders.
To me, it doesn't make a difference if an object is a file or a folder, I want to create all necessary parent folders and copy the object, overwriting if necessary. I'm currently using a jagged array of FileSystemInfo to hold my files/folders.
This has the advantage of avoiding a duplication of code to sync files and folders separately.
However, I can't figure out how to Copy a FileSystemInfo. I'm looking for a way to be able to copy/delete/read creation or modified time that will work on both files and folders.
FileSystemInfo don't have Copy or Delete methods but is the base class for DirectoryInfo and FileInfo.
So when you loop over your FileSystemInfo objects you have to cast to the proper concrete class and use the specific copy/delete methods.
foreach( var fsi in fileSystemInfoObjects )
{
if( fsi is DirectoryInfo )
{
var directory = (DirectoryInfo)fsi;
//do something
}
else if (fsi is FileInfo )
{
var file = (FileInfo)fsi;
//do something
}
}
I used sam's answer to help me solve my problem. What I did was put the copying logic in my custom class so that I don't need to duplicate the logic whenever I use it in my code.
public class myFSInfo
{
public FileSystemInfo Dir;
public string RelativePath;
public string BaseDirectory;
public myFSInfo(FileSystemInfo dir, string basedir)
{
Dir = dir;
BaseDirectory = basedir;
RelativePath = Dir.FullName.Substring(basedir.Length + (basedir.Last() == '\\' ? 1 : 2));
}
private myFSInfo() { }
/// <summary>
/// Copies a FileInfo or DirectoryInfo object to the specified path, creating folders and overwriting if necessary.
/// </summary>
/// <param name="path"></param>
public void CopyTo(string path)
{
if (Dir is FileInfo)
{
var f = (FileInfo)Dir;
Directory.CreateDirectory(path.Substring(0,path.LastIndexOf("\\")));
f.CopyTo(path,true);
}
else if (Dir is DirectoryInfo) Directory.CreateDirectory(path);
}
}
What I'd like to do is get 6 pieces of file information from every file in a folder, and all folders beneath it. These pieces are:
Type (you can do this in Access, it will return "Microsoft Excel Worksheet" or "Winzip File" or something, just like you see in the Explorer window, but I didn't see a property for this in C#)
FullName
Length
CreationTime
LastAccessTime
LastWriteTime
I have the following code, which will spit out a list of files complete with path, but I'm trying to figure out how to get that additional info in my output. If it can be separated by a semicolon or something, that would be good as the eventual desire is to write this info to a table. Any help is appreciated.
private void GetMyFiles () {
string rootDirectory = #"" + txtPathToScan.Text + "";
string extension = "*";
List<string> files = GetFilesRecursively (rootDirectory, extension);
Console.WriteLine ("Got {0} files of extension {1} in directory {2}", files.Count, extension, rootDirectory);
foreach (string file in files) {
Console.WriteLine (file);
}
}
/// <summary>
/// This function calls itself recursively for each of the subdirectories that it finds
/// in the root directory passed to it. It returns files of the extension as specified
/// by the caller.
/// </summary>
/// <param name="rootDirectory">The directory from which the file list is sought.</param>
/// <param name="extension">The particular extension for which the file list is sought.</param>
/// <returns>A list of all the files with extension as specified by the caller. This list
/// includes the files in the current directory as well its sub-directories.</returns>
static List<string> GetFilesRecursively (string rootDirectory, string extension) {
// Uncomment this line only if you want to trace the control as it goes from
// sub-directory to sub-directory. Be ready for long scrolls of text output:
//Console.WriteLine ("Currently in directory {0}", rootDirectory);
// Create an output list:
List<string> opList = new List<string> ();
// Get all files in the current directory:
string[] allFiles = Directory.GetFiles (rootDirectory, "*." + extension);
// Add these files to the output list:
opList.AddRange (allFiles);
// Get all sub-directories in current directory:
string[] subDirectories = Directory.GetDirectories (rootDirectory);
// And iterate through them:
foreach (string subDir in subDirectories) {
// Get all the files from the sub-directory:
List<string> subDirFileList = GetFilesRecursively (subDir, extension);
// And add it to this list:
opList.AddRange (subDirFileList);
}
// Finally return the output list:
return opList;
}
You can get most of these using the FileInfo class....
var info = new System.IO.FileInfo(#"c:\folder\file.ext");
It has properties for Length, CreationTime, LastAccessTime and LastWriteTime, to output them (for example) to the console, you could do...
Console.WriteLine("For file {0}", info.Name);
Console.WriteLine("Length is {0}", info.Length);
Console.WriteLine("Creation time is {0}", info.CreationTime);
Console.WriteLine("Last access time is {0}", info.LastAccessTime);
Console.WriteLine("Last write time is {0}", info.LastWriteTime);
To get the full filename, you can use GetFileNameWithoutExtension...
var fileName = System.IO.Path.GetFileNameWithoutExtension(#"c:\folder\file.ext")
filename will equal "file" in the above example.
Getting the description of a file extension is a bit more work, but can be done using SHGetFIleInfo, See this answer for details.
To integrate this with your current code (if you're not so worried about the file descriptions), you could change your GetFilesRecursively method to return a List<FileInfo>...
static List<FileInfo> GetFilesRecursively (string rootDirectory, string extension)
Update your opList variable accordingly...
List<FileInfo> opList = new List<FileInfo> ();
And then tweak your AddRange call to add FileInfo objects...
opList.AddRange (allFiles.Select(f => new FileInfo(f)));
Lastly, the type of subDirFileList will need to be changed as well, so a List<FileInfo>.
(I think that's everything!)
For posterity, the completed answer is as below. Please only vote for Richard's answer if you're going to upvote anything. Thanks!
private void GetMyFiles () {
string rootDirectory = #"" + txtPathToScan.Text + "";
string extension = "*";
List<FileInfo> files = GetFilesRecursively (rootDirectory, extension);
Console.WriteLine ("Got {0} files of extension {1} in directory {2}", files.Count, extension, rootDirectory);
foreach (FileInfo file in files)
{
Console.WriteLine(file);
var info = new System.IO.FileInfo(#"" + file + "");
Console.WriteLine("For file {0}", info.Name);
Console.WriteLine("Length is {0} KB", info.Length/1024);
Console.WriteLine("Creation time is {0}", info.CreationTime);
Console.WriteLine("Last access time is {0}", info.LastAccessTime);
Console.WriteLine("Last write time is {0}", info.LastWriteTime);
}
}
/// <summary>
/// This function calls itself recursively for each of the subdirectories that it finds
/// in the root directory passed to it. It returns files of the extension as specified
/// by the caller.
/// </summary>
/// <param name="rootDirectory">The directory from which the file list is sought.</param>
/// <param name="extension">The particular extension for which the file list is sought.</param>
/// <returns>A list of all the files with extension as specified by the caller. This list
/// includes the files in the current directory as well its sub-directories.</returns>
static List<FileInfo> GetFilesRecursively(string rootDirectory, string extension)
{
// Uncomment this line only if you want to trace the control as it goes from
// sub-directory to sub-directory. Be ready for long scrolls of text output:
//Console.WriteLine ("Currently in directory {0}", rootDirectory);
// Create an output list:
List<FileInfo> opList = new List<FileInfo>();
// Get all files in the current directory:
string[] allFiles = Directory.GetFiles (rootDirectory, "*." + extension);
// Add these files to the output list:
opList.AddRange(allFiles.Select(f => new FileInfo(f)));
// Get all sub-directories in current directory:
string[] subDirectories = Directory.GetDirectories (rootDirectory);
// And iterate through them:
foreach (string subDir in subDirectories) {
// Get all the files from the sub-directory:
List<FileInfo> subDirFileList = GetFilesRecursively (subDir, extension);
// And add it to this list:
opList.AddRange (subDirFileList);
}
// Finally return the output list:
return opList;
}
I have a situation where I have to find a path to the first file named my.exe starting from startingdirectory & \mydir\ and go deep as needed.
Actually, IO.Directory.GetFiles is suitable but I need it stop searching after the first file is found like it is possible with FindFirstFile from WinAPI.
VB.NET
Dim findedDirectories() As String = IO.Directory.GetFiles( _
startingdirectory & "\mydir\", "my.exe", IO.SearchOption.AllDirectories)
C#
string[] findedDirectories = IO.Directory.GetFiles( _
startingdirectory + "\\mydir\\", "my.exe", IO.SearchOption.AllDirectories);
Is it possible to stop searching after the first file is found in a way that the result of the function will be a string or an empty string, not a string array? Or is here better way to search for a first file in subdirectories?
A solution like the following one could help:
/// <summary>
/// Searches for the first file matching to searchPattern in the sepcified path.
/// </summary>
/// <param name="path">The path from where to start the search.</param>
/// <param name="searchPattern">The pattern for which files to search for.</param>
/// <returns>Either the complete path including filename of the first file found
/// or string.Empty if no matching file could be found.</returns>
public static string FindFirstFile(string path, string searchPattern)
{
string[] files;
try
{
// Exception could occur due to insufficient permission.
files = Directory.GetFiles(path, searchPattern, SearchOption.TopDirectoryOnly);
}
catch (Exception)
{
return string.Empty;
}
// If matching files have been found, return the first one.
if (files.Length > 0)
{
return files[0];
}
else
{
// Otherwise find all directories.
string[] directories;
try
{
// Exception could occur due to insufficient permission.
directories = Directory.GetDirectories(path);
}
catch (Exception)
{
return string.Empty;
}
// Iterate through each directory and call the method recursivly.
foreach (string directory in directories)
{
string file = FindFirstFile(directory, searchPattern);
// If we found a file, return it (and break the recursion).
if (file != string.Empty)
{
return file;
}
}
}
// If no file was found (neither in this directory nor in the child directories)
// simply return string.Empty.
return string.Empty;
}
I guess the simplest approach would be to organise the recursion into sub-directories yourself with recursive calls to Directory.GetDirectories passing SearchOption.TopDirectoryOnly. In each directory check for the file's existence with File.Exists.
This actually mirrors the way it would be done in Win32 with FindFirstFile. When using FindFirstFile you always need to implement the sub-directory recursion yourself because FindFirstFile has nothing analagous to SearchOption.AllDirectories.
Imagine I wish to create (or overwrite) the following file :- C:\Temp\Bar\Foo\Test.txt
Using the File.Create(..) method, this can do it.
BUT, if I don't have either one of the following folders (from that example path, above)
Temp
Bar
Foo
then I get an DirectoryNotFoundException thrown.
So .. given a path, how can we recursively create all the folders necessary to create the file .. for that path? If Temp or Bar folders exists, but Foo doesn't... then that is created also.
For simplicity, lets assume there's no Security concerns -- all permissions are fine, etc.
To summarize what has been commented in other answers:
//path = #"C:\Temp\Bar\Foo\Test.txt";
Directory.CreateDirectory(Path.GetDirectoryName(path));
Directory.CreateDirectory will create the directories recursively and if the directory already exist it will return without an error.
If there happened to be a file Foo at C:\Temp\Bar\Foo an exception will be thrown.
DirectoryInfo di = Directory.CreateDirectory(path);
Console.WriteLine("The directory was created successfully at {0}.",
Directory.GetCreationTime(path));
See this MSDN page.
Use Directory.CreateDirectory before you create the file. It creates the folder recursively for you.
. given a path, how can we recursively create all the folders necessary to create the file .. for that path
Creates all directories and subdirectories as specified by path.
Directory.CreateDirectory(path);
then you may create a file.
You will need to check both parts of the path (directory and filename) and create each if it does not exist.
Use File.Exists and Directory.Exists to find out whether they exist. Directory.CreateDirectory will create the whole path for you, so you only ever need to call that once if the directory does not exist, then simply create the file.
You should use Directory.CreateDirectory.
http://msdn.microsoft.com/en-us/library/54a0at6s.aspx
Assuming that your assembly/exe has FileIO permission is itself, well is not right. Your application may not run with admin rights. Its important to consider Code Access Security and requesting permissions
Sample code:
FileIOPermission f2 = new FileIOPermission(FileIOPermissionAccess.Read, "C:\\test_r");
f2.AddPathList(FileIOPermissionAccess.Write | FileIOPermissionAccess.Read, "C:\\example\\out.txt");
try
{
f2.Demand();
}
catch (SecurityException s)
{
Console.WriteLine(s.Message);
}
Understanding .NET Code Access Security
Is “Code Access Security” of any real world use?
You want Directory.CreateDirectory()
Here is a class I use (converted to C#) that if you pass it a source directory and a destination it will copy all of the files and sub-folders of that directory to your destination:
using System.IO;
public class copyTemplateFiles
{
public static bool Copy(string Source, string destination)
{
try {
string[] Files = null;
if (destination[destination.Length - 1] != Path.DirectorySeparatorChar) {
destination += Path.DirectorySeparatorChar;
}
if (!Directory.Exists(destination)) {
Directory.CreateDirectory(destination);
}
Files = Directory.GetFileSystemEntries(Source);
foreach (string Element in Files) {
// Sub directories
if (Directory.Exists(Element)) {
copyDirectory(Element, destination + Path.GetFileName(Element));
} else {
// Files in directory
File.Copy(Element, destination + Path.GetFileName(Element), true);
}
}
} catch (Exception ex) {
return false;
}
return true;
}
private static void copyDirectory(string Source, string destination)
{
string[] Files = null;
if (destination[destination.Length - 1] != Path.DirectorySeparatorChar) {
destination += Path.DirectorySeparatorChar;
}
if (!Directory.Exists(destination)) {
Directory.CreateDirectory(destination);
}
Files = Directory.GetFileSystemEntries(Source);
foreach (string Element in Files) {
// Sub directories
if (Directory.Exists(Element)) {
copyDirectory(Element, destination + Path.GetFileName(Element));
} else {
// Files in directory
File.Copy(Element, destination + Path.GetFileName(Element), true);
}
}
}
}
Following code will create directories (if not exists) & then copy files.
// using System.IO;
// for ex. if you want to copy files from D:\A\ to D:\B\
foreach (var f in Directory.GetFiles(#"D:\A\", "*.*", SearchOption.AllDirectories))
{
var fi = new FileInfo(f);
var di = new DirectoryInfo(fi.DirectoryName);
// you can filter files here
if (fi.Name.Contains("FILTER")
{
if (!Directory.Exists(di.FullName.Replace("A", "B"))
{
Directory.CreateDirectory(di.FullName.Replace("A", "B"));
File.Copy(fi.FullName, fi.FullName.Replace("A", "B"));
}
}
}