delete, edit, copy, rename....in explorer.Help me!

cruxsel h15y ago

When I pasted your code I managed to solve some of the issues... But I would like to know how it can be customized and what are the references to be added to make it fully working on the client side..

Below are the specific errors, Kindly help me out with hints or specific answer for the below errors

HttpPostedFile pf = Request.Files.Item(0);
(Error 16 'System.Web.HttpFileCollection' does not contain a definition for 'Item' and no extension method 'Item' accepting a first argument of type 'System.Web.HttpFileCollection' could be found (are you missing a using directive or an assembly reference?))

if (!string.IsNullOrEmpty(_strAllowedPathPattern) && !Regex.IsMatch(WebPath, _strAllowedPathPattern))
(Error 17 The best overloaded method match for 'System.Text.RegularExpressions.Regex.IsMatch(string, string)' has some invalid arguments
)

WriteErrorRow(string.Format(strPathError, WebPath, "is not allowed because it does not match the pattern '" + Server.HtmlEncode(_strAllowedPathPattern) + "'."));

(Error 19 The best overloaded method match for 'string.Format(string, object, object)' has some invalid arguments
)

da = di.GetDirectories;
fa = di.GetFiles;

Error 24 Cannot convert method group 'GetDirectories' to non-delegate type 'System.IO.DirectoryInfo[]'. Did you intend to invoke the method? dr.Item("Name") = fi.Name;

Error 28 'System.Data.DataRow' does not contain a definition for 'Item' and no extension method 'Item' accepting a first argument of type 'System.Data.DataRow' could be found (are you missing a using directive or an assembly reference?)

return PageUrl(strUp);
Error 40 No overload for method 'PageUrl' takes '1' arguments

return System.Security.Principal.WindowsIdentity.GetCurrent.Name;
}
Error 79 'System.Security.Principal.WindowsIdentity.GetCurrent()' is a 'method', which is not valid in the given context

0

Roei Bar17y ago

didnt you say you want a Web based.....

0

get love17y ago

I'm doing windows forms application.My form has a treeview displays directory tree and a lisview display directories,files like explorer. I want to have buttons new folder,delete, edit, copy, cut, paste, rename file and diretory .This buttons will implement operation on listview.Please help me! Thanks a lot!

0

Kirtan Patel17y ago

Can you tell me More Specifically What you want as Final Result i could not understood your requirement

0

Roei Bar17y ago

here you go :-)

