HttpWebRequest 下载文件，并且能够断点续传

  HttpWebRequest是unity 内置得类用来处理关于http通讯得。  

using UnityEngine;
using System.Threading;
using System.IO;
using System.Net;
using System;
/// <summary>
/// 下载工具类
/// </summary>
public class ThreadLoadFile :MonoBehaviour
{

    private string url;
    private Thread _thread;
    //进度
    private long progress;
    private long LoadSpeed;
    private float precent;

    //默认保存文件夹路径
    private string DefaultSavePath;
    //保存结束后最终的文件路径（含后缀）
    private string SavedPath;
    private string SaveingPath;
    private string flieSize;
    private long fileByteLength;
    //下载文件名称（含后缀）
    private string FileName;


    public bool FileIsLoaded = false;
    //下载中文件名后缀
    private string CacheSuffix = ".realmax";
    //下载文件原后缀
    private string Extension;

    //检测文件是否已经存在
    private bool CheckIsLoaded()
    {
        if(File.Exists(SavedPath))
        {
            FileStream fileStream = File.OpenWrite(SavedPath);
            long Filelength = fileStream.Length;
            fileStream.Close();
            if(Filelength == fileByteLength)
            {
                Debug.Log(FileName + "文件已经存在");              
                return true;
            }
            else
            {
                Debug.Log(FileName + "文件已经存在，但是文件异常");
            }
        }
        return false;
    }

# region  调用的方法入口   

    //***********这些初始化后即可获得数据***********
   
    //获取文件名字
    public string GetFileName()
    {
        return FileName;
    }

    //获取文件大小
    public string GetFileSize()
    {
        return flieSize;
    }
    //获取保存路径(需要先设置Url，否则将返回空路径)
    public string GetSavePath()
    {
        return SavedPath;
    }
    //***********这些需要运行StartLoad 方法后才能获得数据***********
    /// <summary>
    /// 开始下载
    /// </summary>
    public void StartLoad()
    {
        if(FileIsLoaded)
        {
            return;
        }
        if(_thread!=null)
            _thread.Start();
    }
    //获取下载进度
    public string GetProgress()
    {
        return ByteToString(progress);
    }
    //获取下载百分比
    public float GetPercent()
    {
        return precent;
    }
    //获取下载速度
    public string GetLoadSpeed()
    {
        return ByteToString(LoadSpeed) + "/s";
    }
#endregion
    //删除下载的文件以及缓存文件（当反馈下载文件异常时可调用）
    private void DeleteLoadFile()
    {
        if(File.Exists(SavedPath))
        {
            FileInfo fileInfo = new FileInfo(SavedPath);
            fileInfo.Delete();
        }
        if(File.Exists(SaveingPath))
        {
            FileInfo fileInfo = new FileInfo(SaveingPath);
            fileInfo.Delete();
        }
    }



 
    /// <summary>        
    /// HTTP 下载文件     
    /// Current Thread Download
    /// </summary>             
    private void DownloadFile()
    {

         FileStream fileStream;
         long lStartPos=0;
        if(File.Exists(SaveingPath))
        {
            fileStream = File.OpenWrite(SaveingPath);
            lStartPos = fileStream.Length;
            fileStream.Seek(lStartPos, SeekOrigin.Current);//移动文件流中的当前指针
            Debug.Log(FileName + "上次下载未完成，将继续下载");
        }
        else
        {
            fileStream = new FileStream(SaveingPath, FileMode.Create);
            Debug.Log(FileName + "开始下载");
        }


        //下载
        HttpWebRequest Myrq = (HttpWebRequest)HttpWebRequest.Create(url);
        Myrq.Method = "GET";


        if(lStartPos > fileByteLength)
        {
            Debug.Log("缓存文件异常，请删除后继续");
            _thread.Abort();
            return;
        }
        if(lStartPos > 0)
            Myrq.AddRange((int)lStartPos); //设置Range值  

        HttpWebResponse myrp = (HttpWebResponse)Myrq.GetResponse();
        long totalBytes = myrp.ContentLength;
        Stream st = myrp.GetResponseStream();
        long totalDownloadedByte = 0;
        byte[] by = new byte[1024];
        int osize = st.Read(by, 0, (int)by.Length);
        while(osize > 0)
        {

            totalDownloadedByte = osize + totalDownloadedByte;
            //保存字节
            fileStream.Write(by, 0, osize);
            progress = (int)totalDownloadedByte + lStartPos;
            precent = (float)progress / fileByteLength;
            osize = st.Read(by, 0, (int)by.Length);
        }
        fileStream.Dispose();
        fileStream.Close();
        st.Dispose();
        st.Close();
        if(File.Exists(SaveingPath))
        {
            FileInfo fileInfo = new FileInfo(SaveingPath);
            if(fileInfo.Length == fileByteLength)
            {
                fileInfo.MoveTo(SavedPath);
            }
            else
            {
                Debug.LogError("文件下载异常，请删除缓存文件重新下载");
            }
            FileIsLoaded = true;
        
        }
        if(myrp != null)
        {
            myrp.Close();
        }
        if(Myrq != null)
        {
            Myrq.Abort();
        }
        _thread.Abort();
    }
    private long GetHttpWebResponseLength()
    {
        HttpWebRequest Myrq = (HttpWebRequest)HttpWebRequest.Create(url);
       
        HttpWebResponse httpWebResponse = (HttpWebResponse)Myrq.GetResponse();
        long Length = httpWebResponse.ContentLength;
        httpWebResponse.Close();
        Myrq.Abort();
        return Length;
    }

