使用Ext实现网络硬盘

所谓“网络硬盘”，即将服务器的磁盘空间提供给用户使用，用户可以通过这种方式在互联网上实现文件的转移和备份。通过网络硬盘，不仅可以备份电脑系统文件，且可以轻松实现移动化办公，你可以随时随地进行个人文件的上传、下载、删除及文件目录的创建、删除等操作，还可以实现文件网络共享、网络文件快递、快速下载通道等。

选择使用Ext能轻易实现各种JS,AJAX功能。Ext与服务器交互主要是通过url,JSON。程序关键的代码是文件操作部分。

界面类似于电脑里的资源管理器，左侧为文件夹管理，右侧为文件夹下文件管理，支持右键菜单，计算剩余空间功能。

程序运行截图：

获取文件夹下的文件

DirectoryInfo TheFolder = new DirectoryInfo(Path);
foreach (FileInfo NextFile in TheFolder.GetFiles())
{
}
foreach (DirectoryInfo NextFile in TheFolder.GetDirectories())
{
}

格式文件大小

        public string formatBytes(long bytes)
        {
            if (bytes > 1073741824)
            {
                return String.Format("{0:f2}", ((double)bytes / 1073741824)) + " G";
            }
            if (bytes > 1048576)
            {
                return String.Format("{0:f2}", ((double)bytes / 1048576)) + " M";
            }
            if (bytes > 1024)
            {
                return String.Format("{0:f2}", ((double)bytes / 1024)) + " K";
            }
            return bytes.ToString() + " Bytes";
        }

得到路径下文件的大小

public static long GetDirectoryLength(string dirPath)
{
    //判断给定的路径是否存在,如果不存在则退出
    if (!Directory.Exists(dirPath))
        return 0;
    long len = 0;

    //定义一个DirectoryInfo对象
    DirectoryInfo di = new DirectoryInfo(dirPath);

    //通过GetFiles方法,获取di目录中的所有文件的大小
    foreach (FileInfo fi in di.GetFiles())
    {
        len += fi.Length;
    }

    //获取di中所有的文件夹,并存到一个新的对象数组中,以进行递归
    DirectoryInfo[] dis = di.GetDirectories();
    if (dis.Length > 0)
    {
        for (int i = 0; i < dis.Length; i++)
        {
            len += GetDirectoryLength(dis[i].FullName);
        }
    }
    return len;
}

删除文件夹 

public void DeleteFolder(string dir)
{
    if (Directory.Exists(dir)) //如果存在这个文件夹删除之    
    {
        foreach (string d in Directory.GetFileSystemEntries(dir))
        {
            if (File.Exists(d))
                File.Delete(d); //直接删除其中的文件                  
            else
                DeleteFolder(d); //递归删除子文件夹    
        }
        Directory.Delete(dir, true); //删除已空文件夹                 
    }
} 

复制文件夹

private void CopyFiles(string varFromDirectory, string varToDirectory)
{
    string DirectoryName = "";
    DirectoryName = varToDirectory;
    if (!Directory.Exists(varToDirectory))
        Directory.CreateDirectory(varToDirectory);

    if (!Directory.Exists(varFromDirectory))
        return;
    string[] directories = Directory.GetDirectories(varFromDirectory);
    if (directories.Length > 0)
    {
        foreach (string d in directories)
        {
            CopyFiles(d, varToDirectory + d.Substring(d.LastIndexOf("\\")));
        }
    }  //C#递归方法复制文件夹  
    string[] files = Directory.GetFiles(varFromDirectory); if (files.Length > 0)
    {
        foreach (string s in files)
        {
            File.Copy(s, varToDirectory + s.Substring(s.LastIndexOf("\\")), true);
        }
    }
}

得到新复制文件的名字

