程序博客网 > 文化部对网络直播

C# ajax 大文件上传

来源：互联网 发布：文化部对网络直播 编辑：程序博客网 时间：2024/05/17 02:46

C# ajax 大文件上传

C# ajax 大文件上传组件可以支持超大文件，最大支持10G，已经加入断点续传功能；本人测试效果良好，上传效率还可以。

全部代码暂不提供，只提供代码参考。

demo: http://dwz.cn/topwang

 

请看核心代码：

<br><br>public partial class MainPage : UserControl
    {
        private UploadDataContext model;
        private FileUploadContext fiUpService;
        private int UploadBlockSize = 400 * 1024;
        private bool IsUploadPaused = false;
        private string clientIP = "";
        private string allowExt = "";
        private long allowSize = 0;
        private string taskID="";
        Dictionary<string,bool> taskList = new Dictionary<string,bool>();
 
        public MainPage()
        {
            InitializeComponent();
        }
 
        public MainPage(string cip,string ext,string fSize)
            :this()
        {
            clientIP = cip;
            allowExt = FormatExt(ext);
            allowSize = long.Parse(fSize);
        }
 
        private string FormatExt(string fileExt) {
            string[] arr=fileExt.Split('|');
            string extList="";
            for(int i=0;i<arr.Length;i++){
                extList+="*."+arr[i];
                if(i!=arr.Length-1){
                    extList += ";";
                }
            }
            return fileExt.Replace("|",",")+"|"+extList;
        }
 
 
        [ScriptableMember]
        public string OnBeforeUnload()
        {
            if (model.TotalUploaded != 0 && model.TotalUploaded < model.TotalFileSize)
            {
                return "您正在上传文件，且尚未完成，您确定离开？";
            }
            else
            {
                return string.Empty;
            }
        }
 
        private void UserControl_Loaded(object sender, RoutedEventArgs e)
        {
            model = new UploadDataContext();
            this.DataContext = model;
            fiUpService = new FileUploadContext();
 
            const string scriptableObjectName = "Bridge";
            HtmlPage.RegisterScriptableObject(scriptableObjectName,this);
            string pluginName = HtmlPage.Plugin.Id;
            string script = string.Format(
                    @"window.onbeforeunload = function () {{
                        var slApp = document.getElementById('{0}');
                        var result = slApp.Content.{1}.OnBeforeUnload();
                        if(result.length > 0)
                        return result;
                    }}", pluginName, scriptableObjectName);
            HtmlPage.Window.Eval(script);
        }
 
        private void btnSelectFile_Click(object sender, RoutedEventArgs e)
        {
            var dialog = new OpenFileDialog();
            dialog.Multiselect = true;
            dialog.Filter = allowExt;
 
            if (dialog.ShowDialog() == true)
            {
                string notAllowedFiles = "";
 
                foreach (var filein dialog.Files)
                {
 
                    string md5 = MD5.GetMd5String(clientIP + file.Name + file.Length + DateTime.Now.ToString("yyyy-MM-dd"));
                    if (model.UploadFileList.FirstOrDefault(x => x.FileId == md5) == null)
                    {
                        if (!IsAllowFileSize(file.Length))
                        {
                            notAllowedFiles += ";" + file.Name;
                            continue;
                        }
                        UploadFileInfo ufile = new UploadFileInfo();
                        ufile.FileId = md5;
                        ufile.FileName = file.Name;
                        ufile.FileSize = file.Length;
                        ufile.Uploaded = 0;
                        ufile.FileInfo = file;
                        model.UploadFileList.Add(ufile);
                    }
                }
                if (notAllowedFiles.Length > 0)
                {
                    MessageBox.Show("单个文件大小不能超过：" + formatSize(allowSize));
                }
 
                btnStartUpload.IsEnabled = model.UploadFileList.Count > 0;
 
            }
        }
 
        private bool IsAllowFileSize(long fSize)
        {
            if (this.allowSize > fSize || this.allowSize== fSize)
            {
                return true;
            }
            else {
                return false;
            }
        }
 
        private string formatSize(long value) {
            if (value>0)
            {
                long fileSize = (long)value;
                string result;
                if (fileSize >= 1024 * 1024 * 1024)
                {
                    result = Math.Round((double)fileSize / (1024 * 1024 * 1024), 2) + " GB";
                }
                else if (fileSize >= 1024 * 1024)
                {
                    result = Math.Round((double)fileSize / (1024 * 1024), 2) + " MB";
                }
                else if (fileSize >= 1024)
                {
                    result = Math.Round((double)fileSize / 1024, 2) + " KB";
                }
                else
                {
                    result = fileSize + " B";
                }
                return result;
            }
            else
            {
                return "0 B";
            }
        }
 
        private void btnStartUpload_Click(object sender, RoutedEventArgs e)
        {
            btnSelectFile.IsEnabled = false;
            btnDelete.IsEnabled = false;
            btnStartUpload.IsEnabled = false;
            btnCancelUpload.IsEnabled = true;
            btnPauseUpload.IsEnabled = true;
            taskID = MD5.GetMd5String(DateTime.Now.ToString());
            taskList.Add(taskID,false);
            bool isResume = true;
            if (isResume == true)
            {
                foreach (var itemin model.UploadFileList)
                {
                    fiUpService.GetFileUploadInfo(new UploadFileInfoContract
                    {
                        FileId = item.FileId,
                        FileName = item.FileName,
                        FileSize = item.FileSize,
                        Uploaded = item.Uploaded
                    }, OnGetFileInfoComplete, null);
                }
            }
            else
            {
                foreach (var itemin model.UploadFileList)
                {
                    Uploading(item);
                }
            }
 
        }
 
        private void OnGetFileInfoComplete(InvokeOperation<UploadFileInfoContract> invokeOp)
        {
            UploadFileInfoContract contract = invokeOp.Value;
            if (contract != null)
            {
                UploadFileInfo ufi = model.UploadFileList.SingleOrDefault(x => x.FileId == contract.FileId);
                if (ufi != null)
                {
                    ufi.Uploaded = contract.Uploaded;
                    if(ufi.FileSize>ufi.Uploaded){
                        Uploading(ufi);
                    }else if (ufi.FileSize == ufi.Uploaded){
                        ufi.ServerUrl = contract.ServerUrl;
                        Uploading(ufi);
                    }
                }
            }
        }
 
 
         
        private void Uploading(UploadFileInfo ufi)
        {
            if(taskID!=""){
                if (taskList.ContainsKey(taskID))
                {
                    if (taskList[taskID]==true)
                    {
                        return;
                    }
                }
            }
            lock (this)
            {
                if (IsUploadPaused)
                {
                    return;
                }
                if (ufi.Uploaded < ufi.FileSize)
                {
                    FileStream fs = ufi.FileInfo.OpenRead();
                    fs.Seek(ufi.Uploaded, SeekOrigin.Begin);
                    int size = UploadBlockSize;
                    if (size > ufi.FileSize - ufi.Uploaded)
                    {
                        size = (int)(ufi.FileSize - ufi.Uploaded);
                    }
                    byte[] bytes = new byte[size];
                    try
                    {
                        fs.Read(bytes, 0, size);
                        fiUpService.Uploading(new UploadFileInfoContract
                        {
                            FileId = ufi.FileId,
                            FileName = ufi.FileName,
                            FileSize = ufi.FileSize,
                            Uploaded = ufi.Uploaded
                        }, bytes, UploadingComplete, null);
                    }
                    finally
                    {
                        fs.Close();
                        fs.Dispose();
                        fs = null;
                    }
                }
                else
                {
                    if (model.TotalUploaded >= model.TotalFileSize)
                    {
                        taskList[taskID] = true;
                        UIHelper.SetTimeout(1000, () =>
                        {
                            string files_list = "[";
                            int i=0;
                            foreach (var itemin model.UploadFileList)
                            {
                                i++;
                                files_list += "{\"file_name\":\""+item.FileName+"\",\"file_size\":\""+item.FileSize+"\",\"file_url\":\""+item.ServerUrl+"\"}";
                                if(i!=model.UploadFileList.Count){
                                    files_list += ",";
                                }
                            }
                            files_list += "]";
                            model.UploadFileList.Clear();
                            btnSelectFile.IsEnabled = true;
                            btnDelete.IsEnabled = true;
                            btnStartUpload.IsEnabled = false;
                            btnCancelUpload.IsEnabled = false;
                            IsUploadPaused = false;
                            btnPauseUpload.Content = "暂停";
                            btnPauseUpload.IsEnabled = false;
                            HtmlPage.Window.Invoke("FileUploadCompleteJs", files_list);
                             
                        });
                    }
                }
            }
        }
 
        private void UploadingComplete(InvokeOperation<UploadFileInfoContract> invokeOp)
        {
            UploadFileInfoContract contract = invokeOp.Value;
            if (contract != null)
            {
                UploadFileInfo ufi = model.UploadFileList.SingleOrDefault(x => x.FileId == contract.FileId);
                if (ufi != null)
                {
                    ufi.Uploaded = contract.Uploaded;
                    ufi.ServerUrl = contract.ServerUrl;
                    Uploading(ufi);
                }
            }
        }
 
        private void btnCancelUpload_Click(object sender, RoutedEventArgs e)
        {
            lock (this)
            {
                IsUploadPaused = true;
                btnPauseUpload.IsEnabled = false;
                ConfirmWin win = new ConfirmWin();
                win.Message = "取消上传将会清空当前已上传部分文件，\r\n您确定要取消上传？";
                win.Closed += new EventHandler(CancelConfirmWin_Closed);
                win.Show();
            }
        }
 
        void CancelConfirmWin_Closed(object sender, EventArgs e)
        {
            ConfirmWin win = sender as ConfirmWin;
            if (win.DialogResult == true)
            {
                List<UploadFileInfoContract> list = new List<UploadFileInfoContract>();
                foreach (var itemin model.UploadFileList)
                {
                    UploadFileInfoContract c = new UploadFileInfoContract();
                    c.FileId = item.FileId;
                    c.FileName = item.FileName;
                    c.FileSize = item.FileSize;
                    c.Uploaded = item.Uploaded;
                    list.Add(c);
                }
                fiUpService.CancelUpload(list, CancelUploadComplete, null);
                taskList.Remove(taskID);
                taskID = "";
            }
            else
            {
                IsUploadPaused = false;
                btnPauseUpload.Content = "暂停";
                btnPauseUpload.IsEnabled = true;
            }
        }
 
        private void CancelUploadComplete(InvokeOperation<List<UploadFileInfoContract>> invokeOp)
        {
            List<UploadFileInfoContract> list = invokeOp.Value;
            if (list != null)
            {
                foreach (var itemin list)
                {
                    UploadFileInfo ufi = model.UploadFileList.SingleOrDefault(x => x.FileId == item.FileId);
                    if (ufi != null)
                    {
                        ufi.Uploaded = item.Uploaded;
                    }
                }
            }
            IsUploadPaused = false;
            btnSelectFile.IsEnabled = true;
            btnDelete.IsEnabled = true;
            btnStartUpload.IsEnabled = true;
            btnPauseUpload.IsEnabled = false;
            btnPauseUpload.Content = "暂停";
            btnCancelUpload.IsEnabled = false;
        }
 
        private void btnDelete_Click(object sender, RoutedEventArgs e)
        {
 
            if (grdFileList.SelectedItems != null)
            {
                List<UploadFileInfo> selectedItems = new List<UploadFileInfo>();
  
                foreach (var itemin grdFileList.SelectedItems)
                {
                    UploadFileInfo fi = item as UploadFileInfo;
                    if (fi != null)
                    {
                        selectedItems.Add(fi);
                    }
                }
                int i = 0;
                foreach (var itemin selectedItems)
                {
                    i++;
                    model.UploadFileList.Remove(item);
                }
                if (i == 0)
                {
                    MessageBox.Show("您没有选中任何文件，请先选中文件。");
                }
 
                if (model.UploadFileList.Count == 0)
                {
                    btnStartUpload.IsEnabled = false;
                }
            }
 
        }
 
        private void btnPauseUpload_Click(object sender, RoutedEventArgs e)
        {
            lock (this)
            {
                IsUploadPaused = !IsUploadPaused;
                if (IsUploadPaused)
                {
                    btnPauseUpload.Content = "继续";
                }
                else
                {
                    btnPauseUpload.Content = "暂停";
                    if (taskList[taskID] == false)
                    {
                        foreach (var itemin model.UploadFileList)
                        {
                            fiUpService.GetFileUploadInfo(new UploadFileInfoContract
                            {
                                FileId = item.FileId,
                                FileName = item.FileName,
                                FileSize = item.FileSize,
                                Uploaded = item.Uploaded
                            }, OnGetFileInfoComplete, null);
                        }
                    }
                }
            }
        }
    }

　　

