C# DirectoryInfo.CreateSubdirectory方法代码示例

        protected void btnupload_Click(object sender, EventArgs e)
        {
            string aud;
            aud = "Audio";

            string tempFolderAbsolutePath;
            tempFolderAbsolutePath = Server.MapPath("ShareData//");
            string subFolderRelativePath = @"Audio";//@"SubTemp1";

            DirectoryInfo tempFolder = new DirectoryInfo(tempFolderAbsolutePath);
            DirectoryInfo subFolder = tempFolder.CreateSubdirectory(subFolderRelativePath);

            string tempFileName = String.Concat(Guid.NewGuid().ToString(), @".MP3");

            string str = Path.GetExtension(FileUpload1.PostedFile.FileName);
            if ((str == ".mp3") || (str == ".wav") || (str == ".wma") || (str == ".aiff") || (str == ".au"))
            {
                FileUpload1.SaveAs(subFolder.FullName + "\\" + FileUpload1.FileName);
                SqlConnection con = new SqlConnection();
                SqlCommand cmd = new SqlCommand();
                con.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=D:\\CloudTest\\Irain-M\\Irain-M\\App_Data\\Database.mdf;Integrated Security=True;User Instance=True";
                con.Open();
                cmd.Connection = con;
                cmd.CommandText = "insert into sharedetails(filename,username,date,category) values ('" + FileUpload1.FileName + "','" + Label1.Text + "','" + DateTime.Now + "','" + aud + "')";
                cmd.ExecuteNonQuery();
                con.Close();
                ClientScript.RegisterStartupScript(typeof(Page), "MessagePopUp",
                               "alert('Audio uploaded successfully!'); window.location.href = 'share.aspx';", true);
            }
            else
            {
                ClientScript.RegisterStartupScript(typeof(Page), "MessagePopUp",
                                          "alert('This file format is not supported in this section!'); window.location.href = 'share.aspx';", true);
            }
        }

        /// <summary>
        /// Archives the exception report.
        /// The name of the PDF file is modified to make it easier to identify.
        /// </summary>
        /// <param name="pdfFile">The PDF file.</param>
        /// <param name="archiveDirectory">The archive directory.</param>
        public static void ArchiveException(FileInfo pdfFile, string archiveDirectory)
        {
            // Create a new subdirectory in the archive directory
            // This is based on the date of the report being archived
            DirectoryInfo di = new DirectoryInfo(archiveDirectory);
            string archiveFileName = pdfFile.Name;
            string newSubFolder = ParseFolderName(archiveFileName);
            try
            {
                di.CreateSubdirectory(newSubFolder);
            }
            catch (Exception ex)
            {
                // The folder already exists so don't create it
            }

            // Create destination path
            // Insert _EXCEPT into file name
            // This will make it easier to identify as an exception in the archive folder
            string destFileName = archiveFileName.Insert(archiveFileName.IndexOf("."), "_EXCEPT");
            string destFullPath = archiveDirectory + "\\" + newSubFolder + "\\" + destFileName;

            // Move the file to the archive directory
            try
            {
                pdfFile.MoveTo(destFullPath);
            }
            catch (Exception ex)
            {
            }
        }

        public static bool CopyDirectoryTree(this DirectoryInfo source, DirectoryInfo dest)
        {
            bool wasModified = false;

            if (!Directory.Exists(dest.FullName))
                Directory.CreateDirectory(dest.FullName);

            foreach (FileInfo file in source.EnumerateFiles())
            {
                var fileDest = Path.Combine(dest.ToString(), file.Name);
                if (!File.Exists(fileDest))
                {
                    file.CopyTo(fileDest);
                    wasModified = true;
                }
            }

            foreach (DirectoryInfo subDirectory in source.GetDirectories())
            {
                var dirDest = Path.Combine(dest.ToString(), subDirectory.Name);
                DirectoryInfo newDirectory = dest.CreateSubdirectory(subDirectory.Name);
                if (CopyDirectoryTree(subDirectory, newDirectory))
                    wasModified = true;
            }

            return wasModified;
        }

        /// <summary>
        /// Deep copy directory
        /// </summary>
        /// <param name="source"></param>
        /// <param name="target"></param>
        public static void DeepCopy(DirectoryInfo source, DirectoryInfo target)
        {
            try
            {
                // Recursively call the DeepCopy Method for each Directory
                foreach (DirectoryInfo dir in source.GetDirectories())
                {
                    DirectoryInfo subDir = target.CreateSubdirectory(dir.Name);

                    // --- IMPROVED SECTION ---
                    // Set the security settings for the new directory same as the source dir
                    subDir.SetAccessControl(new DirectorySecurity(dir.FullName, AccessControlSections.All));
                    DeepCopy(dir, target.CreateSubdirectory(dir.Name));
                }

                // Go ahead and copy each file in "source" to the "target" directory
                foreach (FileInfo file in source.GetFiles())
                {
                    file.CopyTo(Path.Combine(target.FullName, file.Name), true); // allow overwrite
                }
            }
            catch (Exception)
            {
                throw;
            }
        }

        static void Main(string[] args)
        {
            var directory = new DirectoryInfo(args[0]);
            var slides=directory.CreateSubdirectory("LaTeXCompiledSlides");
            slides.Delete(true);
            slides.Create();

            var latexDirectory = directory.CreateSubdirectory("LaTeX");
            var files = latexDirectory.GetFiles("L*.tex");
            var galleries = new List<GalleryInfo>();
            var processor = new LatexProcessor();

            foreach (var file in files)
            {
                var doc = processor.Parse(file);
                var docs = doc.Sections.Select(z => new LatexDocument { Preamble = doc.Preamble, Sections = new List<LatexSection> { z } }).ToList();
                int number = 0;
                foreach (var e in docs)
                {
                    var pdf = processor.Compile(e, latexDirectory);
                    var targetDirectory = slides.CreateSubdirectory(file.Name + "." + number);
                    processor.ConvertToPng(pdf, targetDirectory);
                    galleries.Add(new GalleryInfo { Name = e.LastSection.Name, Directory=targetDirectory });
                    number++;
                }
            }

            var matcher =
                Matchers.ByName<VideoItem, GalleryInfo>(galleries, z => z.Name, (a, b) => a.Directory.FullName == b.Directory.FullName);

            var model = EditorModelIO.ReadGlobalData(directory);
            var root = ItemTreeBuilder.Build<FolderItem, LectureItem, VideoItem>(model);
            matcher.Push(root);
            DataBinding<VideoItem>.SaveLayer<GalleryInfo>(root, directory);
        }

        // Constructor
        /// <summary>
        /// Open a profile (create if not exist) and load it.
        /// </summary>
        /// <param name="profileDirectory">The root directory of the profile</param>
        public CraftitudeProfile(DirectoryInfo profileDirectory)
        {
            Directory = profileDirectory;

            _craftitudeDirectory = Directory.CreateSubdirectory("craftitude");
            _craftitudeDirectory.CreateSubdirectory("repositories"); // repository package lists
            _craftitudeDirectory.CreateSubdirectory("packages"); // cached package setups

            _bsonFile = _craftitudeDirectory.GetFile("profile.bson");

            if (!_bsonFile.Exists)
            {
                ProfileInfo = new ProfileInfo();
            }
            else
            {
                using (FileStream bsonStream = _bsonFile.Open(FileMode.OpenOrCreate))
                {
                    using (var bsonReader = new BsonReader(bsonStream))
                    {
                        var jsonSerializer = new JsonSerializer();
                        ProfileInfo = jsonSerializer.Deserialize<ProfileInfo>(bsonReader) ?? new ProfileInfo();
                    }
                }
            }
        }

        private void CreateNewPackage(string name, string version)
        {
            var runtimeForPacking = TestUtils.GetClrRuntimeComponents().FirstOrDefault();
            if (runtimeForPacking == null)
            {
                throw new InvalidOperationException("Can't find a CLR runtime to pack test packages.");
            }

            var runtimeHomePath = base.GetRuntimeHomeDir((string)runtimeForPacking[0],
                                                         (string)runtimeForPacking[1],
                                                         (string)runtimeForPacking[2]);

            using (var tempdir = new DisposableDir())
            {
                var dir = new DirectoryInfo(tempdir);
                var projectDir = dir.CreateSubdirectory(name);
                var outputDir = dir.CreateSubdirectory("output");
                var projectJson = Path.Combine(projectDir.FullName, "project.json");

                File.WriteAllText(projectJson, [email protected]"{{
  ""version"": ""{version}"",
  ""frameworks"": {{ 
      ""dnx451"": {{ }}
  }}
}}");
                DnuTestUtils.ExecDnu(runtimeHomePath, "restore", projectJson);
                DnuTestUtils.ExecDnu(runtimeHomePath, "pack", projectJson + " --out " + outputDir.FullName, environment: null, workingDir: null);

                var packageName = string.Format("{0}.{1}.nupkg", name, version);
                var packageFile = Path.Combine(outputDir.FullName, "Debug", packageName);

                File.Copy(packageFile, Path.Combine(PackageSource, packageName), overwrite: true);
            }
        }

        protected override void AnnotateCorpus(
            Corpus corpus, System.Threading.CancellationToken token)
        {
            token.ThrowIfCancellationRequested();

            Guid taskId = Guid.NewGuid();

            DirectoryInfo dir = new DirectoryInfo(
                AppDomain.CurrentDomain.BaseDirectory);

            dir = dir.CreateSubdirectory("Tasks");
            dir = dir.CreateSubdirectory(taskId.ToString());

            string dataFile = dir.FullName + "\\Corpus.crfppdata";
            string outputFile = dir.FullName + "\\Output.crfppdata";

            try
            {
                AnnotationProgressChangedEventArgs ePrepared =
                    new AnnotationProgressChangedEventArgs(
                        1, 3, MessagePreparing);
                OnAnnotationProgressChanged(ePrepared);

                CRFPPHelper.EncodeCorpusToCRFPPData(corpus, dataFile);
                token.ThrowIfCancellationRequested();

                AnnotationProgressChangedEventArgs eAnnotating =
                    new AnnotationProgressChangedEventArgs(
                        2, 3, MessageAnnotating);
                OnAnnotationProgressChanged(eAnnotating);

                CRFPPHelper.Annotate(
                    Model.RootPath, dataFile, outputFile, 1, 0);
                token.ThrowIfCancellationRequested();

                AnnotationProgressChangedEventArgs eFinishing =
                    new AnnotationProgressChangedEventArgs(
                        3, 3, MessageFinishing);
                OnAnnotationProgressChanged(eFinishing);

                CRFPPHelper.DecodeCorpusFromCRFPPData(corpus, outputFile);
                token.ThrowIfCancellationRequested();
            }
            catch
            {
                throw;
            }
            finally
            {
                File.Delete(dataFile);
                File.Delete(outputFile);

                try
                {
                    dir.Delete();
                }
                catch { }
            }
        }

        static void ModifyAppDirectory() {
            DirectoryInfo dir = new DirectoryInfo(".");

            dir.CreateSubdirectory("MyFolder");
            DirectoryInfo myDataFolder = dir.CreateSubdirectory(@"MyFolder\Data");
            Console.WriteLine("New folderr is {0}", myDataFolder);
            Console.WriteLine();
        }

 /// <summary>
 /// Create Project Folder
 /// <para>Programmer:Sarwan</para>
 /// <para>lab.uyghurdev.net</para>
 /// </summary>
 /// <param name="strRootPath"></param>
 public void createProjectFolder(string strRootPath)
 {
     DirectoryInfo di = new DirectoryInfo(strRootPath);
     if (!di.Exists)
     {
         di.Create();
     }
     di.CreateSubdirectory( Settings.PICTURE_FOLDER);//Create Picture folder in root folder
     di.CreateSubdirectory( Settings.SOUND_FOLER);//Create Sound folder in root folder.
 }

 public WurmPlayer(DirectoryInfo playerDir, string name, Platform targetPlatform)
 {
     Name = name;
     this.playerDir = playerDir;
     DumpsDir = playerDir.CreateSubdirectory("dumps");
     LogsDir = playerDir.CreateSubdirectory("logs");
     ScreenshotsDir = playerDir.CreateSubdirectory("screenshots");
     ConfigTxt = new FileInfo(Path.Combine(playerDir.FullName, "config.txt"));
     File.WriteAllText(ConfigTxt.FullName, string.Empty);
     Logs = new WurmLogs(LogsDir, targetPlatform);
 }

        public void Export(string dir)
        {
            throw new NotImplementedException();

            DirectoryInfo exportDir = new DirectoryInfo(dir);

            Dictionary<World, tempDictTwo> dict = new Dictionary<World, tempDictTwo>();

            var maps = exportDir.CreateSubdirectory("Maps");
            var graphics = exportDir.CreateSubdirectory("Graphics");
            var data = exportDir.CreateSubdirectory("Data");

            foreach (var world in this.WorldsList)
            {
                maps.CreateSubdirectory(world.Value.Name);
                graphics.CreateSubdirectory(world.Value.Name);

                tempDictTwo td = new tempDictTwo();

                foreach (var map in world.Value.MapList)
                {
                    tempStorage t = new tempStorage();
                    t.oldTexture = map.Value.Map.TextureName;
                    t.oldPath = map.Value.MapFileLocation;

                    td.dict.Add(map.Value.Map, t);

                    var pictStrings = map.Value.Map.TextureName.Split(new char[] { '\\', '.' });
                    string imageExt = pictStrings.Last();

                    map.Value.MapFileLocation = Path.Combine (world.Value.Name, map.Value.Map.Name + ".xml");
                    String newTexturePath = Path.Combine (world.Value.Name, map.Value.Map.Name + "." + imageExt);

                    File.Copy(Path.Combine (TileEngine.TextureManager.TextureRoot, map.Value.Map.TextureName), Path.Combine (graphics.FullName, newTexturePath), true);
                    map.Value.Map.TextureName = newTexturePath;

                    //map.Value.Map.Save(Path.Combine(maps.FullName, map.Value.MapFileLocation));
                }

                dict.Add(world.Value, td);
            }

            Save(Path.Combine(data.FullName, this.FileName));

            foreach (var world in this.WorldsList)
            {
                foreach (var map in world.Value.MapList)
                {
                    map.Value.Map.TextureName = dict[world.Value].dict[map.Value.Map].oldTexture;
                    map.Value.MapFileLocation = dict[world.Value].dict[map.Value.Map].oldPath;
                }
            }
        }

        static void ModifyAppDirectory()
        {
            DirectoryInfo dir = new DirectoryInfo(@"C:\");

            // Create \MyFolder off application directory.
            dir.CreateSubdirectory("MyFolder");

            // Create \MyFolder2\Data off application directory.
            DirectoryInfo myDataFolder = dir.CreateSubdirectory(@"MyFolder2\Data");

            Console.WriteLine("New Folder is: {0}", myDataFolder);
        }

        static void ModifyAppDirectory()
        {
            DirectoryInfo dir = new DirectoryInfo(".");

            // Create \MyFolder off initial directory.
            dir.CreateSubdirectory("MyFolder");

            // Capture returned DirectoryInfo object.
            DirectoryInfo myDataFolder = dir.CreateSubdirectory(@"MyFolder2\Data");

            // Prints path to ..\MyFolder2\Data.
            Console.WriteLine("New Folder is: {0}", myDataFolder);
        }

        static void Main(string[] args)
        {
            string[] tabFichier = Directory.GetFiles(@"C:\Windows\Web\Wallpaper");

            foreach (string fichier in tabFichier)
                Console.WriteLine(fichier);

            Console.ReadLine();

            DirectoryInfo dir = new DirectoryInfo(@"C:\Windows\Web\Wallpaper");
            FileInfo[] tableauImages = dir.GetFiles("*.jpg");

            foreach (FileInfo f in tableauImages)
            {
                Console.WriteLine("***************************");
                Console.WriteLine("Nom Fichier: {0}", f.Name);
                Console.WriteLine("Taille: {0}", f.Length);
                Console.WriteLine("Création: {0}", f.CreationTime);
                Console.WriteLine("Attributs: {0}", f.Attributes);
                Console.WriteLine("***************************\n");
            }

            DirectoryInfo dir2 = new DirectoryInfo(".");

            // Mon Répertoire
            dir2.CreateSubdirectory(@"Mon Répertoire");

            // Mon Répertoire2
            DirectoryInfo nouveau = dir2.CreateSubdirectory
                (@"Mon Répertoire2\Données");

            DriveInfo[] mesDisques = DriveInfo.GetDrives();

            foreach (DriveInfo d in mesDisques)
            {
                Console.WriteLine("Nom: {0}", d.Name); // C ou D
                Console.WriteLine("Type: {0}", d.DriveType); // fixe

                if (d.IsReady)
                {
                    Console.WriteLine("Espace libre: {0}", d.TotalFreeSpace);
                    Console.WriteLine("Système fichier: {0}", d.DriveFormat);
                    Console.WriteLine("Nom: {0}\n", d.VolumeLabel);
                }
            }

            Console.ReadLine();


        }