");
Response.Write("

 using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Configuration;

/// 
/// minimalist single-page class for performing server file management via the browser
/// 

public class _default : System.Web.UI.Page
{
    
    #region " Web Form Designer Generated Code "
    
    //This call is required by the Web Form Designer.
    [System.Diagnostics.DebuggerStepThrough()]
    private void InitializeComponent()
    {
        
    }
    
    //NOTE: The following placeholder declaration is required by the Web Form Designer.
    //Do not delete or move it.
    private System.Object designerPlaceholderDeclaration;
    
    private void  // ERROR: Handles clauses are not supported in C#
Page_Init(System.Object sender, System.EventArgs e)
    {
        //CODEGEN: This method call is required by the Web Form Designer
        //Do not modify it using the code editor.
        InitializeComponent();
    }
    
    #endregion
    
    private string _strImagePath;
    //-- path to GIF icon image files (absolute)
    private string _strHideFilePattern;
    //-- hide any files matching pattern
    private string _strHideFolderPattern;
    //-- hide any folders matching pattern
    private string _strAllowedPathPattern;
    //-- force user to stay on paths matching pattern
    private bool _blnFlushContent;
    //-- flush rows to the browser as they are written
    
    private const string _strIconSize = "height=16 width=16";
    private const string _strRenameTag = "_2_";
    private const string _strCheckboxTag = "checked_";
    private const string _strActionTag = "action";
    private const string _strWebPathTag = "path";
    private const string _strColSortTag = "sort";
    private const string _strTargetFolderTag = "targetfolder";
    
    private Exception _FileOperationException;
    
    /// 
    /// tag used to seperate old filename from new filename for renamed files
    /// 

    public string RenameTag {
        get { return _strRenameTag; }
    }
    
    /// 
    /// tag used to indicate the action field in the form
    /// 

    public string ActionTag {
        get { return _strActionTag; }
    }
    
    /// 
    /// tag used to indicate file checkboxes in the form
    /// 

    public string CheckboxTag {
        get { return _strCheckboxTag; }
    }
    
    /// 
    /// tag used to indicate the target folder field in the form
    /// 

    public string TargetFolderTag {
        get { return _strTargetFolderTag; }
    }
    
    /// 
    /// returns the current web path being browsed
    /// 

    public string CurrentWebPath {
        get { return WebPath(); }
    }
    
    /// 
    /// returns the current script filename (.aspx)
    /// 

    public string ScriptName {
        get { return Request.ServerVariables("script_name"); }
    }
    
    /// 
    /// This event fires when the page is being loaded
    /// 

    private void Page_Load(System.Object sender, System.EventArgs e)
    {
        //-- get .config settings
        _strHideFolderPattern = GetConfigString("HideFolderPattern");
        _strHideFilePattern = GetConfigString("HideFilePattern");
        _strAllowedPathPattern = GetConfigString("AllowedPathPattern");
        _strImagePath = GetConfigString("ImagePath", "images/");
        _blnFlushContent = (!string.IsNullOrEmpty(GetConfigString("FlushContent")));
    }
    
    /// 
    /// Retrieve a value from the .config file appSettings
    /// 

    private string GetConfigString(string strKey, string strDefaultValue)
    {
        strKey = "WebFileManager/" + strKey;
        if (ConfigurationSettings.AppSettings(strKey) == null) {
            return strDefaultValue;
        }
        else {
            return Convert.ToString(ConfigurationSettings.AppSettings(strKey));
        }
    }
    
    /// 
    /// performs the user action indicated in the hidden Action form field
    /// 

    public void HandleAction()
    {
        if (Request.Form(_strActionTag) == null) return; 
        
        string strAction = Request.Form(_strActionTag).ToLower;
        if (string.IsNullOrEmpty(strAction)) return; 
        
        switch (strAction) {
            case "newfolder":
                MakeFolder(GetTargetPath);
                break;
            case "upload":
                SaveUploadedFile();
                break;
            default:
                ProcessCheckedFiles(strAction);
                break;
        }
        if ((_FileOperationException != null)) {
            WriteError(_FileOperationException);
        }
    }
    
    /// 
    /// performs the specified action on all checked files
    /// 

    private void ProcessCheckedFiles(string strAction)
    {
        int intLoc = 0;
        string strName = null;
        int intTagLength = _strCheckboxTag.Length;
        ArrayList FileList = new ArrayList();
        
        foreach (string strItem in Request.Form) {
            intLoc = strItem.IndexOf(_strCheckboxTag);
            if (intLoc > -1) {
                _FileOperationException = null;
                strName = strItem.Substring(intLoc + intTagLength);
                FileList.Add(strName);
                switch (strAction) {
                    case "delete":
                        DeleteFileOrFolder(strName);
                        break;
                    case "move":
                        MakeFolder(GetTargetPath);
                        MoveFileOrFolder(strName);
                        break;
                    case "copy":
                        MakeFolder(GetTargetPath);
                        CopyFileOrFolder(strName);
                        break;
                    case "rename":
                        RenameFileOrFolder(strName);
                        break;
                }
            }
        }
        
        //-- certain operations must work on all the selected files/folders at once.
        if (strAction == "zip") {
            ZipFileOrFolder(FileList);
        }
    }
    
    /// 
    /// Saves the first HttpPostedFile (if there is one) to the current folder
    /// 

    private void SaveUploadedFile()
    {
        if (Request.Files.Count > 0) {
            HttpPostedFile pf = Request.Files.Item(0);
            if (pf.ContentLength > 0) {
                string strFilename = pf.FileName;
                string strTargetFile = GetLocalPath(Path.GetFileName(strFilename));
                //-- make sure we clear out any existing file before uploading
                if (File.Exists(strTargetFile)) {
                    DeleteFileOrFolder(strFilename);
                }
                try {
                    pf.SaveAs(strTargetFile);
                }
                catch (Exception ex) {
                    _FileOperationException = ex;
                }
            }
        }
    }
    
    
    /// 
    /// writes complete table to page, including header, body, and footer
    /// 

    public void WriteTable()
    {
        int intRowsRendered = 0;
        {
            //-- header table
            Response.Write("");
            Response.Write("");
            Response.Write("");
            Response.Write(" ");
            Response.Write("");
            Response.Write("");
            Response.Write(" ");
            Response.Write(UpUrl);
            Response.Write(" Move up a folder");
            Response.Write(" Scroll to Bottom");
            Response.Write("
");
            Response.Write(Environment.NewLine);
            Flush();
            
            //-- body table
            Response.Write("");
            Response.Write("");
            Response.Write("");
            Response.Write(" ");
            Response.Write(" " + PageUrl("", "Name") + "File Name");
            Response.Write(" " + PageUrl("", "Size") + "Size");
            Response.Write(" ");
            Response.Write(" " + PageUrl("", "Created") + "Created");
            Response.Write(" " + PageUrl("", "Modified") + "Modified");
            Response.Write(" " + PageUrl("", "Attr") + "Attr");
            Response.Write(Environment.NewLine);
            Flush();
            
            //-- render body table rows for folders and files
            intRowsRendered = WriteRows();
            
            Response.Write("
");
            Flush();
            
            //-- footer table
            if (intRowsRendered < 0) return; 
            
            Response.Write("");
            Response.Write("");
            Response.Write("");
            Response.Write("");
            Response.Write("");
            Response.Write("");
            Response.Write(" ");
            Response.Write("  ");
            
            Response.Write("");
            Response.Write("");
            Response.Write("");
            Response.Write("");
            Response.Write("");
            Response.Write("");
            Response.Write(" New folder");
            Response.Write(" ");
            Response.Write("");
            Response.Write(" Copy to folder");
            Response.Write(" ");
            Response.Write("");
            Response.Write(" Move to folder");
            Response.Write(" ");
            Response.Write("
");
            Response.Write("");
            Response.Write(" Upload a file");
            Response.Write(" ");
            Response.Write("");
            Response.Write(" Delete");
            Response.Write(" ");
            Response.Write("");
            Response.Write(" Rename");
            Response.Write(" ");
            Response.Write("");
            Response.Write("");
            Response.Write(" Zip");
            Response.Write("
");
            
            Response.Write("
");
            Response.Write("");
            Response.Write(" ");
            Response.Write(" ");
            Response.Write("
");
        }
        Flush();
    }
    
    /// 
    /// Gets all files and folders for the current path, and writes rows for each one
    /// 

    private int WriteRows()
    {
        const string strPathError = "The path '{0}' {1} Go back";
        
        //-- make sure we're allowed to look at this web path
        if (!string.IsNullOrEmpty(_strAllowedPathPattern) && !Regex.IsMatch(WebPath, _strAllowedPathPattern)) {
            WriteErrorRow(string.Format(strPathError, WebPath, "is not allowed because it does not match the pattern '" + Server.HtmlEncode(_strAllowedPathPattern) + "'."));
            return -1;
        }
        
        //-- make sure this directory exists on the server
        string strLocalPath = GetLocalPath();
        if (!Directory.Exists(strLocalPath)) {
            WriteErrorRow(string.Format(strPathError, WebPath, "does not exist."));
            return -1;
        }
        
        //-- make sure we can get the files and directories for this directory
        DirectoryInfo[] da = null;
        FileInfo[] fa = null;
        try {
            DirectoryInfo di = new DirectoryInfo(strLocalPath);
            da = di.GetDirectories;
            fa = di.GetFiles;
        }
        catch (Exception ex) {
            WriteErrorRow(ex);
            return -1;
        }
        
        //-- add all file/directory info to intermediate DataTable
        DataTable dt = GetFileInfoTable();
        dt.BeginLoadData();
        foreach (DirectoryInfo d in da) {
            AddRowToFileInfoTable(d, dt);
        }
        foreach (FileInfo f in fa) {
            AddRowToFileInfoTable(f, dt);
        }
        dt.EndLoadData();
        dt.AcceptChanges();
        
        if (dt.Rows.Count == 0) {
            WriteErrorRow("(no files)");
            return 0;
        }
        
        //-- sort and render intermediate DataView from our DataTable
        DataView dv = default(DataView);
        if (string.IsNullOrEmpty(SortColumn())) {
            dv = dt.DefaultView;
        }
        else {
            dv = new DataView(dt);
            if (SortColumn.StartsWith("-")) {
                dv.Sort = "IsFolder, " + SortColumn().Substring(1) + " desc";
            }
            else {
                dv.Sort = "IsFolder desc, " + SortColumn();
            }
        }
        
        int intRenderedRows = 0;
        foreach (DataRowView drv in dv) {
            if (WriteViewRow(drv)) intRenderedRows += 1; 
        }
        
        return intRenderedRows;
    }
    
    /// 
    /// returns intermediate DataTable of File/Directory info 
    /// to be used for sorting prior to display
    /// 

    private DataTable GetFileInfoTable()
    {
        DataTable dt = new DataTable();
        {
            dt.Columns.Add(new DataColumn("Name", typeof(System.String)));
            dt.Columns.Add(new DataColumn("IsFolder", typeof(System.Boolean)));
            dt.Columns.Add(new DataColumn("FileExtension", typeof(System.String)));
            dt.Columns.Add(new DataColumn("Attr", typeof(System.String)));
            dt.Columns.Add(new DataColumn("Size", typeof(System.Int64)));
            dt.Columns.Add(new DataColumn("Modified", typeof(System.DateTime)));
            dt.Columns.Add(new DataColumn("Created", typeof(System.DateTime)));
        }
        return dt;
    }
    
    /// 
    /// translates a FileSystemInfo entry to a DataRow in our intermediate DataTable
    /// 

    private void AddRowToFileInfoTable(FileSystemInfo fi, DataTable dt)
    {
        DataRow dr = dt.NewRow;
        string Attr = AttribString(fi.Attributes);
        {
            dr.Item("Name") = fi.Name;
            dr.Item("FileExtension") = Path.GetExtension(fi.Name);
            dr.Item("Attr") = Attr;
            if (Attr.IndexOf("d") > -1) {
                dr.Item("IsFolder") = true;
                dr.Item("Size") = 0;
            }
            else {
                dr.Item("IsFolder") = false;
                dr.Item("Size") = new FileInfo(fi.FullName).Length;
            }
            dr.Item("Modified") = fi.LastWriteTime;
            dr.Item("Created") = fi.CreationTime;
        }
        dt.Rows.Add(dr);
    }
    
    
    /// 
    /// Returns the specified sort column, if any, provided in the URL querystring
    /// 

    private string SortColumn()
    {
        if (Request.QueryString(_strColSortTag) == null) {
            return "Name";
        }
        else {
            return Request.QueryString(_strColSortTag);
        }
    }
    
    /// 
    /// Returns the current URL path we're browsing at the moment
    /// 

    private string WebPath()
    {
        string strPath = Request.Item(_strWebPathTag);
        if (strPath == null || string.IsNullOrEmpty(strPath)) {
            strPath = GetConfigString("DefaultPath", "~/");
        }
        return strPath;
    }
    
    /// 
    /// Returns the URL for one level "up" from our current WebPath()
    /// 

    private string UpUrl()
    {
        string strUp = Regex.Replace(WebPath(), "/[^/]+$", "");
        if (string.IsNullOrEmpty(strUp) | strUp == "/") {
            strUp = GetConfigString("DefaultPath", "~/");
        }
        return PageUrl(strUp);
    }
    
    /// 
    /// return partial URL to this page, optionally specifying a new target path
    /// 

    private string PageUrl(string NewPath, 
string NewSortColumn)
    {
        
        bool blnSortProvided = (!string.IsNullOrEmpty(NewSortColumn));
        
        //-- if not provided, use the current values in the querystring
        if (string.IsNullOrEmpty(NewPath)) NewPath = WebPath(); 
        if (string.IsNullOrEmpty(NewSortColumn)) NewSortColumn = SortColumn(); 
        
        System.Text.StringBuilder sb = new System.Text.StringBuilder();
        {
            sb.Append("            sb.Append(ScriptName);
            sb.Append("?");
            sb.Append(_strWebPathTag);
            sb.Append("=");
            sb.Append(NewPath);
            if (!string.IsNullOrEmpty(NewSortColumn)) {
                sb.Append("&");
                sb.Append(_strColSortTag);
                sb.Append("=");
                if (blnSortProvided & (NewSortColumn.ToLower == SortColumn().ToLower)) {
                    sb.Append("-");
                }
                sb.Append(NewSortColumn);
            }
            sb.Append("\">");
        }
        
        return sb.ToString;
    }
    
    /// 
    /// given file object, return formatted KB size in text
    /// 

    private string FormatKB(long FileLength)
    {
        return string.Format("{0:N0}", (FileLength / 1024));
    }
    
    /// 
    /// turn numeric attribute into standard "RHSDAC" text
    /// 

    private string AttribString(IO.FileAttributes a)
    {
        StringBuilder sb = new StringBuilder();
        if ((a & FileAttributes.ReadOnly) > 0) sb.Append("r"); 
        if ((a & FileAttributes.Hidden) > 0) sb.Append("h"); 
        if ((a & FileAttributes.System) > 0) sb.Append("s"); 
        if ((a & FileAttributes.Directory) > 0) sb.Append("d"); 
        if ((a & FileAttributes.Archive) > 0) sb.Append("a"); 
        if ((a & FileAttributes.Compressed) > 0) sb.Append("c"); 
        return sb.ToString;
    }
    
    /// 
    /// path.combine works great, but is filesystem-centric; we just convert the slashes
    /// 

    private string WebPathCombine(string path1, string path2)
    {
        string strTemp = Path.Combine(path1, path2).Replace("\\", "/");
        if (strTemp.IndexOf("~/") > -1) {
            strTemp = strTemp.Replace("~/", Page.ResolveUrl("~/"));
        }
        return strTemp;
    }
    
    /// 
    /// given filename, return URL to icon image for that filetype
    /// 

    private string FileIconLookup(DataRowView drv)
    {
        
        if (IsDirectory(drv)) {
            return WebPathCombine(_strImagePath, "file/folder.gif");
        }
        
        switch (Convert.ToString(drv.Item("FileExtension"))) {
            case ".gif":
            case ".peg":
            case ".jpe":
            case ".jpg":
            case ".png":
                return WebPathCombine(WebPath, Convert.ToString(drv.Item("Name")));
            //Return "file_image.gif"
            case ".txt":
                return WebPathCombine(_strImagePath, "file/text.gif");
            case ".htm":
            case ".xml":
            case ".xsl":
            case ".css":
            case ".html":
            case ".config":
                return WebPathCombine(_strImagePath, "file/html.gif");
            case ".mp3":
            case ".wav":
            case ".wma":
            case ".au":
            case ".mid":
            case ".ram":
            case ".rm":
            case ".snd":
            case ".asf":
                return WebPathCombine(_strImagePath, "file/audio.gif");
            case ".zip":
            case "tar":
            case ".gz":
            case ".rar":
            case ".cab":
            case ".tgz":
                return WebPathCombine(_strImagePath, "file/compressed.gif");
            case ".asp":
            case ".wsh":
            case ".js":
            case ".vbs":
            case ".aspx":
            case ".cs":
            case ".vb":
                return WebPathCombine(_strImagePath, "file/script.gif");
            default:
                return WebPathCombine(_strImagePath, "file/generic.gif");
        }
    }
    
    /// 
    /// writes a table row containing information about the file or folder
    /// 

    private bool WriteViewRow(DataRowView drv)
    {
        string strFileLink = null;
        string strFileName = Convert.ToString(drv.Item("Name"));
        string strFilePath = WebPathCombine(WebPath, strFileName);
        bool blnFolder = IsDirectory(drv);
        
        if (blnFolder) {
            if (!string.IsNullOrEmpty(_strHideFolderPattern) && Regex.IsMatch(strFileName, _strHideFolderPattern, RegexOptions.IgnoreCase)) {
                return false;
            }
            strFileLink = PageUrl(strFilePath) + strFileName + "";
        }
        else {
            if (!string.IsNullOrEmpty(_strHideFilePattern) && Regex.IsMatch(strFileName, _strHideFilePattern, RegexOptions.IgnoreCase)) {
                return false;
            }
            strFileLink = "" + strFileName + "";
        }
        
        {
            Response.Write("

Response.Write(_strCheckboxTag);
Response.Write(strFileName);
Response.Write("\" type=checkbox>");
Response.Write("

Response.Write(FileIconLookup(drv));
Response.Write("\" ");
Response.Write(_strIconSize);
Response.Write(">");
Response.Write("

");
Response.Write(strFileLink);
Response.Write("

");
if (blnFolder) {
Response.Write("

");
}
else {
Response.Write(FormatKB(Convert.ToInt64(drv.Item("Size"))));
Response.Write("

kb");
}
Response.Write("

");
Response.Write(Convert.ToString(drv.Item("Created")));
Response.Write("

");
Response.Write(Convert.ToString(drv.Item("Modified")));
Response.Write("

");
Response.Write(Convert.ToString(drv.Item("Attr")));
Response.Write(Environment.NewLine);
}
Flush();

return true;
}

///

/// optionally dumps the current response buffer to the client as it is being rendered.
/// This is faster, but it can cause problems with some HTTP filters
/// so it is off by default.
///

private void Flush()
{
if (_blnFlushContent) Response.Flush();
}

///

/// maps the current web path to a server filesystem path
///

private string GetLocalPath(string strFilename)
{
return Path.Combine(Server.MapPath(WebPath), strFilename);
}

///

/// converts a filesystem path to a relative path based on our current
/// file browsing path, WITHOUT a leading slash
///

private string MakeRelativePath(string strFilename)
{
string strRelativePath = strFilename.Replace(Server.MapPath(WebPath), "");
if (strRelativePath.StartsWith("\\")) {
return strRelativePath.Substring(1);
}
else {
return strRelativePath;
}
}

///

/// maps the current web path, plus target folder, to a server filesystem path
///

private string GetTargetPath(string strFilename)
{
return Path.Combine(Path.Combine(GetLocalPath, Request.Form(_strTargetFolderTag)), strFilename);
}

///

/// returns True if the provided path is an existing directory
///

private bool IsDirectory(string strFilepath)
{
return Directory.Exists(strFilepath);
}

///

/// Returns true if this DataRowView represents a directory/folder
///

private bool IsDirectory(DataRowView drv)
{
return Convert.ToString(drv.Item("attr")).IndexOf("d") > -1;
}

///

/// deletes a file or folder
///

private void DeleteFileOrFolder(string strName)
{
string strLocalPath = GetLocalPath(strName);
try {
RemoveReadOnly(strLocalPath);
if (IsDirectory(strLocalPath)) {
Directory.Delete(strLocalPath, true);
}
else {
File.Delete(strLocalPath);
}
}
catch (Exception ex) {
_FileOperationException = ex;
}
}

///

/// moves a file from the current folder to the target folder
///

private void MoveFileOrFolder(string strName)
{
string strLocalPath = GetLocalPath(strName);
string strTargetPath = GetTargetPath(strName);
try {
if (IsDirectory(strLocalPath)) {
Directory.Move(strLocalPath, strTargetPath);
}
else {
File.Move(strLocalPath, strTargetPath);
}
}
catch (Exception ex) {
_FileOperationException = ex;
}
}

///

/// moves a file from the current folder to the target folder
///

private void CopyFileOrFolder(string strName)
{
string strLocalPath = GetLocalPath(strName);
string strTargetPath = GetTargetPath(strName);

try {
if (IsDirectory(strLocalPath)) {
CopyFolder(strLocalPath, strTargetPath, true);
}
else {
File.Copy(strLocalPath, strTargetPath);
}
}
catch (Exception ex) {
_FileOperationException = ex;
}
}

///

/// Compress all the selected files
/// due to limitations of SharpZipLib, this must be done in one pass
/// (it cannot modify an existing zip file!)
///

private void ZipFileOrFolder(ArrayList FileList)
{
string ZipTargetFile = null;

if (FileList.Count == 1) {
ZipTargetFile = GetLocalPath(Path.ChangeExtension(Convert.ToString(FileList.Item(0)), ".zip"));
}
else {
ZipTargetFile = GetLocalPath("ZipFile.zip");
}

FileStream zfs = default(FileStream);
ICSharpCode.SharpZipLib.Zip.ZipOutputStream zs = default(ICSharpCode.SharpZipLib.Zip.ZipOutputStream);
try {
if (File.Exists(ZipTargetFile)) {
zfs = File.OpenWrite(ZipTargetFile);
}
else {
zfs = File.Create(ZipTargetFile);
}

zs = new ICSharpCode.SharpZipLib.Zip.ZipOutputStream(zfs);

ExpandFileList(FileList);

foreach (string strName in FileList) {
ICSharpCode.SharpZipLib.Zip.ZipEntry ze = default(ICSharpCode.SharpZipLib.Zip.ZipEntry);
//-- the ZipEntry requires a preceding slash if the file is a folder
if (strName.IndexOf("\\") > -1 & !strName.StartsWith("\\")) {
ze = new ICSharpCode.SharpZipLib.Zip.ZipEntry("\\" + strName);
}
else {
ze = new ICSharpCode.SharpZipLib.Zip.ZipEntry(strName);
}

ze.DateTime = DateTime.Now;
zs.PutNextEntry(ze);

FileStream fs = default(FileStream);
try {
fs = File.OpenRead(GetLocalPath(strName));
byte[] buffer = new byte[2049];
int len = fs.Read(buffer, 0, buffer.Length);
while (len > 0) {
zs.Write(buffer, 0, len);
len = fs.Read(buffer, 0, buffer.Length);
}
}
catch (Exception ex) {
_FileOperationException = ex;
}
finally {
if ((fs != null)) fs.Close();
zs.CloseEntry();
}
}
}
finally {
if ((zs != null)) zs.Close();
if ((zfs != null)) zfs.Close();
}
}

///

/// renames a file; assumes filename is "(oldname)(renametag)(newname)"
///

private void RenameFileOrFolder(string strName)
{
string strOldName = null;
string strNewName = null;
int intTagLoc = strName.IndexOf(_strRenameTag);
if (intTagLoc == -1) return;

strOldName = strName.Substring(0, intTagLoc);
strNewName = strName.Substring(intTagLoc + _strRenameTag.Length);
if (strOldName == strNewName) return;

string strOldPath = GetLocalPath(strOldName);
string strNewPath = GetLocalPath(strNewName);

try {
if (IsDirectory(strOldPath)) {
Directory.Move(strOldPath, strNewPath);
}
else {
File.Move(strOldPath, strNewPath);
}
}
catch (Exception ex) {
_FileOperationException = ex;
}
}

///

/// creates a subfolder in the current folder
///

private void MakeFolder(string strFilename)
{
string strLocalPath = GetLocalPath(strFilename);
try {
if (!Directory.Exists(strLocalPath)) {
Directory.CreateDirectory(strLocalPath);
}
}
catch (Exception ex) {
_FileOperationException = ex;
}
}

///

/// recursively copies a folder, and all subfolders and files, to a target path
///

private void CopyFolder(string strSourceFolderPath, string strDestinationFolderPath, bool blnOverwrite)
{

//-- make sure target folder exists
if (!Directory.Exists(strDestinationFolderPath)) {
Directory.CreateDirectory(strDestinationFolderPath);
}

//-- copy all of the files in this folder to the destination folder
foreach (string strFilePath in Directory.GetFiles(strSourceFolderPath)) {
string strFileName = Path.GetFileName(strFilePath);
//-- if exception, will be caught in calling proc
File.Copy(strFilePath, Path.Combine(strDestinationFolderPath, strFileName), blnOverwrite);
}

//-- copy all of the subfolders in this folder
foreach (string strFolderPath in Directory.GetDirectories(strSourceFolderPath)) {
string strFolderName = Regex.Match(strFolderPath, "[^\\\\]+$").ToString;
CopyFolder(strFolderPath, Path.Combine(strDestinationFolderPath, strFolderName), blnOverwrite);
}
}

///

/// Given an ArrayList of file and folder names, ensure that the
/// ArrayList contains all subfolder file names
///

private void ExpandFileList(ref ArrayList FileList)
{

string strLocalPath = null;
ArrayList NewFileList = new ArrayList();

for (int i = FileList.Count - 1; i >= 0; i += -1) {
strLocalPath = GetLocalPath(Convert.ToString(FileList.Item(i)));
if (IsDirectory(strLocalPath)) {
FileList.Remove(FileList.Item(i));
AddFilesFromFolder(strLocalPath, NewFileList);
}
}

if (NewFileList.Count > 0) {
FileList.AddRange(NewFileList);
}
}

///

/// Adds all the files in the specified folder to the FileList,
///

private void AddFilesFromFolder(string strFolderName, ref ArrayList FileList)
{
if (!Directory.Exists(strFolderName)) return;

try {
foreach (string strName in Directory.GetFiles(strFolderName)) {
FileList.Add(MakeRelativePath(strName));
}
}
catch (Exception ex) {
//-- mostly to catch "access denied"
_FileOperationException = ex;
}

try {
foreach (string strName in Directory.GetDirectories(strFolderName)) {
AddFilesFromFolder(strName, FileList);
}
}
catch (Exception ex) {
//-- mostly to catch "access denied"
_FileOperationException = ex;
}
}

///

/// recursively removes the read only tag from a file or folder, if it is present
///

private void RemoveReadOnly(string strPath)
{
if (IsDirectory(strPath)) {
foreach (string strFile in Directory.GetFiles(strPath)) {
RemoveReadOnly(strFile);
}
foreach (string strFolder in Directory.GetDirectories(strPath)) {
RemoveReadOnly(strFolder);
}
}
else {
FileInfo fi = new FileInfo(strPath);
if ((fi.Attributes & FileAttributes.ReadOnly) != 0) {
fi.Attributes = fi.Attributes ^ FileAttributes.ReadOnly;
}
}
}

///

/// returns the windows identity that ASP.NET is currently running under
///

private string CurrentIdentity()
{
return System.Security.Principal.WindowsIdentity.GetCurrent.Name;
}

///

/// adds additional helpful information to certain types of exceptions
///

private string GetFriendlyErrorMessage(Exception ex)
{
string strMessage = ex.Message;
if (ex is System.UnauthorizedAccessException) {
strMessage += " The account '" + CurrentIdentity() + "' may not have permission to this file or folder.";
}
return strMessage;
}

///

/// Parse and display any exceptions encountered during a file operation
///

private void WriteError(Exception ex)
{
WriteError(GetFriendlyErrorMessage(ex));
}
private void WriteError(string strText)
{
Response.Write("

");
Response.Write(strText);
Response.Write("

");
}
private void WriteErrorRow(Exception ex)
{
WriteErrorRow(GetFriendlyErrorMessage(ex));
}
private void WriteErrorRow(string strText)
{
Response.Write("

");
Response.Write(strText);
Response.Write("

");
}
}

dont forget to mark this as "Accpeted answer"

0