/// <summary>
/// 创建bucket
/// </summary>
/// <param name="bucketName">bucket名</param>
/// <param name="aclType">开放类型</param>
/// <param name="ossPoint">站点</param>
/// <param name="accessId">accessId</param>
/// <param name="accessKey">accessKey</param>
/// <returns></returns>
public static bool SetBucketAcl(string bucketName, string aclType)
{
if (string.IsNullOrWhiteSpace(bucketName))
{
throw new Exception("Bucket名称为空");
}
//建立Oss客户端连接
OssClient client = ConnOssClient();
if (!client.DoesBucketExist(bucketName))
{
throw new Exception("Bucket还没有建立");
}
//设置读写
switch (aclType)
{
case "1":
client.SetBucketAcl(bucketName, CannedAccessControlList.PublicRead);
break;
case "2":
client.SetBucketAcl(bucketName, CannedAccessControlList.Private);
break;
default:
client.SetBucketAcl(bucketName, CannedAccessControlList.PublicReadWrite);
break;
}
return(true);
}
public async Task SaveBlobStreamAsync(string containerName, string blobName, Stream source, BlobProperties properties = null)
{
try
{
await Task.Run(() =>
{
var exist = _ossClient.DoesBucketExist(containerName);
if (!exist)
{
_ossClient.CreateBucket(containerName);
}
var md5 = OssUtils.ComputeContentMd5(source, source.Length);
var objectMeta = new ObjectMetadata();
objectMeta.AddHeader("Content-MD5", md5);
objectMeta.UserMetadata.Add("Content-MD5", md5);
if (properties != null)
{
objectMeta.ContentType = properties.ContentType;
}
_ossClient.PutObject(containerName, blobName, source, objectMeta);
});
}
catch (Exception ex)
{
if (ex.IsOssStorageException())
{
throw ex.Convert();
}
throw;
}
}
/// <summary>
/// 创建bucket
/// </summary>
/// <param name="bucketName">bucket名</param>
/// <param name="referers">白名单字符串数组Json</param>
/// <param name="ossPoint">站点</param>
/// <param name="accessId">accessId</param>
/// <param name="accessKey">accessKey</param>
/// <returns></returns>
public static bool SetBucketReferer(string bucketName, string referers)
{
if (string.IsNullOrWhiteSpace(bucketName))
{
throw new Exception("Bucket名称为空");
}
//建立Oss客户端连接
OssClient client = ConnOssClient();
if (!client.DoesBucketExist(bucketName))
{
throw new Exception("Bucket还没有建立");
}
//设置白名单
if (string.IsNullOrWhiteSpace(referers))
{
var request = new SetBucketRefererRequest(bucketName);
client.SetBucketReferer(request);
}
else
{
List <string> refererList = JSONHelper.JsonToModel <List <string> >(referers);//jSON 反序列化
var request = new SetBucketRefererRequest(bucketName, refererList);
client.SetBucketReferer(request);
}
return(true);
}
public Task <bool> BucketExistsAsync(string bucketName)
{
if (string.IsNullOrEmpty(bucketName))
{
throw new ArgumentNullException(nameof(bucketName));
}
return(Task.FromResult(_client.DoesBucketExist(bucketName)));
}
public static OssSign BuildSign(string bucketName, string dir, string userId, string fileType, int?maxLength, int hours = 2)
{
if (string.IsNullOrWhiteSpace(bucketName))
{
throw new Exception("Bucket名称为空");
}
//建立Oss客户端连接
OssClient client = ConnOssClient();
if (!client.DoesBucketExist(bucketName))
{
throw new Exception("Bucket还没有建立");
}
//如果文件夹未设置则设置为临时文件夹
if (string.IsNullOrWhiteSpace(dir))
{
dir = "Temp";
}
string ossDomain = ConfigHelper.GetConfigString("Oss_Domain");
string ossPoint = ConfigHelper.GetConfigString("Oss_Point");
string accessId = ConfigHelper.GetConfigString("Oss_AccessId");
string accessKey = ConfigHelper.GetConfigString("Oss_AccessKey");
OssSign ossSign = new OssSign();
ossSign.OssDomain = ossDomain;
ossSign.OSSAccessKeyId = accessId;
ossSign.bucketUrl = ossPoint.Replace("oss-", bucketName + ".oss-");
string keyPath = dir + "/" + userId + "/" + fileType + "/" + DateTime.Now.ToString("yyyyMMdd") + "/";
ossSign.key = keyPath + "${filename}";
ossSign.guid = Guid.NewGuid().ToString("N").ToUpper();
policy policyModel = new policy();
policyModel.expiration = DateTime.Now.AddHours(hours).ToString("yyyy-MM-ddTHH:mm:00.000Z");
policyModel.conditions = new List <object>();
policyModel.conditions.Add(new
{
bucket = bucketName
});
policyModel.conditions.Add(new string[] { "starts-with", "$key", keyPath });
if (maxLength.HasValue)
{
List <object> range = new List <object>();
range.Add("content-length-range");
range.Add(1);
range.Add(maxLength);
policyModel.conditions.Add(range);
}
string jsonPolicy = JSONHelper.ObjectToJson(policyModel);
ossSign.policy = Base64Change.EncodeBase64ByUTF8(jsonPolicy);
ossSign.Signature = SHA1.Hmac_sha1(accessKey, ossSign.policy);
return(ossSign);
}
private bool DoesBucketExist(string bucketName)
{
try {
return(_client.DoesBucketExist(bucketName));
} catch (Exception ex) when(IsNotFoundException(ex))
{
return(false);
}
}
public Task Init()
{
Client = new OssClient(EndPoint, AccessKeyId, AccessKeySecret);
if (!Client.DoesBucketExist(DefaultBucket))
{
Client.CreateBucket(DefaultBucket);
}
return(Task.CompletedTask);
}
public override void OnApplicationShutdown(ApplicationShutdownContext context)
{
var ossClient = new OssClient(_endPoint, _accessKeyId, _accessKeySecret);
if (ossClient.DoesBucketExist(_bucketName))
{
ossClient.DeleteBucket(_bucketName);
}
}
/// <summary>
/// 检查bucket是否存在
/// </summary>
/// <param name="bucketName">bucket名</param>
/// <param name="ossPoint">站点</param>
/// <param name="accessId">accessId</param>
/// <param name="accessKey">accessKey</param>
/// <returns></returns>
public static bool CheckBucket(string bucketName)
{
if (string.IsNullOrWhiteSpace(bucketName))
{
throw new Exception("Bucket名称为空");
}
//建立Oss客户端连接
OssClient client = ConnOssClient();
return(client.DoesBucketExist(bucketName));
}
/// <summary>
/// 上传文件到Oss
/// </summary>
/// <param name="bucketName">bucket名</param>
/// <param name="dir">文件夹</param>
/// <param name="userId">用户ID</param>
/// <param name="fileType">文件类型</param>
/// <param name="file">文件</param>
/// <param name="ossPoint">站点</param>
/// <param name="accessId">accessId</param>
/// <param name="accessKey">accessKey</param>
/// <param name="newFileName">是否新文件名 默认生成新文件名</param>
/// <returns></returns>
public static string UploadFile(string bucketName, string dir, string userId, string fileType, HttpPostedFile file, bool newFileName = true)
{
if (string.IsNullOrWhiteSpace(bucketName))
{
throw new Exception("Bucket名称为空");
}
if (string.IsNullOrWhiteSpace(userId))
{
throw new Exception("userId为空");
}
if (string.IsNullOrWhiteSpace(fileType))
{
throw new Exception("fileType为空");
}
if (file == null || string.IsNullOrWhiteSpace(file.FileName))
{
throw new Exception("请选择文件");
}
//建立Oss客户端连接
OssClient client = ConnOssClient();
if (!client.DoesBucketExist(bucketName))
{
throw new Exception("Bucket还没有建立");
}
string fileName = file.FileName;
string fileExtension = Path.GetExtension(fileName).ToLower();
//文件保存Key生成
string Key = dir + "/" + userId + "/" + fileType + "/" + DateTime.Now.ToString("yyyyMMdd") + "/" + Guid.NewGuid().ToString("N").ToUpper() + fileExtension;
if (!newFileName)//保留原文件名
{
Key = dir + "/" + userId + "/" + fileType + "/" + DateTime.Now.ToString("yyyyMMdd") + "/" + fileName;
}
//设置缓存
ObjectMetadata Metadata = new ObjectMetadata();
//Metadata.CacheControl = "Private";
Metadata.CacheControl = string.Format("max-age={0}", 157680000);
//Metadata.AddHeader("Expires", DateTime.MaxValue.GetDateTimeFormats('r')[0]);
//Metadata.AddHeader("Expires", 2628000);
Metadata.AddHeader("Content-Type", FileContentTypeHelper.GetMimeType(fileExtension));
//上传文件到Oss
PutObjectResult putResult = client.PutObject(bucketName, Key, file.InputStream, Metadata);
return(GetDomain() + "/" + Key);
}
public static bool CreateBucket(OssClient client, string bucketName)
{
TkDebug.AssertArgumentNull(client, "client", null);
TkDebug.AssertArgumentNullOrEmpty(bucketName, "bucketName", null);
bucketName = bucketName.ToLower(ObjectUtil.SysCulture);
if (!client.DoesBucketExist(bucketName))
{
client.CreateBucket(bucketName);
return(true);
}
return(false);
}
/// <summary>
/// 上传文件到Oss
/// </summary>
/// <param name="bucketName">bucket名</param>
/// <param name="dir">文件夹</param>
/// <param name="userId">用户ID</param>
/// <param name="fileType">文件类型</param>
/// <param name="base64Str">文件Base64字符串</param>
/// <param name="fileExt">文件后缀</param>
/// <param name="ossPoint">站点</param>
/// <param name="accessId">accessId</param>
/// <param name="accessKey">accessKey</param>
/// <returns></returns>
public static string UploadFileFromBase64(string bucketName, string dir, string userId, string fileType, string base64Str, string fileExt)
{
if (string.IsNullOrWhiteSpace(bucketName))
{
throw new Exception("Bucket名称为空");
}
if (string.IsNullOrWhiteSpace(userId))
{
throw new Exception("userId为空");
}
if (string.IsNullOrWhiteSpace(fileType))
{
throw new Exception("fileType为空");
}
if (string.IsNullOrWhiteSpace(base64Str))
{
throw new Exception("请选择文件");
}
//建立Oss客户端连接
OssClient client = ConnOssClient();
if (!client.DoesBucketExist(bucketName))
{
throw new Exception("Bucket还没有建立");
}
byte[] imageBytes = Convert.FromBase64String(base64Str);
//读入MemoryStream对象
Stream stream = new MemoryStream(imageBytes);
string fileExtension = fileExt.ToLower();
//文件保存Key生成
string Key = dir + "/" + userId + "/" + fileType + "/" + DateTime.Now.ToString("yyyyMMdd") + "/" + Guid.NewGuid().ToString("N").ToUpper() + fileExtension;
//设置缓存
ObjectMetadata Metadata = new ObjectMetadata();
//Metadata.CacheControl = "Private";
Metadata.CacheControl = string.Format("max-age={0}", 157680000);
//Metadata.AddHeader("Expires", DateTime.MaxValue.GetDateTimeFormats('r')[0]);
//Metadata.AddHeader("Expires", 2628000);
Metadata.AddHeader("Content-Type", FileContentTypeHelper.GetMimeType(fileExtension));
//上传文件到Oss
client.PutObject(bucketName, Key, stream, Metadata);
return(GetDomain() + "/" + Key);
}
/// <summary>
/// 上传文件到Oss
/// </summary>
/// <param name="bucketName">bucket名</param>
/// <param name="Key">文件夹</param>
/// <param name="FileByte">文件字节数组</param>
/// <param name="fileExt">文件后缀</param>
/// <param name="ossPoint">站点</param>
/// <param name="accessId">accessId</param>
/// <param name="accessKey">accessKey</param>
/// <returns></returns>
public static string UploadFileFromByte(string bucketName, string Key, byte[] FileByte, string fileExt,
bool isExpires = true, bool isGzip = false)
{
if (string.IsNullOrWhiteSpace(bucketName))
{
throw new Exception("Bucket名称为空");
}
if (FileByte.Length == 0)
{
throw new Exception("请选择文件");
}
//建立Oss客户端连接
OssClient client = ConnOssClient();
if (!client.DoesBucketExist(bucketName))
{
throw new Exception("Bucket还没有建立");
}
//读入MemoryStream对象
string fileExtension = fileExt.ToLower();
//读入MemoryStream对象
Stream stream = new MemoryStream(FileByte);
//设置缓存
ObjectMetadata Metadata = new ObjectMetadata();
//Metadata.CacheControl = "Private";
if (isExpires)
{
Metadata.CacheControl = string.Format("max-age={0}", 157680000);
}
else
{
Metadata.CacheControl = "Private";
}
//if (isExpires) Metadata.AddHeader("Expires", DateTime.MaxValue.GetDateTimeFormats('r')[0]);
//if (isExpires) Metadata.AddHeader("Expires", 2628000);
Metadata.AddHeader("Content-Type", FileContentTypeHelper.GetMimeType(fileExtension));
if (isGzip)
{
Metadata.AddHeader("Content-Encoding", "gzip");
}
//上传文件到Oss
client.PutObject(bucketName, Key, stream, Metadata);
return(GetDomain() + "/" + Key);
}
/// <summary>
/// 判断存储空间是否存在
/// </summary>
/// <param name="bucketName">存储空间的名称</param>
public static bool DoesBucketExist(string bucketName)
{
bool exist = false;
try
{
exist = ossClient.DoesBucketExist(bucketName);
}
catch (Exception ex)
{
Console.WriteLine("Check object Exist failed. {0}", ex.Message);
}
return(exist);
}
public void CreateAndDeleteBucketDefaultRegionTest()
{
var settings = AccountSettings.Load();
//point to default region
var ossClient = new OssClient(settings.OssEndpoint, settings.OssAccessKeyId, settings.OssAccessKeySecret);
//get a random bucketName
var bucketName = OssTestUtils.GetBucketName(_className);
//assert bucket does not exist
Assert.IsFalse(OssTestUtils.BucketExists(ossClient, bucketName),
string.Format("Bucket {0} should not exist before creation", bucketName));
//create a new bucket
ossClient.CreateBucket(bucketName);
Assert.IsTrue(ossClient.DoesBucketExist(bucketName),
string.Format("Bucket {0} should exist after creation", bucketName));
//delete the bucket
ossClient.DeleteBucket(bucketName);
Assert.IsFalse(ossClient.DoesBucketExist(bucketName),
string.Format("Bucket {0} should not exist after deletion", bucketName));
}
public void CreateAndDeleteBucketDefaultRegionTest()
{
var settings = AccountSettings.Load();
//point to default region
var ossClient = new OssClient(settings.OssEndpoint, settings.OssAccessKeyId, settings.OssAccessKeySecret);
//get a random bucketName
var bucketName = OssTestUtils.GetBucketName(_className);
//assert bucket does not exist
Assert.IsFalse(OssTestUtils.BucketExists(ossClient, bucketName),
string.Format("Bucket {0} should not exist before creation", bucketName));
//create a new bucket
ossClient.CreateBucket(bucketName);
Assert.IsTrue(ossClient.DoesBucketExist(bucketName),
string.Format("Bucket {0} should exist after creation", bucketName));
//delete the bucket
ossClient.DeleteBucket(bucketName);
Assert.IsFalse(ossClient.DoesBucketExist(bucketName),
string.Format("Bucket {0} should not exist after deletion", bucketName));
}
/// <summary>
/// 判断存储空间是否存在
/// </summary>
/// <param name="bucketName">存储空间的名称</param>
public static bool DoesBucketExist(string bucketName)
{
var client = new OssClient(Tools.AliYunTools._ossEndpointURL, OSSACCESSKEYID, ACCESSKEYSECRET);
try
{
var exist = client.DoesBucketExist(bucketName);
return(exist);
}
catch (Exception ex)
{
Console.WriteLine(string.Format("Check object Exist failed. {0}", ex.Message));
return(false);
}
}
/// <summary>
/// Is Bucket Exist
/// </summary>
public bool IsBucketExist()
{
bool result = false;
try
{
result = client.DoesBucketExist(bucketName);
}
catch (OssException ex)
{
lastError = ex;
}
return(result);
}
//判断存储空间是否存在（相当于判断相片是否存在，可用于客户查询）
public void IfAlbumExit()
{
var client = new OssClient(endpoint, accessKeyId, accessKeySecret);
try
{
var exist = client.DoesBucketExist("igets");
Console.WriteLine("查询是否存在");
Console.WriteLine("存在 ? {0}", exist);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// 上传文件到Oss 文件名不变
/// </summary>
/// <param name="fileName">文件名</param>
/// <param name="bucketName">bucket名</param>
/// <param name="dir">文件夹</param>
/// <param name="userId">用户ID</param>
/// <param name="fileType">文件类型</param>
/// <param name="FileStream">文件流</param>
/// <param name="fileExt">文件后缀</param>
/// <param name="ossPoint">站点</param>
/// <param name="accessId">accessId</param>
/// <param name="accessKey">accessKey</param>
/// <returns></returns>
public static string UploadFileFromStream(string fileName, string bucketName, string dir, string userId, string fileType, Stream FileStream)
{
if (string.IsNullOrWhiteSpace(bucketName))
{
throw new Exception("Bucket名称为空");
}
if (string.IsNullOrWhiteSpace(userId))
{
throw new Exception("userId为空");
}
if (string.IsNullOrWhiteSpace(fileType))
{
throw new Exception("fileType为空");
}
if (FileStream.Length == 0)
{
throw new Exception("请选择文件");
}
//建立Oss客户端连接
OssClient client = ConnOssClient();
if (!client.DoesBucketExist(bucketName))
{
throw new Exception("Bucket还没有建立");
}
//读入MemoryStream对象
string fileExtension = Path.GetExtension(fileName);
//文件保存Key生成
string key = dir + "/" + userId + "/" + fileType + "/" + DateTime.Now.ToString("yyyyMMdd") + "/" + fileName;
//设置缓存
ObjectMetadata Metadata = new ObjectMetadata();
//Metadata.CacheControl = "Private";
Metadata.CacheControl = string.Format("max-age={0}", 157680000);
//Metadata.AddHeader("Expires", DateTime.MaxValue.GetDateTimeFormats('r')[0]);
//Metadata.AddHeader("Expires", 2628000);
Metadata.AddHeader("Content-Type", FileContentTypeHelper.GetMimeType(fileExtension));
//上传文件到Oss
client.PutObject(bucketName, key, FileStream, Metadata);
return(GetDomain() + "/" + key);
}
public static void DoesBucketExist(string bucketName)
{
try
{
var exist = client.DoesBucketExist(bucketName);
Console.WriteLine("exist ? " + exist);
}
catch (OssException ex)
{
Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
}
catch (Exception ex)
{
Console.WriteLine("Failed with error info: {0}", ex.Message);
}
}
/// <summary>
/// 将文件上传存储空间的方法（本SDK是用阿里云OSS作为存储空间）。
/// 用户可以根据自身的情况重写该方法，重写时须注意该方法必须传入文件二进制流（byte[]）和文件名
/// </summary>
/// <param name="fontfile">文件二进制流</param>
/// <param name="objectName">文件名</param>
/// <returns></returns>
private string UploadOss(byte[] fontfile, string objectName)
{
string endpoint = _ossConfig.Endpoint;
string accessKeyId = _ossConfig.AccessKeyId;
string accessKeySecret = _ossConfig.AccessKeySecret;
string bucketName = _ossConfig.BucketName;
// 创建OSSClient实例
OssClient ossClient = new OssClient(endpoint, accessKeyId, accessKeySecret);
try
{
var exists = ossClient.DoesBucketExist(bucketName);
if (exists)
{
ossClient.SetBucketAcl(bucketName, CannedAccessControlList.PublicRead);
ossClient.PutObject(bucketName, objectName, new MemoryStream(fontfile));
var expiration = DateTime.Now.AddDays(150);
var fontfileUrl = ossClient.GeneratePresignedUri(bucketName, objectName, expiration);
var fontfileString = fontfileUrl.ToString().Substring(0, fontfileUrl.ToString().IndexOf("?"));
Console.WriteLine("fontfileString: " + fontfileString);
return(fontfileString);
}
else
{
throw new OssException("bucket [" + bucketName + "] is not exist!");
}
}
catch (OssException oe)
{
Console.WriteLine("Caught an OSSException, which means your request made it to OSS, but was rejected with an error response for some reason.");
Console.WriteLine("Error Message: " + oe.Message);
Console.WriteLine("Error Code: " + oe.ErrorCode);
Console.WriteLine("Request ID: " + oe.RequestId);
Console.WriteLine("Host ID: " + oe.HostId);
throw oe;
}
catch (ClientException ce)
{
Console.WriteLine("Caught an ClientException, which means the client encountered a serious internal problem while trying to communicate with OSS, " +
"such as not being able to access the network.");
Console.WriteLine(ce.StackTrace);
throw ce;
}
}
public bool DoesBucketExist(string bucketName, ref string msg)
{
try
{
var exist = _ossClient.DoesBucketExist(bucketName);
return(exist);
}
catch (OssException ex)
{
msg = ex.Message;
_logger.LogError("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
}
catch (Exception ex)
{
msg = ex.Message;
_logger.LogError("Failed with error info: {0}", ex.Message);
}
return(false);
}
public void DoesBucketExistTestWithException()
{
try
{
_ossClient.DoesBucketExist("");
Assert.IsTrue(false);
}
catch (Exception e)
{
Assert.True(true, e.Message);
}
try
{
_ossClient.DoesBucketExist("Invalid-Bucket");
Assert.IsTrue(false);
}
catch (Exception e)
{
Assert.True(true, e.Message);
}
var bucketName1 = OssTestUtils.GetBucketName(_className);
try
{
var client = new OssClient(Config.Endpoint, Config.AccessKeyId, "invalid-sk");
_ossClient.CreateBucket(bucketName1, StorageClass.IA);
client.DoesBucketExist(bucketName1);
Assert.IsTrue(false);
}
catch (Exception e)
{
Assert.True(true, e.Message);
}
finally
{
_ossClient.DeleteBucket(bucketName1);
}
}
private static OssClient CreateOssClientOfIOS()
{
if (_ossClient == null)
{
string accessKeyId = "3JkljJxvXgjLz80X";
string accessKeySecret = "L2ERHORPk3WkjqfGUb27RlxvT8x5f3";
string endpoint = "oss-cn-beijing.aliyuncs.com";
//var conf = new ClientConfiguration();
////conf.IsCname = true;/// 配置使用Cname
////conf.ConnectionLimit = 512; //HttpWebRequest最大的并发连接数目
//conf.MaxErrorRetry = 3; //设置请求发生错误时最大的重试次数
//conf.ConnectionTimeout = 300; //设置连接超时时间
////conf.SetCustomEpochTicks(customEpochTicks); //设置自定义基准时间, CreateCancelTokenSource().Token.ToString()
_ossClient = new OssClient(endpoint, accessKeyId, accessKeySecret);
var exist = _ossClient.DoesBucketExist("vgic");
if (!exist)
{
_ossClient.CreateBucket("vgic");
}
}
return(_ossClient);
}
public static void DoesBucketExist(string bucketName)
{
const string accessId = "<your access id>";
const string accessKey = "<your access key>";
const string endpoint = "<valid host name>";
var client = new OssClient(endpoint, accessId, accessKey);
try
{
var exist = client.DoesBucketExist(bucketName);
Console.WriteLine("exist ? " + exist);
}
catch (OssException ex)
{
Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
}
catch (Exception ex)
{
Console.WriteLine("Failed with error info: {0}", ex.Message);
}
}
public static void DoesBucketExist(string bucketName)
{
const string accessKeyId = "<your access key id>";
const string accessKeySecret = "<your access key secret>";
const string endpoint = "<valid host name>";
var client = new OssClient(endpoint, accessKeyId, accessKeySecret);
try
{
var exist = client.DoesBucketExist(bucketName);
Console.WriteLine("exist ? " + exist);
}
catch (OssException ex)
{
Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
}
catch (Exception ex)
{
Console.WriteLine("Failed with error info: {0}", ex.Message);
}
}
/// <summary>
/// 将文件上传到oss
/// </summary>
/// <param name="fileStream">文件流</param>
/// <param name="filename">文件路径</param>
/// <returns></returns>
public string PutObject(Stream fileStream, string DownloadPath)
{
try
{
DownloadPath = DownloadPath.Replace("\\", "/");
meta.CacheControl = "no-cache";
meta.ContentEncoding = "utf-8";
meta.ContentLength = fileStream.Length;
if (!client.DoesBucketExist(bucketName))
{
CreateBucket(bucketName);
}
meta.ContentType = ContentType(Path.GetExtension(DownloadPath).Substring(1));
//var result = client.PutObject("wangjie-img-hz", imgname, imgStream, meta);
var result = client.PutObject(bucketName, DownloadPath, fileStream, meta);
return(result.HttpStatusCode.ToString());
}
catch (Exception e)
{
return(e.Message);
}
}
/// <summary>
/// 保存对象到指定的容器
/// </summary>
/// <param name="containerName"></param>
/// <param name="blobName"></param>
/// <param name="source"></param>
public async Task SaveBlobStream(string containerName, string blobName, Stream source)
{
try
{
await Task.Run(() =>
{
var exist = _ossClient.DoesBucketExist(containerName);
if (!exist)
{
_ossClient.CreateBucket(containerName);
}
var md5 = OssUtils.ComputeContentMd5(source, source.Length);
var objectMeta = new ObjectMetadata();
objectMeta.AddHeader("Content-MD5", md5);
objectMeta.UserMetadata.Add("Content-MD5", md5);
_ossClient.PutObject(containerName, blobName, source, objectMeta);
});
}
catch (Exception ex)
{
throw new StorageException(StorageErrorCode.PostError.ToStorageError(),
new Exception(ex.ToString()));
}
}
/// <summary>
/// 上传文件到Oss
/// </summary>
/// <param name="bucketName">bucket名</param>
/// <param name="dir">文件夹</param>
/// <param name="userId">用户ID</param>
/// <param name="fileType">文件类型</param>
/// <param name="relPath">服务器相对路径</param>
/// <param name="physicalPath">服务器物理路径</param>
/// <param name="ossPoint">站点</param>
/// <param name="accessId">accessId</param>
/// <param name="accessKey">accessKey</param>
/// <returns></returns>
public static string UploadFile(string bucketName, string dir, string userId, string fileType, string relPath, string physicalPath = "")
{
if (string.IsNullOrWhiteSpace(bucketName))
{
throw new Exception("Bucket名称为空");
}
if (string.IsNullOrWhiteSpace(userId))
{
throw new Exception("userId为空");
}
if (string.IsNullOrWhiteSpace(fileType))
{
throw new Exception("fileType为空");
}
// if (file == null || string.IsNullOrWhiteSpace(file.FileName)) throw new Exception("请选择文件");
//建立Oss客户端连接
OssClient client = ConnOssClient();
if (!client.DoesBucketExist(bucketName))
{
throw new Exception("Bucket还没有建立");
}
FileStream file;
string fileExtension;
if (!string.IsNullOrEmpty(physicalPath))
{
fileExtension = Path.GetExtension(physicalPath).ToLower();
file = System.IO.File.OpenRead(physicalPath);
}
else
{
fileExtension = Path.GetExtension(relPath).ToLower();
file = System.IO.File.OpenRead(HttpContext.Current.Server.MapPath(relPath));
}
//string fileName = file.FileName;
//文件保存Key生成
string Key = dir + "/" + userId + "/" + fileType + "/" + DateTime.Now.ToString("yyyyMMdd") + "/" + Guid.NewGuid().ToString("N").ToUpper() + fileExtension;
//设置缓存
ObjectMetadata Metadata = new ObjectMetadata();
//Metadata.CacheControl = "Private";
Metadata.CacheControl = string.Format("max-age={0}", 157680000);
//Metadata.AddHeader("Expires", DateTime.MaxValue.GetDateTimeFormats('r')[0]);
//Metadata.AddHeader("Expires", 2628000);
Metadata.AddHeader("Content-Type", FileContentTypeHelper.GetMimeType(fileExtension));
//using (StreamWriter sw = new StreamWriter(@"C:\MonitorHandlerException.txt", true, Encoding.UTF8))
//{
// sw.WriteLine(string.Format("{0} 上传ossKey：{1}bucketName:{2} FileLeng{3}", DateTime.Now.ToString(), Key,bucketName,file.Length));
//}
//上传文件到Oss
PutObjectResult putResult = client.PutObject(bucketName, Key, file, Metadata);
return(GetDomain() + "/" + Key);
}