public string GetFileNewCopyName(string NewPath, string FileName)
{
    if (File.Exists(NewPath + @"\" + FileName))
    {
        string CopyFileName = NewPath + @"\复制 " + FileName;
        if (File.Exists(CopyFileName))
        {
            DirectoryInfo TheFolder = new DirectoryInfo(Path.GetDirectoryName(CopyFileName));
            int i = 1;
            foreach (FileInfo NextFile in TheFolder.GetFiles())
            {
                CopyFileName = NewPath + @"\复制 (" + i.ToString() + ") " + FileName;
                if (File.Exists(CopyFileName))
                    i++;
                else
                    break;
            }
        }
        return CopyFileName;
    }
    return NewPath + @"\" + FileName;
}

压缩和解压缩类

public class ZipClass
{
    public static bool Zip(String FileToZip, String ZipedFile, String Password)
    {
        if (Directory.Exists(FileToZip))
        {
            return ZipFileDictory(FileToZip, ZipedFile, Password);
        }
        else if (File.Exists(FileToZip))
        {
            return ZipFile(FileToZip, ZipedFile, Password);
        }
        else
        {
            return false;
        }
    }
    /// <summary>
    /// 递归压缩文件夹方法
    /// </summary>
    /// <param name="FolderToZip"></param>
    /// <param name="s"></param>
    /// <param name="ParentFolderName"></param>
    private static bool ZipFileDictory(string FolderToZip, ZipOutputStream s, string ParentFolderName)
    {
        bool res = true;
        string[] folders, filenames;
        ZipEntry entry = null;
        FileStream fs = null;
        Crc32 crc = new Crc32();
        try
        {
            //创建当前文件夹
            entry = new ZipEntry(Path.Combine(ParentFolderName, Path.GetFileName(FolderToZip) + "/"));  //加上 “/” 才会当成是文件夹创建
            s.PutNextEntry(entry);
            s.Flush();


            //先压缩文件，再递归压缩文件夹 
            filenames = Directory.GetFiles(FolderToZip);
            foreach (string file in filenames)
            {
                //打开压缩文件
                fs = File.OpenRead(file);

                byte[] buffer = new byte[fs.Length];
                fs.Read(buffer, 0, buffer.Length);
                entry = new ZipEntry(Path.Combine(ParentFolderName, Path.GetFileName(FolderToZip) + "/" + Path.GetFileName(file)));

                entry.DateTime = DateTime.Now;
                entry.Size = fs.Length;
                fs.Close();

                crc.Reset();
                crc.Update(buffer);

                entry.Crc = crc.Value;

                s.PutNextEntry(entry);

                s.Write(buffer, 0, buffer.Length);
            }
        }
        catch
        {
            res = false;
        }
        finally
        {
            if (fs != null)
            {
                fs.Close();
                fs = null;
            }
            if (entry != null)
            {
                entry = null;
            }
            GC.Collect();
            GC.Collect(1);
        }


        folders = Directory.GetDirectories(FolderToZip);
        foreach (string folder in folders)
        {
            if (!ZipFileDictory(folder, s, Path.Combine(ParentFolderName, Path.GetFileName(FolderToZip))))
            {
                return false;
            }
        }

        return res;
    }

    /**/
    /// <summary>
    /// 压缩目录
    /// </summary>
    /// <param name="FolderToZip">待压缩的文件夹，全路径格式</param>
    /// <param name="ZipedFile">压缩后的文件名，全路径格式</param>
    /// <returns></returns>
    private static bool ZipFileDictory(string FolderToZip, string ZipedFile, String Password)
    {
        bool res;
        if (!Directory.Exists(FolderToZip))
        {
            return false;
        }

        ZipOutputStream s = new ZipOutputStream(File.Create(ZipedFile));
        s.SetLevel(6);
        //s.Password = Password;

        res = ZipFileDictory(FolderToZip, s, "");

        s.Finish();
        s.Close();

        return res;
    }

    /**/
    /// <summary>
    /// 压缩文件
    /// </summary>
    /// <param name="FileToZip">要进行压缩的文件名</param>
    /// <param name="ZipedFile">压缩后生成的压缩文件名</param>
    /// <returns></returns>
    private static bool ZipFile(string FileToZip, string ZipedFile, String Password)
    {
        //如果文件没有找到，则报错
        if (!File.Exists(FileToZip))
        {
            throw new System.IO.FileNotFoundException("指定要压缩的文件: " + FileToZip + " 不存在!");
        }
        //FileStream fs = null;
        FileStream ZipFile = null;
        ZipOutputStream ZipStream = null;
        ZipEntry ZipEntry = null;

        bool res = true;
        try
        {
            ZipFile = File.OpenRead(FileToZip);
            byte[] buffer = new byte[ZipFile.Length];
            ZipFile.Read(buffer, 0, buffer.Length);
            ZipFile.Close();

            ZipFile = File.Create(ZipedFile);
            ZipStream = new ZipOutputStream(ZipFile);
            //ZipStream.Password = Password;
            ZipEntry = new ZipEntry(Path.GetFileName(FileToZip));
            ZipStream.PutNextEntry(ZipEntry);
            ZipStream.SetLevel(6);

            ZipStream.Write(buffer, 0, buffer.Length);
        }
        catch
        {
            res = false;
        }
        finally
        {
            if (ZipEntry != null)
            {
                ZipEntry = null;
            }
            if (ZipStream != null)
            {
                ZipStream.Finish();
                ZipStream.Close();
            }
            if (ZipFile != null)
            {
                ZipFile.Close();
                ZipFile = null;
            }
            GC.Collect();
            GC.Collect(1);
        }

        return res;
    }

    /**/
    /// <summary>
    /// 压缩文件 和 文件夹
    /// </summary>
    /// <param name="FileToZip">待压缩的文件或文件夹，全路径格式</param>
    /// <param name="ZipedFile">压缩后生成的压缩文件名，全路径格式</param>
    /// <returns></returns>
    
}

public class UnZipClass
{
    /**/
    /// <summary>
    /// 解压功能(解压压缩文件到指定目录)
    /// </summary>
    /// <param name="FileToUpZip">待解压的文件</param>
    /// <param name="ZipedFolder">指定解压目标目录</param>
    public static void UnZip(string FileToUpZip, string ZipedFolder, string Password)
    {
        if (!File.Exists(FileToUpZip))
        {
            return;
        }

        if (!Directory.Exists(ZipedFolder))
        {
            Directory.CreateDirectory(ZipedFolder);
        }

        ZipInputStream s = null;
        ZipEntry theEntry = null;

        string fileName;
        FileStream streamWriter = null;
        try
        {
            s = new ZipInputStream(File.OpenRead(FileToUpZip));
            //s.Password = Password;
            while ((theEntry = s.GetNextEntry()) != null)
            {
                if (theEntry.Name != String.Empty)
                {
                    fileName = Path.Combine(ZipedFolder, theEntry.Name);
                    /**/
                    ///判断文件路径是否是文件夹
                    if (fileName.EndsWith("/") || fileName.EndsWith("\\"))
                    {
                        Directory.CreateDirectory(fileName);
                        continue;
                    }

                    streamWriter = File.Create(fileName);
                    int size = 2048;
                    byte[] data = new byte[2048];
                    while (true)
                    {
                        size = s.Read(data, 0, data.Length);
                        if (size > 0)
                        {
                            streamWriter.Write(data, 0, size);
                        }
                        else
                        {
                            break;
                        }
                    }
                }
            }
        }
        finally
        {
            if (streamWriter != null)
            {
                streamWriter.Close();
                streamWriter = null;
            }
            if (theEntry != null)
            {
                theEntry = null;
            }
            if (s != null)
            {
                s.Close();
                s = null;
            }
            GC.Collect();
            GC.Collect(1);
        }
    }
}