using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
namespace Utility
{
/// <summary>
/// @Author:梁继龙
/// @Date：2012/8/1
/// @Email:jilongliang1988ora@163.com
/// @Description:文件处理类
/// </summary>
public class AccessDirFileHelper
{
public static AccessDirFileHelper instance = null;
private static readonly object lockObj = new object();
protected static System.Reflection.Assembly assembly = null; //反射
/// <summary>
/// 单例模式
/// </summary>
/// <returns></returns>
public static AccessDirFileHelper GetInstance()
{
//lock (AccessFileHelper.instance){ }
if (instance == null)
{
lock (lockObj)
{
instance = new AccessDirFileHelper();
}
}
return instance;
}
/// <summary>
/// 获取当前进程的完整路径，包含文件名(进程名)
/// result: X:\xxx\xxx\xxx.exe (.exe文件所在的目录+.exe文件名
/// </summary>
/// <returns></returns>
public string GetLocalProcessFileName()
{
try
{
return this.GetType().Assembly.Location;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 获取新的 Process 组件并将其与当前活动的进程关联的主模块的完整路径，包含文件名(进程名).
//result: X:\xxx\xxx\xxx.exe (.exe文件所在的目录+.exe文件名)
/// </summary>
/// <returns></returns>
public string GetCurrentProcessFileNamePath()
{
try
{
return System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 获取和设置当前目录（即该进程从中启动的目录）的完全限定路径.
/// result: X:\xxx\xxx (.exe文件所在的目录)
/// </summary>
/// <returns></returns>
public String GetCurrentEnvironmentDirectoryPath()
{
try
{
return System.Environment.CurrentDirectory;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 获取当前 Thread 的当前应用程序域的基目录，它由程序集冲突解决程序用来探测程序集。
///string str = System.AppDomain.CurrentDomain.BaseDirectory;
///result: X:\xxx\xxx\ (.exe文件所在的目录+"\")
///Example：用来判断winfrom会少一个Debug E:\\ASP.NET\\MyApp\\WebApp\\bin\\Debug\\bin\\Utility.dll" web
///Example：用来判断winfrom会多一个Debug E:\\ASP.NET\\MyApp\\WinApp\\bin\\Debug\\Utility.dll" winform
///此方法一般判断一个解决方案启动是web还是winform读取文件(dll，config,txt等..)看情况定
/// </summary>
public string GetCurrentDomainBaseDirectory()
{
try
{ //效果一样
//System.Threading.Thread.GetDomain().BaseDirectory
return System.AppDomain.CurrentDomain.BaseDirectory;
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// 获取和设置包含该应用程序的目录的名称。
///string str = System.AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
///result: X:\xxx\xxx\ (.exe文件所在的目录+"\")
/// </summary>
/// <returns></returns>
public string GetCurrentDomainSetupInformationName()
{
try
{
return System.AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 获取启动了应用程序的可执行文件的路径，不包括可执行文件的名称
/// string str = System.Windows.Forms.Application.StartupPath;
/// result: X:\xxx\xxx (.exe文件所在的目录)
/// </summary>
/// <returns></returns>
public string GetWindowsApplicationStartupPath()
{
try
{
return System.Windows.Forms.Application.StartupPath;
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
///获取启动了应用程序的可执行文件的路径，包括可执行文件的名称。
///string str = System.Windows.Forms.Application.ExecutablePath;
///result: X:\xxx\xxx\xxx.exe (.exe文件所在的目录+.exe文件名)
/// </summary>
/// <returns></returns>
public string GetWindowsExecutablePath()
{
try
{
return System.Windows.Forms.Application.ExecutablePath;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 获取应用程序的当前工作目录(不可靠)
/// /string str = System.IO.Directory.GetCurrentDirectory();
/// result: X:\xxx\xxx (.exe文件所在的目录)
/// </summary>
/// <returns></returns>
public string GetCurrentDirectory()
{
try
{
return System.IO.Directory.GetCurrentDirectory();
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 这个方法的意思是:在同一个解决方案里面有两个工程,启动的时候
/// 去判断哪个工程是Winform或者是Web的配置
///Example：E:\\ASP.NET\\MyApp\\WinApp\\bin\\Debug\\MyApp.vshost.exe.Config" //winform
///Example："E:\\ASP.NET\\MyApp\\WebApp\\web.config" //web
///从后面的配置截取Example:String index=Path3.Substring(config.Length - 8);截取
///后面字符串判去判断,最好把都转换成小写或者大写
///index.ToUpper()="E.CONFIG" / index.ToLower()=="e.config"
/// </summary>
/// <returns></returns>
public System.Reflection.Assembly GetCurrentDomainConfigurationFile(string executeWinformConfig, string executeWebConfig)
{
try
{
string config = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
string index = config.Substring(config.Length - 8);
if (index.ToLower() == "e.config") //把截取到的字符串转为为小写
{
assembly = System.Reflection.Assembly.LoadFile(executeWinformConfig); //加载dll文件
}
if (index.ToLower() == "b.config")
{
assembly = System.Reflection.Assembly.LoadFile(executeWebConfig); //加载dll文件
}
return assembly;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 无参数的GetCurrentDomainConfigurationFile方法
/// GetCurrentDomainConfigurationFile
/// </summary>
/// <returns></returns>
public string GetCurrentDomainConfigurationFile()
{
try
{
return AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Application.StartupPath与AppDomain.CurrentDomain.BaseDirectory都是判断
/// 当前启动的工程,并体现能找到
/// Example：E:\\ASP.NET\\MyApp\\MyApp\\bin\\Debug路径下面,唯有不同的就是
/// AppDomain.CurrentDomain.BaseDirectory多了个 \\
/// Application.StartupPath而且是System.Windows.Forms
/// </summary>
/// <returns></returns>
public string GetStartupPath()
{
try
{
return System.Windows.Forms.Application.StartupPath;
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// 获取文件的大小,一般指文件有多少个字节
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public string GetFileSize(string fileName)
{
try
{
if (File.Exists(fileName))
{
return Convert.ToString(new FileInfo(fileName).Length);
}
else
return fileName;
}
catch (Exception)
{
throw;
}
}
///<summary>
///在卸载程序获取系统安装的目录：
///System.Reflection.Assembly curPath = System.Reflection.Assembly.GetExecutingAssembly();
/// string path=curPath.Location;//得到安装程序类SetupLibrary文件的路径，获取这个文件路径
///所在的目录即得到安装程序的目录;
///</summary>
/// <returns></returns>
public String GetExecutingAssemblyDirectory()
{
try
{
System.Reflection.Assembly curPath = System.Reflection.Assembly.GetExecutingAssembly();
string path = curPath.Location;
return path;
}
catch (Exception ex)
{
throw ex;
}
}
#region
/// <summary>
/// 创建目录
/// </summary>
/// <param name="dir">此地路径相对站点而言</param>
public static void CreateDir(string dir)
{
if (dir.Length == 0) return;
if (!System.IO.Directory.Exists(System.Web.HttpContext.Current.Server.MapPath(dir)))
System.IO.Directory.CreateDirectory(System.Web.HttpContext.Current.Server.MapPath(dir));
}
/// <summary>
/// 创建目录路径
/// </summary>
/// <param name="folderPath">物理路径</param>
public static void CreateFolder(string folderPath)
{
if (!System.IO.Directory.Exists(folderPath))
System.IO.Directory.CreateDirectory(folderPath);
}
/// <summary>
/// 删除目录
/// </summary>
/// <param name="dir">此地路径相对站点而言</param>
public static void DeleteDir(string dir)
{
if (dir.Length == 0) return;
if (System.IO.Directory.Exists(System.Web.HttpContext.Current.Server.MapPath(dir)))
System.IO.Directory.Delete(System.Web.HttpContext.Current.Server.MapPath(dir), true);
}
/// <summary>
/// 判断文件是否存在
/// </summary>
/// <param name="file">格式:a/b.htm,相对根目录</param>
/// <returns></returns>
public static bool FileExists(string file)
{
if (File.Exists(System.Web.HttpContext.Current.Server.MapPath(file)))
return true;
else
return false;
}
/// <summary>
/// 读取文件内容
/// </summary>
/// <param name="file">格式:a/b.htm,相对根目录</param>
/// <returns></returns>
public static string ReadFile(string file)
{
if (!FileExists(file))
return "";
try
{
System.IO.StreamReader sr = new System.IO.StreamReader(System.Web.HttpContext.Current.Server.MapPath(file), System.Text.Encoding.UTF8);
string str = sr.ReadToEnd();
sr.Close();
return str;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 保存为不带Bom的文件
/// </summary>
/// <param name="TxtStr"></param>
/// <param name="tempDir">格式:a/b.htm,相对根目录</param>
public static void SaveFile(string TxtStr, string tempDir)
{
SaveFile(TxtStr, tempDir, true);
}
/// <summary>
/// 保存文件内容,自动创建目录
/// </summary>
/// <param name="TxtStr"></param>
/// <param name="tempDir">格式:a/b.htm,相对根目录</param>
/// <param name="noBom"></param>
public static void SaveFile(string TxtStr, string tempDir, bool noBom)
{
try
{
CreateDir(GetFolderPath(true, tempDir));
System.IO.StreamWriter sw;
if (noBom)
sw = new System.IO.StreamWriter(System.Web.HttpContext.Current.Server.MapPath(tempDir), false, new System.Text.UTF8Encoding(false));
else
sw = new System.IO.StreamWriter(System.Web.HttpContext.Current.Server.MapPath(tempDir), false, System.Text.Encoding.UTF8);
sw.Write(TxtStr);
sw.Close();
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 复制文件
/// 这个方法在6.0版本后改写，虽看似比前面的版本冗长，但避免了file2文件一直被占用的问题
/// </summary>
/// <param name="file1"></param>
/// <param name="file2"></param>
/// <param name="overwrite">如果已经存在是否覆盖？</param>
public static void CopyFile(string file1, string file2, bool overwrite)
{
if (System.IO.File.Exists(System.Web.HttpContext.Current.Server.MapPath(file1)))
{
if (overwrite)
System.IO.File.Copy(System.Web.HttpContext.Current.Server.MapPath(file1), System.Web.HttpContext.Current.Server.MapPath(file2), true);
else
{
if (!System.IO.File.Exists(System.Web.HttpContext.Current.Server.MapPath(file2)))
System.IO.File.Copy(System.Web.HttpContext.Current.Server.MapPath(file1), System.Web.HttpContext.Current.Server.MapPath(file2));
}
}
}
/// <summary>
/// 删除文件
/// </summary>
/// <param name="file">此地路径相对程序路径而言</param>
public static void DeleteFile(string file)
{
if (file.Length == 0) return;
if (System.IO.File.Exists(System.Web.HttpContext.Current.Server.MapPath(file)))
System.IO.File.Delete(System.Web.HttpContext.Current.Server.MapPath(file));
}
/// <summary>
/// 获得文件的目录路径
/// </summary>
/// <param name="filePath">文件路径</param>
/// <returns>以\结尾</returns>
public static string GetFolderPath(string filePath)
{
return GetFolderPath(false, filePath);
}
/// <summary>
/// 获得文件的目录路径
/// </summary>
/// <param name="isUrl">是否是网址</param>
/// <param name="filePath">文件路径</param>
/// <returns>以\或/结尾</returns>
public static string GetFolderPath(bool isUrl, string filePath)
{
if (isUrl)
return filePath.Substring(0, filePath.LastIndexOf("/") + 1);
else
return filePath.Substring(0, filePath.LastIndexOf("\\") + 1);
}
/// <summary>
/// 获得文件的名称
/// </summary>
/// <param name="filePath"></param>
/// <returns></returns>
public static string GetFileName(string filePath)
{
return GetFileName(false, filePath);
}
/// <summary>
/// 获得文件的名称
/// </summary>
/// <param name="isUrl">是否是网址</param>
/// <param name="filePath"></param>
/// <returns></returns>
public static string GetFileName(bool isUrl, string filePath)
{
if (isUrl)
return filePath.Substring(filePath.LastIndexOf("/") + 1, filePath.Length - filePath.LastIndexOf("/") - 1);
else
return filePath.Substring(filePath.LastIndexOf("\\") + 1, filePath.Length - filePath.LastIndexOf("\\") - 1);
}
/// <summary>
/// 获得文件的后缀
/// 不带点，小写
/// </summary>
/// <param name="filePath"></param>
/// <returns></returns>
public static string GetFileExt(string filePath)
{
return filePath.Substring(filePath.LastIndexOf(".") + 1, filePath.Length - filePath.LastIndexOf(".") - 1).ToLower();
}
/// <summary>
/// 目录拷贝
/// </summary>
/// <param name="OldDir"></param>
/// <param name="NewDir"></param>
public static void CopyDir(string OldDir, string NewDir)
{
DirectoryInfo OldDirectory = new DirectoryInfo(OldDir);
DirectoryInfo NewDirectory = new DirectoryInfo(NewDir);
CopyDir(OldDirectory, NewDirectory);
}
private static void CopyDir(DirectoryInfo OldDirectory, DirectoryInfo NewDirectory)
{
string NewDirectoryFullName = NewDirectory.FullName + "\\" + OldDirectory.Name;
if (!Directory.Exists(NewDirectoryFullName))
Directory.CreateDirectory(NewDirectoryFullName);
FileInfo[] OldFileAry = OldDirectory.GetFiles();
foreach (FileInfo aFile in OldFileAry)
File.Copy(aFile.FullName, NewDirectoryFullName + "\\" + aFile.Name, true);
DirectoryInfo[] OldDirectoryAry = OldDirectory.GetDirectories();
foreach (DirectoryInfo aOldDirectory in OldDirectoryAry)
{
DirectoryInfo aNewDirectory = new DirectoryInfo(NewDirectoryFullName);
CopyDir(aOldDirectory, aNewDirectory);
}
}
/// <summary>
/// 目录删除
/// </summary>
/// <param name="OldDir"></param>
public static void DelDir(string OldDir)
{
DirectoryInfo OldDirectory = new DirectoryInfo(OldDir);
OldDirectory.Delete(true);
}
/// <summary>
/// 目录剪切
/// </summary>
/// <param name="OldDirectory"></param>
/// <param name="NewDirectory"></param>
public static void CopyAndDelDir(string OldDirectory, string NewDirectory)
{
CopyDir(OldDirectory, NewDirectory);
DelDir(OldDirectory);
}
/// <summary>
/// 文件下载
/// </summary>
/// <param name="_Request"></param>
/// <param name="_Response"></param>
/// <param name="_fullPath">源文件路径</param>
/// <param name="_speed"></param>
/// <returns></returns>
public static bool DownloadFile(System.Web.HttpRequest _Request, System.Web.HttpResponse _Response, string _fullPath, long _speed)
{
string _fileName = GetFileName(false, _fullPath);
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;
double pack = 10240; //10K bytes
//int sleep = 200; //每秒5次 即5*10K bytes每秒
int sleep = (int)Math.Floor(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());
_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((fileLength - startBytes) / pack) + 1;
for (int i = 0; i < maxCount; i++)
{
if (_Response.IsClientConnected)
{
_Response.BinaryWrite(br.ReadBytes(int.Parse(pack.ToString())));
System.Threading.Thread.Sleep(sleep);
}
else
{
i = maxCount;
}
}
}
catch
{
return false;
}
finally
{
br.Close();
myFile.Close();
}
}
catch
{
return false;
}
return true;
}
#endregion
}
}
相关推荐
3. **整合到一个通用类**：将上述逻辑封装到一个类中，可以提供更方便的调用方式。这个类可能包含一个`UploadFiles`方法，接收页面控件集合和上传目录作为参数。 ```csharp public class FileUploader { public ...
本文将深入探讨如何使用C#来处理不同类型的文件路径，包括UNC（通用命名约定，用于网络共享）、本地文件以及HTTP URL的文件。 首先，让我们关注本地文件的读写。在C#中，可以使用`System.IO`命名空间中的`...
在这个例子中，我们创建了一个`FileStream`对象，指定文件路径和访问模式（读取）。然后，我们创建一个字节数组，其长度等于文件大小，并使用`Read`方法填充数组。最后，我们遍历数组并打印每个字节的值。 关于代码...
要使用 `FileInfo` 类，首先需要通过文件路径创建一个 `FileInfo` 对象，例如： ```csharp using System.IO; FileInfo fi = new FileInfo("yourFileName"); ``` 一旦创建了 `FileInfo` 对象，可以通过该对象访问...
例如，确保只有授权用户可以访问特定文件，限制大文件的下载以防止服务器负载过高，或者使用异步操作来提高用户体验。 总之，“C#实现文件下载”是一个涵盖多种技术的课题，包括HTTP协议的理解、C#的网络编程API...
File.Copy("本地文件路径", "\\\\另一台电脑的IP地址或主机名\\共享文件夹名\\新文件名", true); ``` 参数三是布尔值，表示是否覆盖已存在的文件。 6. **异常处理**：在进行网络文件操作时，可能会遇到各种异常，如...
- **FileStream**: C#中的`System.IO.FileStream`类是最基础的文件I/O流，它提供了对磁盘文件的低级访问。 - **Stream**: `Stream`是所有I/O操作的基础抽象类，包括`FileStream`、`MemoryStream`、`NetworkStream`...
"文件路径检查"这个主题主要关注如何在C#编程环境下处理和验证包含映射的网络路径，以及如何解决网络路径未启用的问题。下面将详细介绍相关知识点。 首先，让我们了解什么是网络路径。网络路径是计算机网络中用于...
此外，`FileStream`类提供了低级别的文件访问，可以用于更复杂的操作。 最后，**文件系统监视**可以使用`FileSystemWatcher`类，它能监听指定目录的文件系统更改事件，如文件创建、修改、删除等，这对于实时监控...
2. **配置IKVM**: 在C#项目中，设置IKVM的类路径，确保PDFBox库被正确加载。这通常通过在程序中动态加载IKVM和PDFBox库的Assembly完成。 3. **PDF文档的读取**：使用PDFBox提供的API，首先创建一个`PDFReader`对象...
- 这个方法找到文件的服务器路径，设置MIME类型为"application/octet-stream"，这是通用的二进制数据类型，然后返回一个FileResult，浏览器会自动触发文件下载。 3. 大文件上传： 对于大文件上传，常规方法可能会...
- 当涉及到多线程操作或并发访问文件系统时，还需要考虑同步和锁的问题，以防止数据不一致或竞态条件。 综上所述，C#提供了强大且灵活的API来处理文件系统和注册表，开发者可以根据具体需求选择最适合的方法和类。...
// 创建FileStream对象，指定文件路径、打开模式和访问权限 FileStream fs = new FileStream("c:\\tmp\\WriteFileStuff.txt", FileMode.OpenOrCreate, FileAccess.Write); // 使用FileStream创建StreamWriter...
创建FileStream对象时，需要指定文件的路径和访问模式（如只读、只写或读写）。例如： ```csharp using (FileStream fs = new FileStream("example.txt", FileMode.OpenOrCreate)) { // 文件操作代码 } ``` 这里，`...
2. **打开DBF文件**：使用选择的库，通过指定文件路径打开DBF文件，获取文件中的表头信息和数据行。 3. **读取数据**：遍历DBF文件的每一行，读取每个字段的值，可能需要进行数据类型转换。 4. **创建Excel工作簿*...
在后端开发中，T4模板常用于数据库实体类、数据访问层（DAL）、业务逻辑层（BLL）等的自动生成。例如，从数据库模式导出的EDMX文件可以与T4模板配合，自动生成Poco类，从而简化ORM操作。 六、T4模板的优势 1. 动态...
在C#中，`System.IO.File`类提供了静态方法用于文件的创建、删除、移动和打开，同时协助创建`FileStream`对象。`File`类是本章的核心，其方法如`Copy`、`Create`、`Delete`、`Exists`、`Move`和`Open`等。 **11.1.2...
C#是一种广泛用于Windows平台的编程语言，它提供了多种方式与各种数据库进行交互，其中OleDb（OLE DB）是一种常见的数据访问接口。本篇将深入探讨标题和描述中提及的"C#编写的OleDb数据库连接通用类库"。 首先，Ole...
在处理系统相关的任务时，有时我们需要获取映射的驱动器路径，例如网络驱动器，这些驱动器通常通过UNC路径（通用命名约定）与网络共享连接。下面将详细解释如何使用C#来实现这一功能。 首先，我们需要了解什么是...
在C#中，我们可以使用`System.Configuration`命名空间中的类来处理配置文件，如`ConfigurationManager`。配置文件通常以XML格式存储，用于存储应用的设置，如连接字符串、路径信息等。在本场景中，配置文件可能包含...