C# DirectoryInfo.ToString方法代码示例

    /// <summary>
    /// Recursive Copy Directory Method
    /// </summary>
    private static void CopyAll(DirectoryInfo source, DirectoryInfo target)
    {
        // Check if the source directory exists, if not, don't do any work.
        if (!Directory.Exists(source.FullName))
        {
            return;
        }

        // Check if the target directory exists, if not, create it.
        if (!Directory.Exists(target.FullName))
        {
            Directory.CreateDirectory(target.FullName);
        }

        // Copy each file into it’s new directory.
        foreach (var fileInfo in source.GetFiles())
        {
            fileInfo.CopyTo (Path.Combine (target.ToString (), fileInfo.Name), true);
        }

        // Copy each subdirectory using recursion.
        foreach (var subDirInfo in source.GetDirectories())
        {
            DirectoryInfo nextTargetSubDir = target.CreateSubdirectory(subDirInfo.Name);
            CopyAll(subDirInfo, nextTargetSubDir);
        }
    }

    /// <summary>
    /// Verzeichnis rekursiv kopieren. Vorhandene Dateien werden überschreiben
    /// </summary>
    /// <param name="source">QuellVERZEICHNIS</param>
    /// <param name="target">ZielVERZEICHNIS</param>
    /// <param name="dirCount">für jedes erzeugte Verzeichnis +=1</param>
    /// <param name="fileCount">für jede erzeugte Datei +=1</param>
    public static void CopyAll(
		DirectoryInfo source,
		DirectoryInfo target,
		ref int dirCount,
		ref int fileCount)
    {
        // Check if the target directory exists, if not, create it.
        if (!Directory.Exists(target.FullName))
        {
            dirCount++;
            Directory.CreateDirectory(target.FullName);
            Logger.Log("Verzeichnis erstellt: " + target.FullName);
        }

        // Copy each file into it’s new directory.
        foreach (FileInfo fi in source.GetFiles())
        {
            fileCount++;
            fi.CopyTo(Path.Combine(target.ToString(), fi.Name), true);
            Logger.Log("Datei kopiert: " + fi.FullName);
        }

        // Copy each subdirectory using recursion.
        foreach (DirectoryInfo diSrcSubDir in source.GetDirectories())
        {
            dirCount++;
            DirectoryInfo diNext = target.CreateSubdirectory(diSrcSubDir.Name);
            CopyAll(diSrcSubDir, diNext, ref dirCount, ref fileCount);
        }
    }

    protected void Page_Load(object sender, EventArgs e)
    {
        string url = Request.Url.ToString();
        ArrayList list = new ArrayList();
        string str = string.Empty;
        DirectoryInfo dir = new DirectoryInfo(Server.MapPath(""));
        string filepath = dir.ToString().Replace("Facility", "app_offline.htm");

        if (url.IndexOf("status") != -1)
        {
            string query = Request.QueryString["status"].ToString();
            switch (query.ToUpper())
            {
                case "GET":
                    {
                        Config config = new Config();
                        config.PrintConfig1 = IMonitorConfig.GetSetting("print1");
                        config.PrintConfig2 = IMonitorConfig.GetSetting("print2");
                        config.RouterConfig = IMonitorConfig.GetSetting("router");
                        config.LaptopConfig = IMonitorConfig.GetSetting("laptop");
                        list.Add(config);
                    }
                    break;
                case "SET":
                    {
                        if (!File.Exists(filepath))
                        {
                            using (FileStream fs = File.Create(filepath))
                            {
                                fs.WriteByte(0);
                            }
                        }
                        File.Delete(filepath);
                        string print1 = Request.QueryString["print1"].ToString();
                        string print2 = Request.QueryString["print2"].ToString();
                        string router = Request.QueryString["router"].ToString();
                        string laptop = Request.QueryString["laptop"].ToString();
                        string[] name = { "print1", "print2", "router", "laptop" };
                        string[] value = { print1, print2, router, laptop };
                        IMonitorConfig.WriteSetting(name, value);
                        Response.Write("更新成功！");
                        Response.End();
                        return;
                    }
            }
        }
        else
        {
            Response.Write("This is Iwooo Monitor System");
            Response.End();
            return;
        }

        JavaScriptSerializer json = new JavaScriptSerializer();
        str = json.Serialize(list);

        Response.Write(str);
        Response.End();
        return;
    }

 public void SerializeDeserialize_Roundtrip()
 {
     var orig = new DirectoryInfo("SomePath");
     DirectoryInfo cloned = BinaryFormatterHelpers.Clone(orig);
     Assert.Equal(orig.Name, cloned.Name);
     Assert.Equal(orig.FullName, cloned.FullName);
     Assert.Equal(orig.ToString(), cloned.ToString());
 }

 public static string path()
 {
     string returnpath = "";
     DirectoryInfo ParentDirectory = new DirectoryInfo(Application.dataPath);
     ParentDirectory = ParentDirectory.Parent;
     returnpath = ParentDirectory.ToString();
     returnpath = returnpath + "/Resources/"+"Items/";
     Debug.Log(returnpath);
     return returnpath;
 }

    /// <summary>
    /// Datei source ins Verzeichnis target kopieren. Überschreibt vorhandene
    /// Dateien.
    /// </summary>
    /// <param name="source">QuellDATEI</param>
    /// <param name="target">ZielVERZEICHNIS</param>
    /// <param name="fileCount">wird um 1 erhöht, wenn erfolgreich</param>
    public static void CopyFile(
		FileInfo source,
		DirectoryInfo target,
		ref int fileCount)
    {
        if (source.Exists)
        {
            fileCount++;
            source.CopyTo(Path.Combine(target.ToString(), source.Name), true);
            Logger.Log("Datei kopiert: " + source.FullName);
        }
        else
        {
            Logger.LogError("Datei nicht gefunden: " + source.FullName);
        }
    }

    public static void OnPostProcessBuild(BuildTarget target, string path)
    {
        Debug.Log("Post Processing Build");

        // Get Required Paths
        projectParent = Directory.GetParent(Application.dataPath);
        buildname = Path.GetFileNameWithoutExtension(path);
        targetdir = Directory.GetParent(path);
        char divider = Path.DirectorySeparatorChar;
        string dataMarker = "_Data"; // Specifically for Windows Standalone build
        buildDataDir = targetdir.FullName + divider + buildname + dataMarker + divider;

        // Do Certain actions on your files (Copy, remove or email them to NASA your decision)
        filecount = 0;
        dircount = 0;
        CopyAll(new DirectoryInfo(projectParent.ToString() + divider + srcName), new DirectoryInfo(buildDataDir));

        Debug.Log("Copied: " + filecount + " file" +((filecount!=1)?"s":"")+ ", " + dircount + " folder" +((dircount!=1)?"s":""));
    }

    public bool LoadCubiquity(TargetInfo Target)
    {
        bool isLibrarySupported = false;

        if((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32))
        {
            isLibrarySupported = true;

            string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "Win64" : "Win32";

            //string remotePath = @"http://www.volumesoffun.com/downloads/Cubiquity/Cubiquity-2015-06-14.zip";
            //System.IO.Compression.ZipFile.ExtractToDirectory(remotePath, extractPath);

            //Copy the Cubiquity DLL into the binaries directory locally
            FileInfo file = new FileInfo(Path.Combine(ThirdPartyLibraryPath, "CubiquityC.dll"));
            DirectoryInfo destDir = new DirectoryInfo(Path.Combine(ModulePath, "..", "..", "Binaries", PlatformString));
            destDir.Create();
            FileInfo destFile = new FileInfo(Path.Combine(destDir.ToString(), "CubiquityC.dll"));
            if (destFile.Exists)
            {
                if (file.LastWriteTime > destFile.LastWriteTime)
                {
                    file.CopyTo(destFile.FullName, true);
                }
            }
            else
            {
                file.CopyTo(destFile.FullName, true);
            }

            //Make sure we can link against the .lib file
            PublicAdditionalLibraries.Add(Path.Combine(ThirdPartyLibraryPath, "CubiquityC.lib"));
        }

        if(isLibrarySupported)
        {
            // Include path
            PublicIncludePaths.Add(ThirdPartyIncludePath);
        }

        return isLibrarySupported;
    }

	static void PerformDeepCopy(string sourceDirectory, string destinationDirectory)
	{
		if (!Directory.Exists(destinationDirectory))
		{
			Directory.CreateDirectory(destinationDirectory);
		}
		
		var sourceDir = new DirectoryInfo(sourceDirectory);
		var targetDir = new DirectoryInfo(destinationDirectory);
		
		foreach (FileInfo f in sourceDir.GetFiles())
		{
			if(f.Extension != ".meta")
			{
				String file = Path.Combine(targetDir.ToString(), f.Name);
				try
				{
					f.CopyTo(file, true);
				}
				catch(Exception e)
				{
					Debug.LogError(e.Message);
					allFilesExists = false;
				}
				
				if(!File.Exists(file))
				{
					allFilesExists = false;
				}
			}
		}
		
		foreach (DirectoryInfo dir in sourceDir.GetDirectories())
		{
			var subDirectory = targetDir.CreateSubdirectory(dir.Name);
			PerformDeepCopy(dir.FullName, subDirectory.FullName);
		}
	}

	public bool runTest()
	{
		Console.WriteLine(s_strTFPath + "\\" + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer);
		int iCountErrors = 0;
		int iCountTestcases = 0;
		String strLoc = "Loc_000oo";
		String strValue = String.Empty;
		try
		{
			DirectoryInfo dir2;
			strLoc = "Loc_t987b";
			dir2 = new DirectoryInfo(".");
			iCountTestcases++;
			if(File.Exists(dir2.ToString())) {
				iCountErrors++;
				printerr( "Error_94939! Incorrect return");
			}		
			dir2 = new DirectoryInfo("BogusNAmeHere");
			iCountTestcases++;
			if(File.Exists(dir2.ToString())) {
				iCountErrors++;
				printerr( "Error_029uv! Incorrect return");
			}
		} catch (Exception exc_general ) {
			++iCountErrors;
			Console.WriteLine (s_strTFAbbrev + " : Error Err_8888yyy!  strLoc=="+ strLoc +", exc_general=="+exc_general.ToString());
		}
		if ( iCountErrors == 0 )
		{
			Console.WriteLine( "paSs. "+s_strTFName+" ,iCountTestcases=="+iCountTestcases.ToString());
			return true;
		}
		else
		{
			Console.WriteLine("FAiL! "+s_strTFName+" ,iCountErrors=="+iCountErrors.ToString()+" , BugNums?: "+s_strActiveBugNums );
			return false;
		}
	}

    /// <summary>
    /// 删除指定文件夹下所有文件 
    /// </summary>
    /// <param name="path"></param>
    /// <returns></returns>
    public static bool DeleteFiles(string path)
    {
        if (Directory.Exists(path) == false)
            {
                MessageBox.Show("Path is not Existed!");
                return false;
            }
            DirectoryInfo dir = new DirectoryInfo(path);
            FileInfo[] files = dir.GetFiles();
            try
            {
                foreach (var item in files)
                {
                    File.Delete(item.FullName);
                }
                if (dir.GetDirectories().Length != 0)
                {
                    foreach (var item in dir.GetDirectories())
                    {
                        if (!item.ToString().Contains("$") && (!item.ToString().Contains("Boot")))
                        {
                            // Console.WriteLine(item);

                            DeleteFiles(dir.ToString() + "\\" + item.ToString());
                        }
                    }
                }
                //Directory.Delete(path);
                return true;
            }
            catch (Exception)
            {
                MessageBox.Show("Delete Failed!");
                return false;

            }
    }

    /// <summary>
    /// Recursive Copy Directory Method
    /// </summary>
    public static void CopyAll(DirectoryInfo source, DirectoryInfo target)
    {
        // Check if the target directory exists, if not, create it.
        if (Directory.Exists(target.FullName) == false)
        {
            dircount++;
            Directory.CreateDirectory(target.FullName);
        }

        // Copy each file into it’s new directory.
        foreach (FileInfo fi in source.GetFiles())
        {
            filecount++;
            fi.CopyTo(Path.Combine(target.ToString(), fi.Name), true);
        }

        // Copy each subdirectory using recursion.
        foreach (DirectoryInfo diSourceSubDir in source.GetDirectories())
        {
            dircount++;
            DirectoryInfo nextTargetSubDir = target.CreateSubdirectory(diSourceSubDir.Name);
            CopyAll(diSourceSubDir, nextTargetSubDir);
        }
    }

 public void ValidDirectory()
 {
     string path = GetTestFilePath();
     var info = new DirectoryInfo(path);
     Assert.Equal(path, info.ToString());
 }

 public void CurrentDirectory()
 {
     string path = ".";
     var info = new DirectoryInfo(path);
     Assert.Equal(Path.GetFileName(Directory.GetCurrentDirectory()), info.ToString());
 }

		public void TestToString()
		{
			var fi = new DirectoryInfo(longPathDirectory);

			Assert.AreEqual(fi.DisplayPath, fi.ToString());
		}