/// <summary>
/// 创建分层文件夹
/// </summary>
/// <param name="manyFolderType">创建文件夹类型</param>
/// <returns>已创建的文件夹名称</returns>
public static string GreatManyFolder(GreatFolderType manyFolderType)
{
string manyFolderName = "";
if (manyFolderType == GreatFolderType.No)
{
return manyFolderName;
}
DateTime dtnow = DateTime.Now;
switch (manyFolderType)
{
case GreatFolderType.Year:
manyFolderName = dtnow.Year.ToString() + "\\";
break;
case GreatFolderType.YearAndMonth:
manyFolderName = dtnow.Year.ToString() + dtnow.Month.ToString() + "\\";
break;
case GreatFolderType.YearUpMonth:
manyFolderName = dtnow.Year.ToString() + "\\" + dtnow.Month.ToString() + "\\";
break;
case GreatFolderType.YearUpMonthUpDay:
manyFolderName = dtnow.Year.ToString() + "\\" + dtnow.Month.ToString() + "\\" + dtnow.Day.ToString() + "\\";
break;
default:
manyFolderName = "";
break;
}
return manyFolderName;
}
/// <summary>
/// 检查文件夹是否存在,不存在就创建
/// </summary>
/// <param name="repath">绝对路径</param>
/// <returns>文件夹已存在或者创建成功返回TRUE</returns>
public static bool DriIsCreate(string repath)
{
if (!Directory.Exists(repath))
{
try
{
Directory.CreateDirectory(repath);
return true;
}
catch (Exception)
{
return false;
}
}
else
{
return true;
}
}
/// <summary>
/// 目录属性设置 返回True设置成功，否则设置失败
/// </summary>
/// <param name="path">文件路径，如：c:\tempuploads\NewDirectoty</param>
/// <param name="fileAttributes">System.IO.FileAttributes.后面的属性</param>
/// <returns>返回True设置成功，否则设置失败</returns>
public static bool SetDirectory(string path, FileAttributes fileAttributes)
{
DirectoryInfo NewDirInfo = new DirectoryInfo(@path);
try
{
NewDirInfo.Attributes = fileAttributes;
return true;
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// 删除一个目录Delete方法的第二个参数为bool类型，它可以决定是否删除非空目录。如果该参数值为true，将删除整个目录，即使该目录下有文件或子目录；若为false，则仅当目录为空时才可删除。
/// </summary>
/// <param name="path">目录名称@c:\tempuploads\BackUp</param>
/// <param name="recursive">True时，则移除path下的目录，子目录和文件</param>
/// <returns>返回True时删除在功，反之失败</returns>
private static bool DeleteDirectory(string path, bool recursive)
{
if (Directory.Exists(@path))
{
try
{
Directory.Delete(@path, true);
return true;
}
catch (Exception)
{
return false;
}
}
else
{
return false;
}
}
/// <summary>
/// 目录移动方法 返回True移动成功，False移动失败
/// </summary>
/// <param name="sourceDirName">要移动的文件或目录名称，如：c:\tempuploads\NewDirectory</param>
/// <param name="destDirName">目录的新路径，如：c:\tempuploads\BackUp</param>
/// <returns>返回True移动成功，False移动失败</returns>
public static bool MoveDirectory(string sourceDirName, string destDirName)
{
try
{
Directory.Move(@sourceDirName, @destDirName);
return true;
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// 获取当前目录下的所有子目录方法，返回所有子目录的数组
/// </summary>
/// <param name="path">目录路径，如：c:\tempuploads</param>
/// <returns>返回所有子目录的数组</returns>
public static string[] GetDirectories(string path)
{
string[] Directorys;
Directorys = Directory.GetDirectories(@path);
return Directorys;
}
/// <summary>
/// 获取当前目录下的所有文件方法
/// </summary>
/// <param name="path">目录路径如：c:\tempuploads</param>
/// <returns>返回所有文件名称的数组</returns>
public static string[] GetFile(string path)
{
string[] Files;
Files = Directory.GetFiles(@path);
return Files;
}
/// <summary>
/// 目录是否存在
/// </summary>
/// <param name="path">目录名称，如：c:\tempuploads\NewDirectory</param>
/// <returns>返回True存在，返回False不存在</returns>
public static bool DirectoriesExists(string path)
{
if (Directory.Exists(@path))
{
return true;
}
else
{
return false;
}
}
#endregion
#region 文件相关操作
/// <summary>
/// 删除文件
/// </summary>
/// <param name="repath">要删除的文件路径</param>
public static bool DelFile(string repath)
{
if (File.Exists(repath))
{
try
{
File.Delete(repath);
return true;
}
catch (Exception)
{
return false;
}
}
return false;
}
/// <summary>
/// 删除一些文件
/// </summary>
/// <param name="imgsrc">包含文件路径的数组</param>
public static void DelFiles(string[] imgsrc)
{
foreach (string str in imgsrc)
{
if (str != null && str.Trim() != "")
{
DelFile(str);
}
}
}
/// <summary>
/// 删除一些文件
/// </summary>
/// <param name="imgsrc">包含文件路径的数组</param>
/// <param name="realpath">文件真实路径前缀数组</param>
public static void DelFiles(string[] imgsrc, string realpath)
{
foreach (string str in imgsrc)
{
if (str != null && str.Trim() != "")
{
DelFile(realpath + str);
}
}
}
/// <summary>
/// 写文件
/// </summary>
/// <param name="Content">内容</param>
/// <param name="FileSavePath">路径</param>
/// <param name="code">编码</param>
/// <returns>是否成功</returns>
public static bool WriteFile(string Content, string FileSavePath, string code)
{
//if (System.IO.File.Exists(FileSavePath)) {
// try {
// System.IO.File.Delete(FileSavePath);
// } catch (Exception) {
// return false;
// }
//}
using (StreamWriter sw = new StreamWriter(FileSavePath, false, System.Text.Encoding.GetEncoding(code)))
{
try
{
sw.Write(Content);
sw.Flush();
return true;
}
catch (Exception)
{
return false;
}
finally
{
sw.Close();
}
}
}
/// <summary>
/// 读取文件
/// </summary>
/// <param name="FilePath"></param>
/// <returns></returns>
public string ReadFile(string FilePath)
{
System.IO.StreamReader rd = System.IO.File.OpenText(FilePath);
string StrRead = rd.ReadToEnd().ToString();
rd.Close();
return StrRead;
}
/// <summary>
/// 创建一个文件由于File.Create方法默认向所有用户授予对新文件的完全读/写访问权限，所以文件是用读/写访问权限打开的，必须关闭后才能由其他应用程序打开。为此，所以需要使用FileStream类的Close方法将所创建的文件关闭。 返回True创建成功，返回false创建失败
/// </summary>
/// <param name="FilePath">文件路径和文件名，如c:\tempuploads\newFile.txt</param>
/// <returns>返回True创建成功，返回false创建失败</returns>
public static bool CreateFile(string FilePath)
{
try
{
FileStream NewFile = File.Create(@FilePath);
NewFile.Close();
return true;
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// 文件的复制 由于Cope方法的OverWrite参数设为true，所以如果BackUp.txt文件已存在的话，将会被复制过去的文件所覆盖。
/// 返回True复制成功，返回Flase复制失败
/// </summary>
/// <param name="sourceFileName">要复制的源文件路径和文件名，如c:\tempuploads\newFile.txt</param>
/// <param name="destFileName">目标文件的路径和文件名，如：c:\tempuploads\BackUp.txt</param>
/// <param name="overwrite">如果可以改写文件，则为True，返则为False</param>
/// <returns>返回True复制成功，返回Flase复制失败</returns>
public static bool FileCopy(string sourceFileName, string destFileName, bool overwrite)
{
try
{
File.Copy(@sourceFileName, @destFileName, overwrite);
return true;
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// 文件移动方法 只能在同一个逻辑盘下进行文件转移。如果试图将c盘下的文件转移到d盘，将发生错误。
/// 返回True移动成功，返回False移动失败
/// </summary>
/// <param name="sourceFileName">要移动的文件名称，如：c:\tempuploads\BackUp.txt</param>
/// <param name="destFileName">文件的新路径，如：c:\BackUp.txt</param>
/// <returns>返回True移动成功，返回False移动失败</returns>
public static bool FileMove(string sourceFileName, string destFileName)
{
try
{
File.Move(@sourceFileName, @destFileName);
return true;
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// 设置文件属性 文件除了常用的只读和隐藏属性外，还有Archive(文件存档状态)，System(系统文件)，Temporary(临时文件)等。关于文件属性的详细情况请参看MSDN中FileAttributes的描述。
/// 返回True设置成功，否则失败
/// </summary>
/// <param name="FilePath">该文件的路径，如：c:\tempuploads\newFile.txt</param>
/// <param name="fileAttributes">所需的属性：如Hidden,ReadOnly,Normal,Archive</param>
/// <returns>返回True设置成功，否则失败</returns>
public static bool FileSetAttributes(string FilePath, FileAttributes fileAttributes)
{
try
{
File.SetAttributes(@FilePath, fileAttributes);
return true;
}
catch (Exception)
{
return false;
}
}
/// <summary>
/// 检查文件是否存在 返回True文件存在，返回Flase文件不存在
/// </summary>
/// <param name="path">文件路径和文件名，如：@"c:\tempuploads\newFile.txt</param>
/// <returns>返回True文件存在，返回Flase文件不存在</returns>
public static bool FileExists(string path)
{
if (File.Exists(@path))
{
return true;
}
else
{
return false;
}
}
#endregion 文件操作
#region 文件下载相关操作
/// <summary>
/// 带有下载提示的下载
/// </summary>
/// <param name="Response">Response对象</param>
/// <param name="FileName">要下载的文件</param>
public static void FileDownLoad(System.Web.HttpResponse Response, string FileName)
{
//打开要下载的文件
System.IO.FileStream r = new System.IO.FileStream(FileName, System.IO.FileMode.Open);
//设置基本信息
Response.Buffer = false;
Response.AddHeader("Connection", "Keep-Alive");
Response.ContentType = "application/octet-stream";
Response.AddHeader("Content-Disposition", "attachment;filename=" + System.IO.Path.GetFileName(FileName));
Response.AddHeader("Content-Length", r.Length.ToString());
while (true)
{
//开辟缓冲区空间
byte[] buffer = new byte[1024];
//读取文件的数据
int leng = r.Read(buffer, 0, 1024);
if (leng == 0)//到文件尾，结束
break;
if (leng == 1024)//读出的文件数据长度等于缓冲区长度，直接将缓冲区数据写入
Response.BinaryWrite(buffer);
else
{
//读出文件数据比缓冲区小，重新定义缓冲区大小，只用于读取文件的最后一个数据块
byte[] b = new byte[leng];
for (int i = 0; i < leng; i++)
b[i] = buffer[i];
Response.BinaryWrite(b);
}
}
r.Close();//关闭下载文件
Response.End();//结束文件下载
}
/// <summary>
/// 下载文件
/// </summary>
/// <param name="Response">Response对象</param>
/// <param name="Page">页面对象</param>
/// <param name="filename">文件物理地址</param>
public static void FileDownLoad(System.Web.HttpResponse Response, System.Web.UI.Page Page, string filename)
{
string saveFileName = "test.xls";
int intStart = filename.LastIndexOf("\\") + 1;
saveFileName = filename.Substring(intStart, filename.Length - intStart);
Response.Clear();
Response.Charset = "utf-8";
Response.Buffer = true;
Page.EnableViewState = false;
Response.ContentEncoding = System.Text.Encoding.UTF8;
Response.AppendHeader("Content-Disposition", "attachment;filename=" + saveFileName);
Response.WriteFile(filename);
Response.Flush();
Response.Close();
Response.End();
}
/// <summary>
/// 输出硬盘文件，提供下载 支持大文件、续传、速度限制、资源占用小
/// 输入参数 _Request: Page.Request对象， _Response: Page.Response对象， _fileName: 下载文件名， _fullPath: 带文件名下载路径， _speed 每秒允许下载的字节数
/// 返回是否成功
/// Page.Response.Clear();
/// bool success = ResponseFile(Page.Request, Page.Response, "filename", @"C:\download.date", 1024000);
/// if(!success) Response.Write("下载文件出错！");
/// Page.Response.End();
/// </summary>
/// <param name="_Request">Request对象</param>
/// <param name="_Response">Response对象</param>
/// <param name="_fileName">下载文件名</param>
/// <param name="_fullPath">带文件名下载路径</param>
/// <param name="_speed">每秒允许下载的字节数</param>
/// <returns>返回是否成功</returns>
public static bool FileDownLoad(System.Web.HttpRequest _Request, System.Web.HttpResponse _Response, string _fileName, string _fullPath, long _speed)
{
try
{
FileStream myFile = new FileStream(_fullPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
BinaryReader br = new BinaryReader(myFile);
try
{
_Response.AddHeader("Accept-Ranges", "bytes");
_Response.Buffer = false;
long fileLength = myFile.Length;
long startBytes = 0;
int pack = 10240; //10K bytes
//int sleep = 200; //每秒5次 即5*10K bytes每秒
int sleep = (int)Math.Floor(Convert.ToDouble(1000 * pack / _speed)) + 1;
if (_Request.Headers["Range"] != null)
{
_Response.StatusCode = 206;
string[] range = _Request.Headers["Range"].Split(new char[] { '=', '-' });
startBytes = Convert.ToInt64(range[1]);
}
_Response.AddHeader("Content-Length", (fileLength - startBytes).ToString());
if (startBytes != 0)
{
_Response.AddHeader("Content-Range", string.Format(" bytes {0}-{1}/{2}", startBytes, fileLength - 1, fileLength));
}
_Response.AddHeader("Connection", "Keep-Alive");
_Response.ContentType = "application/octet-stream";
_Response.AddHeader("Content-Disposition", "attachment;filename=" + System.Web.HttpUtility.UrlEncode(_fileName, System.Text.Encoding.UTF8));
br.BaseStream.Seek(startBytes, SeekOrigin.Begin);
int maxCount = (int)Math.Floor(Convert.ToDouble((fileLength - startBytes) / pack)) + 1;
for (int i = 0; i < maxCount; i++)
{
if (_Response.IsClientConnected)
{
_Response.BinaryWrite(br.ReadBytes(pack));
Thread.Sleep(sleep);
}
else
{
i = maxCount;
}
}
}
catch
{
return false;
}
finally
{
br.Close();
myFile.Close();
}
}
catch
{
return false;
}
return true;
}
#endregion
}
}