internal void WriteLicense(string path, string netsealId, LicenseFile licenseFile, FileAttributes attributes = 0)
        {
            if (string.IsNullOrWhiteSpace(path))
                throw new Exception("path");

            InternalWriteLicense(path, netsealId, licenseFile, attributes);
        }

        private void btnSave_Click(object sender, EventArgs e)
        {
            FileInfo fi = new FileInfo(this.openFileDialog1.FileName);
            FileAttributes fa = new FileAttributes();

            foreach(object o in this.chkListFileAttributes.CheckedItems)
            {
                fa = fa | (FileAttributes)(Enum)o;
            }

            try
            {
                if(fi.IsReadOnly) fi.IsReadOnly = false;
                fi.CreationTime = DateTime.Parse(this.txtCreationTime.Text);
                fi.LastAccessTime = DateTime.Parse(this.txtLastAccessTime.Text);
                fi.LastWriteTime = DateTime.Parse(this.txtLastWriteTime.Text);

                fi.Attributes = fa;
                getFileInfo(fi);

            }catch(Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

 public Node(string name, FileAttributes attrs)
 {
     Attributes = attrs;
     Name = name;
     Parents = new HashSet<Node>();
     Contains = new HashSet<Node>();
 }

        private static string FromFileAttribs(FileAttributes attribs)
        {
            var str = new StringBuilder(9);

            if ((attribs & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
                str.Append('R');
            if ((attribs & FileAttributes.Archive) == FileAttributes.Archive)
                str.Append('A');
            if ((attribs & FileAttributes.System) == FileAttributes.System)
                str.Append('S');
            if ((attribs & FileAttributes.Hidden) == FileAttributes.Hidden)
                str.Append('H');
            if ((attribs & FileAttributes.Normal) == FileAttributes.Normal)
                str.Append('N');
            if ((attribs & FileAttributes.Directory) == FileAttributes.Directory)
                str.Append('D');
            if ((attribs & FileAttributes.Offline) == FileAttributes.Offline)
                str.Append('O');
            if ((attribs & FileAttributes.Compressed) == FileAttributes.Compressed)
                str.Append('C');
            if ((attribs & FileAttributes.Temporary) == FileAttributes.Temporary)
                str.Append('T');

            return str.ToString();
        }

 private static string GetAttributeLetter(FileAttributes fileAttributes, FileAttributes attributeToSearch, string attributeLetter)
 {
     if ((fileAttributes & attributeToSearch) == attributeToSearch)
         return attributeLetter;
     else
         return "-";
 }

        public static long Pack(FileAttributes fa)
        {
            long ret = 0;
            if ((fa & FileAttributes.Directory) > 0) ret |= Directory;

            return ret;
        }

 public FileTreeNodeProperty(string _name, FileTreeNodeType _type, string _fullPath, FileAttributes _fileSystemAttributes)
 {
     name__ = _name;
     type__ = _type;
     fullPath__ = _fullPath;
     fileSystemAttributes__ = _fileSystemAttributes;
 }

        public static Stream CreateFile(
            string fileName, FileAccess fileAccess, FileShare fileShare, FileMode fileMode, FileAttributes flags)
        {
            // TODO: This is not quite right, but it's close.
            //
            var nativeAccess = fileAccess;
            if ((nativeAccess & FileAccess.Read) != 0)
            {
                nativeAccess &= ~FileAccess.Read;
                nativeAccess |= (FileAccess)GENERIC_READ;
            }
            if ((nativeAccess & FileAccess.Write) != 0)
            {
                nativeAccess &= ~FileAccess.Write;
                nativeAccess |= (FileAccess)GENERIC_WRITE;
            }

            var handle = _CreateFile(fileName, nativeAccess, fileShare, IntPtr.Zero, fileMode, flags, IntPtr.Zero);
            if (handle.IsInvalid)
            {
                Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
            }

            return new SimpleFileStream(handle);
        }

 public void PathAlreadyExistsAsDirectory(FileAttributes attributes)
 {
     string path = GetTestFileName();
     DirectoryInfo testDir = Directory.CreateDirectory(Path.Combine(TestDirectory, path));
     testDir.Attributes = attributes;
     Assert.Equal(testDir.FullName, new DirectoryInfo(TestDirectory).CreateSubdirectory(path).FullName);
 }

 public void UnixInvalidAttributes(FileAttributes attr)
 {
     var path = GetTestFilePath();
     File.Create(path).Dispose();
     Set(path, attr);
     Assert.Equal(FileAttributes.Normal, Get(path));
 }

        internal static IEnumerable<IFileSystemInformation> EnumerateChildrenInternal(
            string directory,
            ChildType childType,
            string searchPattern,
            System.IO.SearchOption searchOption,
            FileAttributes excludeAttributes,
            IFileService fileService)
        {
            // We want to be able to see all files as we recurse and open new find handles (that might be over MAX_PATH).
            // We've already normalized our base directory.
            string extendedDirectory = Paths.AddExtendedPrefix(directory);

            // The assertion here is that we want to find files that match the desired pattern in all subdirectories, even if the
            // subdirectories themselves don't match the pattern. That requires two passes to avoid overallocating for directories
            // with a large number of files.

            // First look for items that match the given search pattern in the current directory
            using (FindOperation findOperation = new FindOperation(Paths.Combine(extendedDirectory, searchPattern)))
            {
                FindResult findResult;
                while ((findResult = findOperation.GetNextResult()) != null)
                {
                    bool isDirectory = (findResult.Attributes & FileAttributes.FILE_ATTRIBUTE_DIRECTORY) == FileAttributes.FILE_ATTRIBUTE_DIRECTORY;

                    if ((findResult.Attributes & excludeAttributes) == 0
                        && findResult.FileName != "."
                        && findResult.FileName != ".."
                        && ((isDirectory && childType == ChildType.Directory)
                            || (!isDirectory && childType == ChildType.File)))
                    {
                        yield return FileSystemInformation.Create(findResult, directory, fileService);
                    }
                }
            }

            if (searchOption != System.IO.SearchOption.AllDirectories) yield break;

            // Now recurse into each subdirectory
            using (FindOperation findOperation = new FindOperation(Paths.Combine(extendedDirectory, "*"), directoriesOnly: true))
            {
                FindResult findResult;
                while ((findResult = findOperation.GetNextResult()) != null)
                {
                    // Unfortunately there is no guarantee that the API will return only directories even if we ask for it
                    bool isDirectory = (findResult.Attributes & FileAttributes.FILE_ATTRIBUTE_DIRECTORY) == FileAttributes.FILE_ATTRIBUTE_DIRECTORY;

                    if ((findResult.Attributes & excludeAttributes) == 0
                        && isDirectory
                        && findResult.FileName != "."
                        && findResult.FileName != "..")
                    {
                        foreach (var child in EnumerateChildrenInternal(Paths.Combine(directory, findResult.FileName), childType, searchPattern,
                            searchOption, excludeAttributes, fileService))
                        {
                            yield return child;
                        }
                    }
                }
            }
        }

 public void WriteAllBytes(string path, byte[] bytes, FileAttributes attributes)
 {
     if (File.Exists(path))
         File.SetAttributes(path, FileAttributes.Normal);
     File.WriteAllBytes(path, bytes);
     File.SetAttributes(path, attributes);
 }

        public static void AddTree(DirNode dirNode, string dirPrefix, string filePrefix, int width, int depth, int fileSizeInKB, FileAttributes? fa = null, DateTime? lmt = null)
        {
            for (int i = 0; i < width; ++i)
            {
                string fileName = i == 0 ? filePrefix : filePrefix + "_" + i;
                FileNode fileNode = new FileNode(fileName)
                {
                    SizeInByte = 1024L * fileSizeInKB,
                    FileAttr = fa,
                    LastModifiedTime = lmt,
                };

                dirNode.AddFileNode(fileNode);
            }

            if (depth > 0)
            {
                for (int i = 0; i < width; ++i)
                {
                    string dirName = i == 0 ? dirPrefix : dirPrefix + "_" + i;
                    DirNode subDirNode = dirNode.GetDirNode(dirName);
                    if (subDirNode == null)
                    {
                        subDirNode = new DirNode(dirName);
                        dirNode.AddDirNode(subDirNode);
                    }

                    DMLibDataHelper.AddTree(subDirNode, dirPrefix, filePrefix, width, depth - 1, fileSizeInKB, fa, lmt: lmt);
                }
            }
        }

 public LoadFileConfiguration(string sourceFile, string targetFile,
     FileAttributes targetFileAttributes = FileAttributes.Normal)
 {
     SourceFile = sourceFile;
     TargetFile = targetFile;
     TargetFileAttributes = targetFileAttributes;
 }

        public DokanError CreateFile(string fileName, DokanNet.FileAccess access, FileShare share, FileMode mode, FileOptions options, FileAttributes attributes, DokanFileInfo info)
        {
            info.DeleteOnClose = (options & FileOptions.DeleteOnClose) != 0;
            //Console.WriteLine("CreateFile: {0}, mode = {1}", fileName, mode);

            if (fileName == "\\")
            {
                return DokanError.ErrorSuccess;
            }

            Directory dir = new Directory(Util.GetPathDirectory(fileName));
            if (!dir.Exists())
            {
                return DokanError.ErrorPathNotFound;
            }

            String name = Util.GetPathFileName(fileName);

            if (name.Length == 0)
            {
                return DokanError.ErrorInvalidName;
            }
            if (name.IndexOfAny(Path.GetInvalidFileNameChars()) > -1)
            {
                return DokanError.ErrorInvalidName;
            }

            // dokan API 要求在目标文件是目录时候，设置 info.IsDirectory = true
            if (dir.Contains(name) && (dir.GetItemInfo(name).attribute & FileAttributes.Directory) != 0)
            {
                info.IsDirectory = true;
                return DokanError.ErrorSuccess;
            }

            try
            {
                File f = new File(fileName, mode);
                f.flagDeleteOnClose = info.DeleteOnClose;
                info.Context = f;
            }
            catch (FileNotFoundException)
            {
                return DokanError.ErrorFileNotFound;
            }
            catch (IOException)
            {
                return DokanError.ErrorAlreadyExists;
            }
            catch (NotImplementedException)
            {
                return DokanError.ErrorAccessDenied;
            }
            catch (Exception)
            {
                return DokanError.ErrorError;
            }

            return DokanError.ErrorSuccess;
        }

 public void WindowsAttributeSetting(FileAttributes attr)
 {
     var path = GetTestFilePath();
     File.Create(path).Dispose();
     Set(path, attr);
     Assert.Equal(attr, Get(path));
     Set(path, 0);
 }

 public void WindowsAttributeSetting(FileAttributes attr)
 {
     var test = new DirectoryInfo(GetTestFilePath());
     test.Create();
     Set(test.FullName, attr);
     Assert.Equal(attr | FileAttributes.Directory, Get(test.FullName));
     Set(test.FullName, 0);
 }

 /// <summary>
 /// Attempts to clear the specified attribute(s) on the given path.
 /// </summary>
 public static void ClearAttributes(this IFileService fileService, string path, FileAttributes attributes)
 {
     FileAttributes currentAttributes = fileService.GetAttributes(path);
     if ((currentAttributes & attributes) != 0)
     {
         fileService.SetAttributes(path, currentAttributes &= ~attributes);
     }
 }

 public void NewItem(string folderName, string name, FileAttributes attrs)
 {
     ThrowIfDisposed();
     using (ComReleaser<IShellItem> folderItem = CreateShellItem(folderName))
     {
         _fileOperation.NewItem(folderItem.Item, attrs, name, string.Empty, _callbackSink);
     }
 }

 /// <summary>
 ///     Adds a file attribute
 /// </summary>
 /// <param name="pathInfo">Affected target</param>
 /// <param name="attribute">Attribute to add</param>
 /// <returns>true if added. false if already exists in attributes</returns>
 public static Boolean AddAttribute(PathInfo pathInfo, FileAttributes attribute)
 {
     if ((pathInfo.Attributes & attribute) == attribute) { return false; }
     var attributes = pathInfo.Attributes;
     attributes |= attribute;
     SetAttributes(pathInfo, attributes);
     return true;
 }