    /// <summary>
    /// 检测URL是否有效
    /// </summary>
    /// <param name="url"></param>
    /// <returns></returns>
    private  bool CheckUrlValid(string url)
    {
        Uri uriResult;
        bool result = Uri.TryCreate(url, UriKind.Absolute, out uriResult);

        if(result)
        {
           
            uriResult = new Uri(url);
            if(uriResult.Scheme == Uri.UriSchemeHttps || uriResult.Scheme == Uri.UriSchemeHttp)
                return true;
        }

        return false;
    }

    ///通过url获取APK名字
    private string GetApkName(string url)
    {
        if(CheckUrlValid(url))
        {
            string[] Strings = url.Split('/');
            if(Strings.Length > 0)
            {
                for(int i = 0; i < Strings.Length; i++)
                {
                    if(Strings[i].Contains(".apk"))
                    {
                        return Strings[i];
                    }
                }
            }
        }
        return null;
    }

    private long CurrentProgree;
    private long LastProgree;
    private float UpdateTimeLoadSpeed = 1;
    private float Timer = 0;
    private void Update()
    {
        CurrentProgree = progress;
        if(LastProgree == 0)
            LastProgree = CurrentProgree;
        Timer += Time.deltaTime;
        if(Timer >= UpdateTimeLoadSpeed)
        {
            LoadSpeed = CurrentProgree - LastProgree;
            LastProgree = CurrentProgree;
            Timer = 0;
        }
    }


    //将字节大小化为字符串 如1024 变为 1KB。
    private string ByteToString(long length)
    {

        float M = length / 1024.0f / 1024.0f;
        if(M > 0.5f)
        {
            return M.ToString("0.0") + "M";
        }
        else
        {
            float kb = length / 1024.0f;
            if(kb > 0.5f)
                return kb.ToString("0.0") + "KB";
            else
                return length.ToString() + "B";
        }

    }
    private void OnApplicationQuit()
    {
        _thread.Abort();
    }

    private void OnDisable()
    {
        _thread.Abort();
    }
    private void OnDestroy()
    {
        _thread.Abort();
    }

    /// <summary>
    /// 通过URL获取文件的文字
    /// </summary>
    /// <param name="url"></param>
    /// <returns></returns>
    private string GetFileName(string url)
    {
        string[] slip = url.Split('/');
        if(slip[slip.Length - 1].Contains("."))
        {
            return slip[slip.Length - 1];
        }
        return null;
    }
    /// <summary>
    /// 获取文件后缀
    /// </summary>
    /// <param name="url"></param>
    /// <returns></returns>
    private string GetExtension(string flie)
    {
        string Extension = "";
        if(flie.Contains("."))
        {
            string[] slips = flie.Split('.');
            Extension = "." + slips[slips.Length - 1];
            return Extension;
        }
        return null;
    }
    public void Init(string _url,string SavePath)
    {
        if(CheckUrlValid(_url))
        {
            url = _url;
            FileName = GetFileName(url);
            Extension = GetExtension(FileName);
            SavedPath = SavePath+"/" + FileName;
            SaveingPath = SavedPath.Replace(Extension, CacheSuffix);
            fileByteLength = GetHttpWebResponseLength();
            flieSize = ByteToString(fileByteLength);
            FileIsLoaded = CheckIsLoaded();
            _thread = new Thread(DownloadFile);
          //  Debug.Log("Save path" + SavedPath);
        }
        else
        {

            Debug.LogError("URL 无效");
        }
    }


}