C#中文件安全管理需要注意的事项有哪些
这篇文章给大家分享的是有关C#中文件安全管理需要注意的事项有哪些的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。
一.DotNet文件目录常用操作：
提到文件的I/O操作，这个对于每一个开发者来说都不是陌生的事，因为这些操作是我们在项目开发过程中经常使用到的一些操作。那么在.NET中操作文件的类在System.IO命名空间下，一下介绍一下常见的I/O操作类：
DiveInfo：提供了对逻辑磁盘的基本信息访问的途径。（只能查看信息，不能做任何修改。）
System.Environment：用来枚举驱动器。（不能获取驱动器的属性）
System.Management：.NET针对WMI调用。
Directory和DircetoryInfo：用于操作目录。（前者为静态类，后者则须在实例化后调用，功能上相同）
File和FileInfo：用于操作文件。（前者为静态类，后者须实例化后调用，功能上相同）
以上介绍了一些文件的基本操作类，本次主要讲解目录和文件操作，一下给出文件和目录操作的一些基本方法：
1.文件常规操作：
(1).文件读写操作：
///<summary>
///写文件
///</summary>
///<paramname="fileName">文件名</param>
///<paramname="content">文件内容</param>
///<paramname="encoding">指定文件编码</param>
protectedvoidWrite_Txt(stringfileName,stringcontent,stringencoding)
{
if(string.IsNullOrEmpty(fileName))
{
thrownewArgumentNullException(fileName);
}
if(string.IsNullOrEmpty(content))
{
thrownewArgumentNullException(content);
}
if(string.IsNullOrEmpty(encoding))
{
thrownewArgumentNullException(encoding);
}
varcode=Encoding.GetEncoding(encoding);
varhtmlfilename=HttpContext.Current.Server.MapPath("Precious\\"+fileName+".txt");
varstr=content;
varsw=StreamWriter.Null;
try
{
using(sw=newStreamWriter(htmlfilename,false,code))
{
sw.Write(str);
sw.Flush();
}
}
catch(IOExceptionioex)
{
thrownewIOException(ioex.Message);
}
catch(Exceptionex)
{
thrownewException(ex.Message);
}
finally
{
sw.Close();
}
}
///<summary>
///读文件
///</summary>
///<paramname="filename">文件路径</param>
///<paramname="encoding">文件编码</param>
///<returns></returns>
protectedstringRead_Txt(stringfilename,stringencoding)
{
if(string.IsNullOrEmpty(filename))
{
thrownewArgumentNullException(filename);
}
if(string.IsNullOrEmpty(encoding))
{
thrownewArgumentNullException(encoding);
}
varcode=Encoding.GetEncoding(encoding);
vartemp=HttpContext.Current.Server.MapPath("Precious\\"+filename+".txt");
varstr=string.Empty;
if(!System.IO.File.Exists(temp))returnstr;
varsr=StreamReader.Null;
try
{
using(sr=newStreamReader(temp,code))
{
str=sr.ReadToEnd();
}
}
catch(IOExceptionioex)
{
thrownewIOException(ioex.Message);
}
catch(Exceptionex)
{
thrownewException(ex.Message);
}
finally
{
sr.Close();
}
returnstr;
}(2).文件附加操作：
///<summary>
///拷贝文件
///</summary>
///<paramname="orignFile">原始文件</param>
///<paramname="newFile">新文件路径</param>
publicstaticvoidFileCoppy(stringorignFile,stringnewFile)
{
if(string.IsNullOrEmpty(orignFile))
{
thrownewArgumentException(orignFile);
}
if(string.IsNullOrEmpty(newFile))
{
thrownewArgumentException(newFile);
}
System.IO.File.Copy(orignFile,newFile,true);
}
///<summary>
///删除文件
///</summary>
///<paramname="path">路径</param>
publicstaticvoidFileDel(stringpath)
{
if(string.IsNullOrEmpty(path))
{
thrownewArgumentException(path);
}
System.IO.File.Delete(path);
}
///<summary>
///移动文件
///</summary>
///<paramname="orignFile">原始路径</param>
///<paramname="newFile">新路径</param>
publicstaticvoidFileMove(stringorignFile,stringnewFile)
{
if(string.IsNullOrEmpty(orignFile))
{
thrownewArgumentException(orignFile);
}
if(string.IsNullOrEmpty(newFile))
{
thrownewArgumentException(newFile);
}
System.IO.File.Move(orignFile,newFile);
}2.目录常规操作：
///<summary>
///在当前目录下创建目录
///</summary>
///<paramname="orignFolder">当前目录</param>
///<paramname="newFloder">新目录</param>
publicstaticvoidFolderCreate(stringorignFolder,stringnewFloder)
{
if(string.IsNullOrEmpty(orignFolder))
{
thrownewArgumentException(orignFolder);
}
if(string.IsNullOrEmpty(newFloder))
{
thrownewArgumentException(newFloder);
}
Directory.SetCurrentDirectory(orignFolder);
Directory.CreateDirectory(newFloder);
}
///<summary>
///创建文件夹
///</summary>
///<paramname="path"></param>
publicstaticvoidFolderCreate(stringpath)
{
if(string.IsNullOrEmpty(path))
{
thrownewArgumentException(path);
}
if(!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
}
publicstaticvoidFileCreate(stringpath)
{
if(string.IsNullOrEmpty(path))
{
thrownewArgumentException(path);
}
varcreateFile=newFileInfo(path);
if(createFile.Exists)return;
varfs=createFile.Create();
fs.Close();
fs.Dispose();
}
///<summary>
///递归删除文件夹目录及文件
///</summary>
///<paramname="dir"></param>
///<returns></returns>
publicstaticvoidDeleteFolder(stringdir)
{
if(string.IsNullOrEmpty(dir))
{
thrownewArgumentException(dir);
}
if(!Directory.Exists(dir))return;
foreach(vardinDirectory.GetFileSystemEntries(dir))
{
if(System.IO.File.Exists(d))
{
//直接删除其中的文件
System.IO.File.Delete(d);
}
else
{
//递归删除子文件夹
DeleteFolder(d);
}
}
//删除已空文件夹
Directory.Delete(dir,true);
}
///<summary>
///指定文件夹下面的所有内容copy到目标文件夹下面
///</summary>
///<paramname="srcPath">原始路径</param>
///<paramname="aimPath">目标文件夹</param>
publicstaticvoidCopyDir(stringsrcPath,stringaimPath)
{
if(string.IsNullOrEmpty(srcPath))
{
thrownewArgumentNullException(srcPath);
}
if(string.IsNullOrEmpty(aimPath))
{
thrownewArgumentNullException(aimPath);
}
try
{
if(aimPath[aimPath.Length-1]!=Path.DirectorySeparatorChar)
{
aimPath+=Path.DirectorySeparatorChar;
}
if(!Directory.Exists(aimPath))
{
Directory.CreateDirectory(aimPath);
}
varfileList=Directory.GetFileSystemEntries(srcPath);
foreach(varfileinfileList)
{
if(Directory.Exists(file))
{
CopyDir(file,aimPath+Path.GetFileName(file));
}
else
{
System.IO.File.Copy(file,aimPath+Path.GetFileName(file),true);
}
}
}
catch(IOExceptionioex)
{
thrownewIOException(ioex.Message);
}
catch(Exceptionee)
{
thrownewException(ee.ToString());
}
}
///<summary>
///获取指定文件夹下所有子目录及文件
///</summary>
///<paramname="path">详细路径</param>
publicstaticstringGetFoldAll(stringpath)
{
if(string.IsNullOrEmpty(path))
{
thrownewArgumentNullException(path);
}
varstr=string.Empty;
varthisOne=newDirectoryInfo(path);
str=ListTreeShow(thisOne,0,str);
returnstr;
}
///<summary>
///获取指定文件夹下所有子目录及文件函数
///</summary>
///<paramname="theDir">指定目录</param>
///<paramname="nLevel">默认起始值,调用时,一般为0</param>
///<paramname="rn">用于迭加的传入值,一般为空</param>
///<returns></returns>
publicstaticstringListTreeShow(DirectoryInfotheDir,intnLevel,stringrn)
{
if(theDir==null)
{
thrownewArgumentNullException("theDir");
}
//获得目录
DirectoryInfo[]subDirectories=theDir.GetDirectories();
foreach(DirectoryInfodirinfoinsubDirectories)
{
if(nLevel==0)
{
rn+="├";
}
else
{
vars=string.Empty;
for(inti=1;i<=nLevel;i++)
{
s+="│ ";
}
rn+=s+"├";
}
rn+="<b>"+dirinfo.Name+"</b><br/>";
//目录下的文件
varfileInfo=dirinfo.GetFiles();
foreach(FileInfofInfoinfileInfo)
{
if(nLevel==0)
{
rn+="│ ├";
}
else
{
varf=string.Empty;
for(inti=1;i<=nLevel;i++)
{
f+="│ ";
}
rn+=f+"│ ├";
}
rn+=fInfo.Name.ToString()+"<br/>";
}
rn=ListTreeShow(dirinfo,nLevel+1,rn);
}
returnrn;
}
///<summary>
///获取指定文件夹下所有子目录及文件(下拉框形)
///</summary>
///<paramname="path">详细路径</param>
///<paramname="dropName">下拉列表名称</param>
///<paramname="tplPath">默认选择模板名称</param>
publicstaticstringGetFoldAll(stringpath,stringdropName,stringtplPath)
{
if(string.IsNullOrEmpty(path))
{
thrownewArgumentNullException(path);
}
if(string.IsNullOrEmpty(tplPath))
{
thrownewArgumentNullException(tplPath);
}
varstrDrop="<selectname=\""+dropName+"\"id=\""+dropName+"\"><optionvalue=\"\">--请选择详细模板--</option>";
varstr=string.Empty;
DirectoryInfothisOne=newDirectoryInfo(path);
str=ListTreeShow(thisOne,0,str,tplPath);
returnstrDrop+str+"</select>";
}
///<summary>
///获取指定文件夹下所有子目录及文件函数
///</summary>
///<paramname="theDir">指定目录</param>
///<paramname="nLevel">默认起始值,调用时,一般为0</param>
///<paramname="rn">用于迭加的传入值,一般为空</param>
///<paramname="tplPath">默认选择模板名称</param>
///<returns></returns>
publicstaticstringListTreeShow(DirectoryInfotheDir,intnLevel,stringrn,stringtplPath)
{
if(theDir==null)
{
thrownewArgumentNullException("theDir");
}
//获得目录
DirectoryInfo[]subDirectories=theDir.GetDirectories();
foreach(DirectoryInfodirinfoinsubDirectories)
{
rn+="<optionvalue=\""+dirinfo.Name+"\"";
if(string.Equals(tplPath,dirinfo.Name,StringComparison.CurrentCultureIgnoreCase))
{
rn+="selected";
}
rn+=">";
if(nLevel==0)
{
rn+="┣";
}
else
{
strings=string.Empty;
for(inti=1;i<=nLevel;i++)
{
s+="│ ";
}
rn+=s+"┣";
}
rn+=""+dirinfo.Name+"</option>";
//目录下的文件
FileInfo[]fileInfo=dirinfo.GetFiles();
foreach(FileInfofInfoinfileInfo)
{
rn+="<optionvalue=\""+dirinfo.Name+"/"+fInfo.Name+"\"";
if(string.Equals(tplPath,fInfo.Name,StringComparison.CurrentCultureIgnoreCase))
{
rn+="selected";
}
rn+=">";
if(nLevel==0)
{
rn+="│ ├";
}
else
{
stringf=string.Empty;
for(inti=1;i<=nLevel;i++)
{
f+="│ ";
}
rn+=f+"│ ├";
}
rn+=fInfo.Name+"</option>";
}
rn=ListTreeShow(dirinfo,nLevel+1,rn,tplPath);
}
returnrn;
}
///<summary>
///获取文件夹大小
///</summary>
///<paramname="dirPath">文件夹路径</param>
///<returns></returns>
publicstaticlongGetDirectoryLength(stringdirPath)
{
if(string.IsNullOrEmpty(dirPath))
{
thrownewArgumentNullException(dirPath);
}
if(!Directory.Exists(dirPath))
{
return0;
}
longlen=0;
DirectoryInfodi=newDirectoryInfo(dirPath);
foreach(FileInfofiindi.GetFiles())
{
len+=fi.Length;
}
DirectoryInfo[]dis=di.GetDirectories();
if(dis.Length>0)
{
for(inti=0;i<dis.Length;i++)
{
len+=GetDirectoryLength(dis[i].FullName);
}
}
returnlen;
}
///<summary>
///获取指定文件详细属性
///</summary>
///<paramname="filePath">文件详细路径</param>
///<returns></returns>
publicstaticstringGetFileAttibe(stringfilePath)
{
if(string.IsNullOrEmpty(filePath))
{
thrownewArgumentNullException(filePath);
}
varstr=string.Empty;
FileInfoobjFi=newFileInfo(filePath);
str+="详细路径:"+objFi.FullName+"<br>文件名称:"+objFi.Name+"<br>文件长度:"+objFi.Length+"字节<br>创建时间"+objFi.CreationTime.ToString()+"<br>最后访问时间:"+objFi.LastAccessTime.ToString()+"<br>修改时间:"+objFi.LastWriteTime.ToString()+"<br>所在目录:"+objFi.DirectoryName+"<br>扩展名:"+objFi.Extension;
returnstr;
}二.DotNet文件目录访问管理：
1.文件目录权限概述：
提到权限这个概念，这对于每一个开发者都是再熟悉不过的，因为我们在开发项目时，都会考虑用户权限管理等等，但是文件的权限操作呢？这里我们就简单的介绍一下.NET中对文件访问权限的访问和设置。文件权限中的访问控制列表： 自由访问控制列表（DACL）：Microsoft Windows NT和更高版本用于保护资源的机制；系统访问控制列表（SACL）：一种控制与资源关联的审核消息的机制。System.Security.AccessControl命名空间通过一些类提供对访问控制列表的访问。DiectorySecurity：该类指定目录的访问控制和审核安全。指定系统目录的访问权限以及访问尝试的审核方式。FileSecurity：该类指定系统文件的访问权限以及如何审核访问尝试。
下面介绍一下文件权限操作的类和方法：
(1).FileStream类GetAccessControl():检索文件的安全对象：
[SecuritySafeCritical]
publicFileSecurityGetAccessControl()
{
if(this._handle.IsClosed)
{
__Error.FileNotOpen();
}
returnnewFileSecurity(this._handle,this._fileName,AccessControlSections.Group|AccessControlSections.Owner|AccessControlSections.Access);
}[SecurityCritical,SecurityPermission(SecurityAction.Assert,UnmanagedCode=true)]
internalFileSecurity(SafeFileHandlehandle,stringfullPath,AccessControlSectionsincludeSections):base(false,handle,includeSections,false)
{
if(fullPath!=null)
{
newFileIOPermission(FileIOPermissionAccess.NoAccess,AccessControlActions.View,fullPath).Demand();
}
else
{
newFileIOPermission(PermissionState.Unrestricted).Demand();
}
}(2).FileStream类SetAccessControl()：保存设置。
[SecuritySafeCritical]
publicvoidSetAccessControl(FileSecurityfileSecurity)
{
if(fileSecurity==null)
{
thrownewArgumentNullException("fileSecurity");
}
if(this._handle.IsClosed)
{
__Error.FileNotOpen();
}
fileSecurity.Persist(this._handle,this._fileName);
}2.文件共享操作实例：
///<summary>
///共享文档操作
///</summary>
publicclassFileSharingOperationHelper
{
publicstaticboolConnectState(stringpath)
{
if(string.IsNullOrEmpty(path))
{
thrownewArgumentNullException(path);
}
returnConnectState(path,"","");
}
///<summary>
///连接远程共享文件夹
///</summary>
///<paramname="path">远程共享文件夹的路径</param>
///<paramname="userName">用户名</param>
///<paramname="passWord">密码</param>
///<returns></returns>
publicstaticboolConnectState(stringpath,stringuserName,stringpassWord)
{
varproc=newProcess();
try
{
proc.StartInfo.FileName="cmd.exe";
proc.StartInfo.UseShellExecute=false;
proc.StartInfo.RedirectStandardInput=true;
proc.StartInfo.RedirectStandardOutput=true;
proc.StartInfo.RedirectStandardError=true;
proc.StartInfo.CreateNoWindow=true;
proc.Start();
vardosLine="netuse"+path+""+passWord+"/user:"+userName;
proc.StandardInput.WriteLine(dosLine);
proc.StandardInput.WriteLine("exit");
while(!proc.HasExited)
{
proc.WaitForExit(1000);
}
varerrormsg=proc.StandardError.ReadToEnd();
proc.StandardError.Close();
if(!string.IsNullOrEmpty(errormsg))
{
thrownewException(errormsg);
}
}
catch(Exceptionex)
{
thrownewException(ex.Message);
}
finally
{
proc.Close();
proc.Dispose();
}
returntrue;
}
///<summary>
///向远程文件夹保存本地内容，或者从远程文件夹下载文件到本地
///</summary>
///<paramname="src">要保存的文件的路径，如果保存文件到共享文件夹，这个路径就是本地文件路径如：@"D:\1.avi"</param>
///<paramname="dst">保存文件的路径，不含名称及扩展名</param>
///<paramname="fileName">保存文件的名称以及扩展名</param>
publicstaticvoidTransport(stringsrc,stringdst,stringfileName)
{
if(string.IsNullOrEmpty(src))
{
thrownewArgumentNullException(src);
}
if(string.IsNullOrEmpty(dst))
{
thrownewArgumentNullException(dst);
}
if(string.IsNullOrEmpty(fileName))
{
thrownewArgumentNullException(fileName);
}
FileStreaminFileStream=null;
FileStreamoutFileStream=null;
try
{
inFileStream=newFileStream(src,FileMode.Open);
if(!Directory.Exists(dst))
{
Directory.CreateDirectory(dst);
}
dst=dst+fileName;
outFileStream=newFileStream(dst,FileMode.OpenOrCreate);
varbuf=newbyte[inFileStream.Length];
intbyteCount;
while((byteCount=inFileStream.Read(buf,0,buf.Length))>0)
{
outFileStream.Write(buf,0,byteCount);
}
}
catch(IOExceptionioex)
{
thrownewIOException(ioex.Message);
}
catch(Exceptionex)
{
thrownewException(ex.Message);
}
finally
{
if(inFileStream!=null)
{
inFileStream.Flush();
inFileStream.Close();
}
if(outFileStream!=null)
{
outFileStream.Flush();
outFileStream.Close();
}
}
}
}文件权限的规则：容器的访问规则可能被配置为不仅应用于对象本身，而且还应用于它的子对象、子容器或这两者。每个访问规则不是显示的就是继承的。DACL可以有对象的所有者任意修改，还可以由所有者已经给予其梗概DACL权限的任何更改。对象的安全描述包含另一个规则列表，称为系统访问权限列表（SACL），该列表将控制系统对对象执行哪个类型的审核。审核是一种具有安全敏感性的操作。在windows中，审核只能由本地安全机构（LSA）生成，LSA是唯一允许向安全事件日志中写入的组件。
三.DotNet彻底删除文件操作：
1.文件彻底删除概述：
看到文件删除，可能有人会问，前面不是已经介绍过文件的删除操作吗？为什么这里还需要详细的介绍。不错，上面的确介绍了文件和目录的删除方法，但是这里是介绍如何彻底的删除文件。我们常规的删除文件和文件格式化，一般是可以被恢复的。我们在操作删除的时候，只是将文件的索引给删除了，并没有删除实际的内容。文件的索引记录了文件在磁盘中的位置信息，当执行删除操作时，只是从文件分配聊表中删除了目录。
那么可能会有人问，怎么讲文件彻底的删除呢？文件的粉碎，其实就是在删除文件分配列表的同时，把文件在磁盘上占用的所有扇区数据置为0。
在.NET中提供了两种文件彻底的方法：
(1).调用系统API来完成这样的“粉碎”操作。
(2).在删除文件之前先删除文件的所有内容，然后在执行删除操作，被称为“假粉碎”。（此方法可以被人恢复文件，但是恢复的数据只是文件中的0）
为了文件安全，可以采用多轮粉碎的方式：第一轮，通过文件操作Windows API，找到原始文件的铭文在存储器上所载区域，逐字符逐位进行完全填充，全部填充为0。第二轮，通过磁盘操作WindowsAPI找到原始文件或目录在FAT表中的位置，将原始文件或目录在FAT表中项清零。第三轮，通过磁盘操作WindowsAPI，找到原始文件或目录在备份FAT表的位置，将原始文件或目录在备份FAT表中的表项清零。
2.文件彻底删除实例：
///<summary>
///粉碎文件操作
///</summary>
publicclassKillFileHelper
{
///<summary>
///强力粉碎文件，文件如果被打开，很难粉碎
///</summary>
///<paramname="filename">文件全路径</param>
///<paramname="deleteCount">删除次数</param>
///<paramname="randomData">随机数据填充文件，默认true</param>
///<paramname="blanks">空白填充文件，默认false</param>
///<returns>true：粉碎成功，false：粉碎失败</returns>
publicstaticboolKillFile(stringfilename,intdeleteCount,boolrandomData=true,boolblanks=false)
{
if(string.IsNullOrEmpty(filename))
{
thrownewArgumentNullException(filename);
}
constintbufferLength=1024000;
varret=true;
try
{
using(varstream=newFileStream(filename,FileMode.Open,FileAccess.ReadWrite,FileShare.ReadWrite))
{
varf=newFileInfo(filename);
varcount=f.Length;
longoffset=0;
varrowDataBuffer=newbyte[bufferLength];
while(count>=0)
{
variNumOfDataRead=stream.Read(rowDataBuffer,0,bufferLength);
if(iNumOfDataRead==0)
{
break;
}
if(randomData)
{
varrandombyte=newRandom();
randombyte.NextBytes(rowDataBuffer);
}
elseif(blanks)
{
for(vari=0;i<iNumOfDataRead;i++)
rowDataBuffer[i]=0;
}
else
{
for(vari=0;i<iNumOfDataRead;i++)
rowDataBuffer[i]=Convert.ToByte(Convert.ToChar(deleteCount));
}
//写新内容到文件。
for(vari=0;i<deleteCount;i++)
{
stream.Seek(offset,SeekOrigin.Begin);
stream.Write(rowDataBuffer,0,iNumOfDataRead);
}
offset+=iNumOfDataRead;
count-=iNumOfDataRead;
}
}
//每一个文件名字符代替随机数从0到9。
varnewName="";
do
{
varrandom=newRandom();
varcleanName=Path.GetFileName(filename);
vardirName=Path.GetDirectoryName(filename);
variMoreRandomLetters=random.Next(9);
//为了更安全，不要只使用原文件名的大小，添加一些随机字母。
for(vari=0;i<cleanName.Length+iMoreRandomLetters;i++)
{
newName+=random.Next(9).ToString();
}
newName=dirName+"\\"+newName;
}while(File.Exists(newName));
//重命名文件的新的随机的名字。
File.Move(filename,newName);
File.Delete(newName);
}
catch
{
//可能其他原因删除失败了，使用我们自己的方法强制删除
varmatchPattern=@"(?<=\s+pid:\s+)\b(\d+)\b(?=\s+)";
try
{
//要检查被那个进程占用的文件
varfileName=filename;
vartool=newProcess{StartInfo={FileName="handle.exe",Arguments=fileName+"/accepteula",UseShellExecute=false,RedirectStandardOutput=true}};
tool.Start();
tool.WaitForExit();
varoutputTool=tool.StandardOutput.ReadToEnd();
foreach(MatchmatchinRegex.Matches(outputTool,matchPattern))
{
//结束掉所有正在使用这个文件的程序
Process.GetProcessById(int.Parse(match.Value)).Kill();
}
File.Delete(fileName);
}
catch
{
ret=false;
}
}
returnret;
}
}四.DotNet文件加密解密操作：
上面介绍了文件的基本操作，文件权限操作，文件的删除操作，最后介绍一下文件的加密和解密操作。File和FileInfo类对文件加密进行了进一步的封装，提供了Encrypt和Decrypt方法用来对文件加密和解密。这两种方法要求文件系统必须为NFTS系统，对操作系统版本也要求必须是NT以上版本，使用该方法加密的文件，必须由同一用户才能进行解密。
具体看一下该方法的实现代码：
1.Encrypt():文件加密操作。
[SecuritySafeCritical]
publicstaticvoidEncrypt(stringpath)
{
if(path==null)
{
thrownewArgumentNullException("path");
}
stringfullPathInternal=Path.GetFullPathInternal(path);
newFileIOPermission(FileIOPermissionAccess.Write|FileIOPermissionAccess.Read,newstring[]{fullPathInternal},false,false).Demand();
if(!Win32Native.EncryptFile(fullPathInternal))
{
interrorCode=Marshal.GetLastWin32Error();
if(errorCode==5)
{
DriveInfoinfo=newDriveInfo(Path.GetPathRoot(fullPathInternal));
if(!string.Equals("NTFS",info.DriveFormat))
{
thrownewNotSupportedException(Environment.GetResourceString("NotSupported_EncryptionNeedsNTFS"));
}
}
__Error.WinIOError(errorCode,fullPathInternal);
}
}2.Decrypt():文件解密操作。
[SecuritySafeCritical]
publicstaticvoidDecrypt(stringpath)
{
if(path==null)
{
thrownewArgumentNullException("path");
}
stringfullPathInternal=Path.GetFullPathInternal(path);
newFileIOPermission(FileIOPermissionAccess.Write|FileIOPermissionAccess.Read,newstring[]{fullPathInternal},false,false).Demand();
if(!Win32Native.DecryptFile(fullPathInternal,0))
{
interrorCode=Marshal.GetLastWin32Error();
if(errorCode==5)
{
DriveInfoinfo=newDriveInfo(Path.GetPathRoot(fullPathInternal));
if(!string.Equals("NTFS",info.DriveFormat))
{
thrownewNotSupportedException(Environment.GetResourceString("NotSupported_EncryptionNeedsNTFS"));
}
}
__Error.WinIOError(errorCode,fullPathInternal);
}
}感谢各位的阅读！关于“C#中文件安全管理需要注意的事项有哪些”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，让大家可以学到更多知识，如果觉得文章不错，可以把它分享出去让更多的人看到吧！
目录
推荐阅读
0 条评论
本站已关闭游客评论，请登录或者注册后再评论吧~