文章来源： QQ:742631333，TEL:15920553851
分类: C#大文件上传,AJAX大文件上传

标签: 大文件上传, 大文件上传控件, 大文件上传组件, AJAX上传大文件

拓网科技
关注 - 0
粉丝 - 10
+加关注

0 0
文化部对网络直播 文化部对网络直播
原创粉丝点击
热门IT博客
软件可靠性设计论文软件可靠性设计论文
游族网络无限工作室游族网络无限工作室
申请域名注册商
java随机数生成一样
又白洗衣片是骗局知乎
西财财经大学网络
魔兽争霸3宽屏mac
虎牙银豆淘宝怎么交易
sql convert
java log4j.xml
神奇的矩阵第一季pdf
amd cpu 游戏优化软件
铁岭启航网络
长虹电视看网络电视
淘宝号在哪里可以买到
淘宝修改差评
新浪网络电视
校准手机电池软件
南宁大数据平台
电梯运行模式的优化
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 宠物租赁 宠物排行榜 深圳宠物 宠物批发 宠物狗市场 宠物航空箱 宠物诱食剂 广州宠物狗 猫宠物 大型宠物猫 宠物展览会 宠物小猫 宠物寄养 宠物犬购买 小型宠物犬 宠物火葬 宠物展 宠宠物 宠物医生 大连宠物店 宠物名 西安宠物 网购宠物 宠物猫价格 宠物公司 宠物医学 小的宠物狗 宠物训练 国际宠物展 宠物论坛 当宠物医生 宠物平台 宠物寄养看宠物 上海宠物展 训练宠物 养什么宠物 迷你宠物 开宠物医院 上海宠物 宠物寄养店 宠物猫医院

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里