微信小程序基于腾讯云对象存储的图片上传

        /// <summary>
        /// 文件流上传
        /// 说明: 酷客多小程序
        /// 其中分片上传使用SliceUploadInit SliceUploadData SliceUploadFinihs
        /// </summary>
        /// <param name="bucketName">bucket名称</param>
        /// <param name="remotePath">远程文件路径</param>
        /// <param name="localPath">本地文件路径</param>
        /// <param name="parameterDic">参数Dictionary</param>
        /// <returns></returns>
        public string UploadFile(string bucketName, string remotePath, Stream file, string filename,Dictionary<string, string> parameterDic = null)
        {
            if (remotePath.EndsWith("/"))
            {
                return constructResult(ERRORCode.ERROR_CODE_PARAMETER_ERROE, "file path can not end with ‘/‘");
            }

            string bizAttribute = "";
            if (parameterDic != null && parameterDic.ContainsKey(CosParameters.PARA_BIZ_ATTR))
                bizAttribute = parameterDic[CosParameters.PARA_BIZ_ATTR];

            int insertOnly = 1;
            if (parameterDic != null && parameterDic.ContainsKey(CosParameters.PARA_INSERT_ONLY))
            {
                try
                {
insertOnly = Int32.Parse(parameterDic[CosParameters.PARA_INSERT_ONLY]);
                }
                catch (Exception e)
                {
Console.WriteLine(e.Message);
return constructResult(ERRORCode.ERROR_CODE_PARAMETER_ERROE, "parameter insertOnly value invalidate");
                }
            }
            return Upload(bucketName, remotePath, file, filename, bizAttribute, insertOnly);

        }

        /// <summary>
        /// 单个文件上传
        /// 说明: 酷客多小程序
        /// <param name="bucketName">bucket名称</param>
        /// <param name="remotePath">远程文件路径</param>
        /// <param name="localPath">本地文件路径</param>
        /// <param name="biz_attr">biz_attr属性</param>
        /// <param name="insertOnly">同名文件是否覆盖</param>
        /// <returns></returns>
        public string Upload(string bucketName, string remotePath, Stream file,string filename,
              string bizAttribute = "", int insertOnly = 1)
        {

            var url = generateURL(bucketName, remotePath);
            var sha1 = SHA1.GetFileSHA1(file);
            var data = new Dictionary<string, object>();
            data.Add("op", "upload");
            data.Add("sha", sha1);
            data.Add("biz_attr", bizAttribute);
            data.Add("insertOnly", insertOnly);

            var expired = getExpiredTime();
            var sign = Sign.Signature(appId, secretId, secretKey, expired, bucketName);
            var header = new Dictionary<string, string>();
            header.Add("Authorization", sign);


            return httpRequest.SendRequest(url, ref data, HttpMethod.Post, ref header, timeOut, file, filename);
        }

       #region 直接上传文件流
       public string SendRequest(string url, ref Dictionary<string, object> data, HttpMethod requestMethod,
       ref Dictionary<string, string> header, int timeOut, Stream file,string filename, long offset = -1, int sliceSize = 0)
        {
            try
            {
                //Console.WriteLine("url:" + url);
                System.Net.ServicePointManager.Expect100Continue = false;
                if (requestMethod == HttpMethod.Get)
                {
var paramStr = "";
foreach (var key in data.Keys)
{
    paramStr += string.Format("{0}={1}&", key, HttpUtility.UrlEncode(data[key].ToString()));
}
paramStr = paramStr.TrimEnd(‘&‘);
url += (url.EndsWith("?") ? "&" : "?") + paramStr;
                }

                request = (HttpWebRequest)HttpWebRequest.Create(url);
                request.Accept = CosDefaultValue.ACCEPT;
                request.KeepAlive = true;
                request.UserAgent = CosDefaultValue.USER_AGENT_VERSION;
                request.Timeout = timeOut;
                foreach (var key in header.Keys)
                {
if (key == "Content-Type")
{
    request.ContentType = header[key];
}
else
{
    request.Headers.Add(key, header[key]);
}
                }
                if (requestMethod == HttpMethod.Post)
                {
request.Method = requestMethod.ToString().ToUpper();
var memStream = new MemoryStream();
if (header.ContainsKey("Content-Type") && header["Content-Type"] == "application/json")
{
    var json = JsonConvert.SerializeObject(data);
    var jsonByte = Encoding.GetEncoding("utf-8").GetBytes(json.ToString());
    memStream.Write(jsonByte, 0, jsonByte.Length);
}
else
{
    var boundary = "---------------" + DateTime.Now.Ticks.ToString("x");
    var beginBoundary = Encoding.ASCII.GetBytes("rn--" + boundary + "rn");
    var endBoundary = Encoding.ASCII.GetBytes("rn--" + boundary + "--rn");
    request.ContentType = "multipart/form-data; boundary=" + boundary;

    var strBuf = new StringBuilder();
    foreach (var key in data.Keys)
    {
        strBuf.Append("rn--" + boundary + "rn");
        strBuf.Append("Content-Disposition: form-data; name="" + key + ""rnrn");
        strBuf.Append(data[key].ToString());
    }
    var paramsByte = Encoding.GetEncoding("utf-8").GetBytes(strBuf.ToString());
    memStream.Write(paramsByte, 0, paramsByte.Length);

    memStream.Write(beginBoundary, 0, beginBoundary.Length);


    var fileStream = file;

    const string filePartHeader =
        "Content-Disposition: form-data; name="fileContent"; filename="{0}"rn" +
        "Content-Type: application/octet-streamrnrn";
    var headerText = string.Format(filePartHeader, filename);
    var headerbytes = Encoding.UTF8.GetBytes(headerText);
    memStream.Write(headerbytes, 0, headerbytes.Length);

    if (offset == -1)
    {
        var buffer = new byte[1024];
        int bytesRead;
        while ((bytesRead = fileStream.Read(buffer, 0, buffer.Length)) != 0)
        {
            memStream.Write(buffer, 0, bytesRead);
        }
    }
    else
    {
        var buffer = new byte[sliceSize];
        int bytesRead;
        fileStream.Seek(offset, SeekOrigin.Begin);
        bytesRead = fileStream.Read(buffer, 0, buffer.Length);
        memStream.Write(buffer, 0, bytesRead);
    }
    fileStream.Close();

    memStream.Write(endBoundary, 0, endBoundary.Length);
}
request.ContentLength = memStream.Length;
var requestStream = request.GetRequestStream();
memStream.Position = 0;
var tempBuffer = new byte[memStream.Length];
memStream.Read(tempBuffer, 0, tempBuffer.Length);
memStream.Close();

requestStream.Write(tempBuffer, 0, tempBuffer.Length);
requestStream.Close();

//Console.WriteLine(strBuf.ToString());
                }

                //Console.WriteLine(request.ContentType.ToString());


                var response = request.GetResponse();
                using (var s = response.GetResponseStream())
                {
var reader = new StreamReader(s, Encoding.UTF8);
return reader.ReadToEnd();
                }
            }
            catch (WebException we)
            {
                if (we.Status == WebExceptionStatus.ProtocolError)
                {
using (var s = we.Response.GetResponseStream())
{
    var reader = new StreamReader(s, Encoding.UTF8);
    return reader.ReadToEnd();
}
                }
                else
                {
throw we;
                }
            }
            catch (Exception e)
            {
                throw e;
            }
        }