C# DirectoryInfo.CreateFolderResourceInfo方法代码示例

    public void Creating_Item_From_Inexisting_Folder_Should_Provides_Names_And_Default_Properties()
    {
      DirectoryInfo di = new DirectoryInfo("test");
      Assert.IsFalse(di.Exists);

      VirtualFolderInfo item = di.CreateFolderResourceInfo();
      Assert.AreEqual("test", item.Name);
      Assert.AreEqual(di.FullName, item.FullName);

      //timestamps should be null
      Assert.IsNull(item.CreationTime);
      Assert.IsNull(item.LastAccessTime);
      Assert.IsNull(item.LastWriteTime);

      //the item should not be hidden / readonly
      Assert.IsFalse(item.IsHidden);
      Assert.IsFalse(item.IsReadOnly);

      //item is not root folder
      Assert.IsFalse(item.IsRootFolder);
    }

    /// <summary>
    /// Creates a new folder in the file system.
    /// </summary>
    /// <param name="parentFolderPath">The qualified name of the designated parent folder, which
    /// needs to exists, and provide write access.</param>
    /// <param name="folderName">The name of the folder to be created.</param>
    /// <returns>A <see cref="VirtualFileInfo"/> instance which represents
    /// the created folder.</returns>
    /// <exception cref="ArgumentNullException">If <paramref name="parentFolderPath"/>
    /// is a null reference.</exception>
    /// <exception cref="ArgumentNullException">If <paramref name="folderName"/>
    /// is a null reference.</exception>
    /// <exception cref="ResourceAccessException">In case of invalid or prohibited
    /// resource access.</exception>
    /// <exception cref="VirtualResourceNotFoundException">If no folder exists that
    /// matches the submitted <paramref name="parentFolderPath"/>.</exception>
    /// <exception cref="ResourceOverwriteException">If the folder already exists on the file
    /// system.</exception>
    public override VirtualFolderInfo CreateFolder(string parentFolderPath, string folderName)
    {
      if (parentFolderPath == null) throw new ArgumentNullException("parentFolderPath");
      if (folderName == null) throw new ArgumentNullException("folderName");

      string absoluteParentPath;
      var parent = GetFolderInfoInternal(parentFolderPath, true, out absoluteParentPath);

      if (RootDirectory == null && parent.IsRootFolder)
      {
        VfsLog.Debug("Blocked attempt to create a folder '{0}' at system root.", folderName);
        throw new ResourceAccessException("Folders cannot be created at the system root.");
      }
      
      //create path of the child
      string childPath = PathUtil.GetAbsolutePath(folderName, new DirectoryInfo(absoluteParentPath));

      //make sure the folder name is not a relative path that points outside the scope
      if (RootDirectory != null && !RootDirectory.IsParentOf(childPath))
      {
        string msg = "Blocked attempt to create folder outside of root through with parent '{0}' and folder name '{1}'";
        VfsLog.Warn(msg, absoluteParentPath, folderName);

        throw new ResourceAccessException("Invalid file path: " + folderName);
      }

      var directory = new DirectoryInfo(childPath);
      if (directory.Exists)
      {
        //log and create exception if the directory already exists
        VfsLog.Debug("Blocked attempt to recreate directory '{0}'", directory.FullName);
        string relativePath = PathUtil.GetRelativePath(childPath, RootDirectory);
        string msg = String.Format("The folder '{0}' already exists.", relativePath);
        throw new ResourceOverwriteException(msg);
      }

      try
      {
        //create directory
        directory.Create();
      }
      catch (Exception e)
      {
        const string msg = "Exception occurred when trying to create new folder '{0}' for parent '{1}'";
        VfsLog.Debug(e, msg, folderName, parent.FullName);

        throw new ResourceAccessException("Could not create folder", e);
      }

      var folder = directory.CreateFolderResourceInfo();

      //adjust and return
      if (UseRelativePaths) folder.MakePathsRelativeTo(RootDirectory);
      return folder;
    }

    protected VirtualFolderInfo GetFolderInfoInternal(string virtualFolderPath, bool mustExist, out string absolutePath)
    {
      try
      {
        //make sure we operate on absolute paths
        absolutePath = PathUtil.GetAbsolutePath(virtualFolderPath ?? "", RootDirectory);

        if (IsRootPath(absolutePath))
        {
          return GetFileSystemRoot();
        }

        var di = new DirectoryInfo(absolutePath);
        VirtualFolderInfo folderInfo = di.CreateFolderResourceInfo();

        //convert to relative paths if required (also prevents qualified paths in validation exceptions)
        if (UseRelativePaths) folderInfo.MakePathsRelativeTo(RootDirectory);

        //make sure the user is allowed to access the resource
        ValidateResourceAccess(folderInfo);

        //verify folder exists on FS
        if(mustExist) folderInfo.VerifyDirectoryExists(RootDirectory);

        return folderInfo;
      }
      catch (VfsException)
      {
        //just bubble internal exceptions
        throw;
      }
      catch (Exception e)
      {
        VfsLog.Debug(e, "Could not create directory based on path '{0}' with root '{1}'", virtualFolderPath,
                           RootDirectory);
        throw new ResourceAccessException("Invalid path submitted: " + virtualFolderPath);
      }
    }

        public  FolderItem ResolveFolderResourcePath2(string submittedFolderPath, FileSystemTask context) {
            //make sure we operate on absolute paths
            string absolutePath = PathUtil.GetAbsolutePath(submittedFolderPath ?? "", RootDirectory);

            if (IsRootPath(absolutePath)) {
                return GetFileSystemRootImplementation() as FolderItem;
            }

            var di = new DirectoryInfo(absolutePath);
            VirtualFolderInfo folderInfo = di.CreateFolderResourceInfo();

            var item = new FolderItem(di, folderInfo);

            //convert to relative paths if required (also prevents qualified paths in validation exceptions)
            if (UseRelativePaths) item.MakePathsRelativeTo(RootDirectory);

            ValidateFolderRequestAccess(item, submittedFolderPath, context);
            return item;
        }