.netcore 通过华为云上传文件到存储桶中

using OBS;
using OBS.Model;
using System.Text.RegularExpressions;

namespace Zowie.Common.Helper
{
    /// <summary>
    /// 华为云OBS
    /// NuGet引用esdk_obs_.net_core，版本：3.0.4
    /// </summary>
    public class HuaWeiOBSHelper
    {
        private ObsClient client;

        public HuaWeiOBSHelper()
        {
            ObsConfig config = new ObsConfig();
            config.Endpoint = "Endpoint";
            var accessKey = "AccessKey";
            var secretKey = "SecretKey";
            client = new ObsClient(accessKey, secretKey, config);
        }

        // 创建一个存储桶
        public string CreateBucket(string bucketName = null)
        {
            try
            {
                CreateBucketRequest request = new CreateBucketRequest()
                {
                    BucketName = bucketName,
                    CannedAcl = CannedAclEnum.PublicRead,
                };
                // 创建存储空间。
                var bucket = client.CreateBucket(request);
                return "Create bucket succeeded";
            }
            catch (Exception ex)
            {
                return "Create bucket failed, " + ex.Message;
            }
        }

        /// <summary>
        /// 上传
        /// </summary>
        /// <param name="bucketName">填写Bucket名称，例如examplebucket</param>
        /// <param name="objectName">相对路径，相对路径中不能包含Bucket名称，例如exampledir/exampleobject.txt。</param>
        /// <param name="localFilename">绝对路径，例如D:\\localpath\\examplefile.txt</param>
        /// <returns></returns>
        public bool UploadFile(string bucketName, string objectName, string localFilename)
        {
            try
            {
                if (objectName.StartsWith("/"))
                {
                    objectName = objectName.Substring(1);
                }
                string pattern = @"\\|/";
                string replacement = @"/";
                Regex rgx = new Regex(pattern);
                localFilename = rgx.Replace(localFilename, replacement);
                objectName = rgx.Replace(objectName, replacement);
                // 上传文件。
                var request = new PutObjectRequest()
                {
                    BucketName = bucketName,
                    ObjectKey = objectName,
                    CannedAcl = CannedAclEnum.PublicRead,
                    FilePath = localFilename
                };
                if (objectName.ToLower().EndsWith(".png"))
                {
                    request.ContentType = "image/png";
                }
                else if (objectName.ToLower().EndsWith(".jpg") || objectName.ToLower().EndsWith(".jpeg"))
                {
                    request.ContentType = "image/jpeg";
                }
                else if (objectName.ToLower().EndsWith(".gif"))
                {
                    request.ContentType = "image/gif";
                }
                else if (objectName.ToLower().EndsWith(".mp4"))
                {
                    request.ContentType = "video/mp4";
                }
                var result = client.PutObject(request);
                return true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 存储一个字符串
        /// </summary>
        /// <param name="bucketName">填写Bucket名称，例如examplebucket</param>
        /// <param name="objectName">相对路径，相对路径中不能包含Bucket名称，例如exampledir/exampleobject.txt。</param>
        /// <param name="inputStream">字符内容</param>
        /// <returns></returns>
        public bool PutString(string bucketName, string objectName, Stream inputStream)
        {
            try
            {
                if (objectName.StartsWith("/"))
                {
                    objectName = objectName.Substring(1);
                }
                string pattern = @"\\|/";
                string replacement = @"/";
                Regex rgx = new Regex(pattern);
                // 上传文件。
                var request = new PutObjectRequest()
                {
                    BucketName = bucketName,
                    ObjectKey = objectName,
                    CannedAcl = CannedAclEnum.PublicRead,
                    InputStream = inputStream
                };
                if (objectName.ToLower().EndsWith(".png"))
                {
                    request.ContentType = "image/png";
                }
                else if (objectName.ToLower().EndsWith(".jpg") || objectName.ToLower().EndsWith(".jpeg"))
                {
                    request.ContentType = "image/jpeg";
                }
                else if (objectName.ToLower().EndsWith(".gif"))
                {
                    request.ContentType = "image/gif";
                }
                else if (objectName.ToLower().EndsWith(".mp4"))
                {
                    request.ContentType = "video/mp4";
                }
                var result = client.PutObject(request);
                return true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 删除文件
        /// </summary>
        /// <param name="bucketName">桶名</param>
        /// <param name="objectName">相对路径，相对路径中不能包含Bucket名称，例如exampledir/exampleobject.txt。</param>
        /// <returns></returns>
        public bool DeleteObject(string bucketName, string objectName)
        {
            try
            {
                if (objectName.StartsWith("/"))
                {
                    objectName = objectName.Substring(1);
                }
                // 删除文件。
                var request = new DeleteObjectRequest()
                {
                    BucketName = bucketName,
                    ObjectKey = objectName,
                };
                var response = client.DeleteObject(request);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return true;
        }

        /// <summary>
        /// 批量删除文件
        /// </summary>
        /// <param name="bucketName">桶名</param>
        /// <param name="objectNames">相对路径，相对路径中不能包含Bucket名称，例如exampledir/exampleobject.txt。</param>
        /// <returns></returns>
        public bool DeleteObjects(string bucketName, List<string> objectNames)
        {
            try
            {
                var request = new DeleteObjectsRequest();
                request.BucketName = bucketName;
                request.Quiet = false;
                foreach (var item in objectNames)
                {
                    if (item.StartsWith("/"))
                        request.AddKey(item.Substring(1));
                    else
                        request.AddKey(item);

                }
                var response = client.DeleteObjects(request);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return true;
        }

        /// <summary>
        /// 下载文件
        /// </summary>
        /// <param name="bucketName">桶名</param>
        /// <param name="objectName">相对路径，相对路径中不能包含Bucket名称，例如exampledir/exampleobject.txt。</param>
        /// <param name="filepath">填写本地文件的完整路径，例如D:\\localpath\\examplefile.txt</param>
        /// <returns></returns>
        public void GetObject(string bucketName, string objectName, string filepath)
        {
            try
            {
                if (objectName.StartsWith("/"))
                {
                    objectName = objectName.Substring(1);
                }
                string pattern = @"\\|/";
                string replacement = @"/";
                Regex rgx = new Regex(pattern);
                filepath = rgx.Replace(filepath, replacement);
                // 下载文件到流。OssObject包含了文件的各种信息，如文件所在的存储空间、文件名、元信息以及一个输入流。
                var request = new GetObjectRequest()
                {
                    BucketName = bucketName,
                    ObjectKey = objectName,
                };
                var obj = client.GetObject(request);
                using (Stream requestStream = obj.OutputStream)
                {
                    byte[] buf = new byte[1024];

                    // 确保本地目录结构存在  
                    string path = Path.GetDirectoryName(filepath);

                    if (!Directory.Exists(path))
                    {
                        Directory.CreateDirectory(path);
                    }
                    var fs = File.Open(filepath, FileMode.OpenOrCreate);
                    var len = 0;
                    // 通过输入流将文件的内容读取到文件或者内存中。
                    while ((len = requestStream.Read(buf, 0, 1024)) != 0)
                    {
                        fs.Write(buf, 0, len);
                    }
                    fs.Close();
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 文件是否存在
        /// </summary>
        /// <param name="bucketName"></param>
        /// <param name="objectName"></param>
        /// <returns></returns>
        public bool FileExist(string bucketName, string objectName)
        {
            try
            {
                if (objectName.StartsWith("/"))
                {
                    objectName = objectName.Substring(1);
                }
                var request = new GetObjectRequest()
                {
                    BucketName = bucketName,
                    ObjectKey = objectName,
                };
                var obj = client.GetObject(request);
                return true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }
}