• 消息队列、OSS常用操作封装


     public class MessageQueue
        {
            #region Private Properties
            private const string _accessKeyId = "";
            private const string _secretAccessKey = "";
            private const string _endpoint = "";
    
            private static string _queueName;
            private const int _receiveTimes = 1;
            private const int _receiveInterval = 2;
            private const int batchSize = 6;
    
            #endregion
    
            #region 设置队列名称
            public string queueName
            {
                set
                {
                    _queueName = value;
    
                }
                get
                {
                    return _queueName;
                }
            }
            #endregion
    
            #region 判断消息队列是否存在
            /// <summary>
            /// 判断消息队列是否存在
            /// </summary>
            /// <returns></returns>
            public static bool QueueIsExist()
            {
                bool flag = false;
                try
                {
                    using (IMNS client = new Aliyun.MNS.MNSClient(_accessKeyId, _secretAccessKey, _endpoint))
                    {
                        var nativeQueue = client.GetNativeQueue(_queueName);
                        var getQueueAttributesResponse = nativeQueue.GetAttributes();
                        flag = true;
                    }
                }
                catch (Exception ex) { Console.WriteLine(ex.ToString()); }
                return flag;
            }
            #endregion
    
            #region 创建消息队列
            /// <summary>
            /// 创建消息队列
            /// </summary>
            /// <returns></returns>
            public static string CreateQueue()
            {
                /*
                    DelaySeconds	发送到该 Queue 的所有消息默认将以DelaySeconds参数指定的秒数延后可被消费,单位为秒。	0-604800秒(7天)范围内某个整数值,默认值为0
                    MaximumMessageSize	发送到该Queue的消息体的最大长度,单位为byte。	1024(1KB)-65536(64KB)范围内的某个整数值,默认值为65536(64KB)。
                    MessageRetentionPeriod	消息在该 Queue 中最长的存活时间,从发送到该队列开始经过此参数指定的时间后,不论消息是否被取出过都将被删除,单位为秒。	60 (1分钟)-1296000 (15 天)范围内某个整数值,默认值345600 (4 天)
                    VisibilityTimeout	消息从该 Queue 中取出后从Active状态变成Inactive状态后的持续时间,单位为秒。	1-43200(12小时)范围内的某个值整数值,默认为30(秒)
                    PollingWaitSeconds	当 Queue 中没有消息时,针对该 Queue 的 ReceiveMessage 请求最长的等待时间,单位为秒。	0-30秒范围内的某个整数值,默认为0(秒)
                    LoggingEnabled	是否开启日志管理功能,True表示启用,False表示停用	True/False,默认为False             
                 */
                string queueName = string.Empty;
                var createQueueRequest = new CreateQueueRequest
                {
                    QueueName = _queueName,
                    Attributes =
                    {
                        DelaySeconds = 0,
                        MaximumMessageSize = 65536,
                        MessageRetentionPeriod = 345600,
                        VisibilityTimeout = 3600,
                        PollingWaitSeconds = 3
                    }
                };
                try
                {
                    using (IMNS client = new Aliyun.MNS.MNSClient(_accessKeyId, _secretAccessKey, _endpoint))
                    {
                        var queue = client.CreateQueue(createQueueRequest);
                        queueName = queue.QueueName;
                    }
                }
                catch (Exception ex) { Console.WriteLine(ex.ToString()); }
                Thread.Sleep(2000);
                return queueName;
            }
            #endregion
    
            #region 删除消息队列
            /// <summary>
            /// 删除消息队列
            /// </summary>
            /// <returns></returns>
            public static bool DeleteQueue()
            {
                bool flag = false;
                var deleteQueueRequest = new DeleteQueueRequest(_queueName);
                deleteQueueRequest.AddHeader("Accept", "IE6"); //Add extra request headers
                //deleteQueueRequest.AddParameter("param1", "value1"); //InvalidQueryString
                try
                {
                    using (IMNS client = new Aliyun.MNS.MNSClient(_accessKeyId, _secretAccessKey, _endpoint))
                    {
                        var deleteQueueResponse = client.DeleteQueue(deleteQueueRequest);
                        flag = true;
                    }
                }
                catch (Exception ex) { Console.WriteLine(ex.ToString()); }
                return flag;
            }
            #endregion
    
            #region 发送消息(单条或多条)
            /// <summary>
            /// 发送消息(单条或多条)
            /// </summary>
            /// <param name="models">SendMessageRequest集合</param>
            /// <returns></returns>
            public static bool BathSendMessage(List<SendMessageRequest> models)
            {
                bool flag = false;
                try
                {
                    using (IMNS client = new Aliyun.MNS.MNSClient(_accessKeyId, _secretAccessKey, _endpoint))
                    {
                        var nativeQueue = client.GetNativeQueue(_queueName);
                        List<SendMessageRequest> requests = new List<SendMessageRequest>();
                        for (int i = 0; i < models.Count; i++)
                        {
                            requests.Add(models[i]);
                        }
                        BatchSendMessageRequest batchSendRequest = new BatchSendMessageRequest()
                        {
                            Requests = requests
                        };
                        var sendMessageResponse = nativeQueue.BatchSendMessage(batchSendRequest);
                        flag = true;
                    }
                }
                catch (Exception ex) { Console.WriteLine(ex.ToString()); }
                return flag;
            }
            #endregion
    
            #region 消费消息(单条或多条)
            /// <summary>
            /// 消费消息(单条或多条)
            /// </summary>
            /// <param name="itemNum">数目</param>
            /// <returns></returns>
            public static List<Message> ReceiveMessage(int itemNum)
            {
                List<Message> lists = new List<Message>();
                try
                {
                    using (IMNS client = new Aliyun.MNS.MNSClient(_accessKeyId, _secretAccessKey, _endpoint))
                    {
                        var nativeQueue = client.GetNativeQueue(_queueName);
                        for (int i = 0; i < itemNum; i++)
                        {
                            var receiveMessageResponse = nativeQueue.ReceiveMessage();
                            Message message = receiveMessageResponse.Message;
                            lists.Add(message);
                        }
                    }
                }
                catch (Exception ex) { Console.WriteLine(ex.ToString()); }
                return lists;
            }
            #endregion
    
            #region 删除消息
            /// <summary>
            /// 删除消息
            /// </summary>
            /// <param name="receiptHandle">receiptHandle</param>
            /// <returns></returns>
            public static bool DeleteMessage(string receiptHandle)
            {
                bool flag = false;
                var deletedReceiptHandle = receiptHandle;
                try
                {
                    using (IMNS client = new Aliyun.MNS.MNSClient(_accessKeyId, _secretAccessKey, _endpoint))
                    {
                        var nativeQueue = client.GetNativeQueue(_queueName);
                        var deleteMessageResponse = nativeQueue.DeleteMessage(receiptHandle);
                        flag = true;
                    }
                }
                catch (Exception ex) { Console.WriteLine(ex.ToString()); }
                return flag;
            }
            #endregion
    
            #region 修改消息可见时间
            /// <summary>
            /// 修改消息可见时间
            /// </summary>
            /// <param name="receiptHandle">receiptHandle</param>
            /// <param name="visibilityTimeout">从现在到下次可被用来消费的时间间隔</param>
            /// <returns></returns>
            public static bool ChangeMessageVisibility(string receiptHandle, int visibilityTimeout)
            {
                bool flag = false;
                var deletedReceiptHandle = receiptHandle;
                try
                {
                    using (IMNS client = new Aliyun.MNS.MNSClient(_accessKeyId, _secretAccessKey, _endpoint))
                    {
                        var nativeQueue = client.GetNativeQueue(_queueName);
                        var changeMessageVisibilityRequest = new ChangeMessageVisibilityRequest
                        {
                            ReceiptHandle = receiptHandle,
                            VisibilityTimeout = visibilityTimeout
                        };
                        var changeMessageVisibilityResponse = nativeQueue.ChangeMessageVisibility(changeMessageVisibilityRequest);
                        flag = true;
                    }
                }
                catch (Exception ex) { Console.WriteLine(ex.ToString()); }
                return flag;
            }
            #endregion
        }
    using System;
    using System.IO;
    using System.Text;
    using System.Threading;
    using System.Security.Cryptography;
    using Aliyun.OSS.Common;
    
    namespace Aliyun.OSS.Samples
    {
        /// <summary>
        /// 获取OSS对象
        /// </summary>
       public static class GetObjectSample
       {
           static string accessKeyId = Config.AccessKeyId;
           static string accessKeySecret = Config.AccessKeySecret;
           static string endpoint = Config.Endpoint;
           static OssClient client = new OssClient(endpoint, accessKeyId, accessKeySecret);
    
           static string key = "123456.jpg";
           static string fileToUpload = Config.FileToUpload;
           static string dirToDownload = Config.DirToDownload;
    
           static AutoResetEvent _event = new AutoResetEvent(false);
    
           public static void GetObjects(string bucketName)
           {
               GetObject(bucketName); //获取文件
    
               GetObjectByRequest(bucketName);
    
               AsyncGetObject(bucketName); //异步方式获取文件
           }
    
           public static void GetObject(string bucketName)
           {
               try
               {
                   client.PutObject(bucketName, key, fileToUpload);
    
                   var result = client.GetObject(bucketName, key);
    
                   using (var requestStream = result.Content)
                   {
                       using (var fs = File.Open(Path.Combine(dirToDownload, key), FileMode.OpenOrCreate))
                       {
                           int length = 4 * 1024;
                           var buf = new byte[length];
                           do
                           {
                               length = requestStream.Read(buf, 0, length);
                               fs.Write(buf, 0, length);
                           } while (length != 0);
                       }
                   }
    
                   Console.WriteLine("Get object succeeded");
               }
               catch (OssException ex)
               {
                    Console.WriteLine("Failed with error code: {0}; Error info: {1}. 
    RequestID:{2}	HostID:{3}", 
                        ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
               }
               catch (Exception ex)
               {
                    Console.WriteLine("Failed with error info: {0}", ex.Message);
               }
            }
    
           public static void GetObjectByRequest(string bucketName)
           {
               try
               {
                   client.PutObject(bucketName, key, fileToUpload);
    
                   var request = new GetObjectRequest(bucketName, key);
                   request.SetRange(0, 100);
    
                   var result = client.GetObject(request);
    
                   Console.WriteLine("Get object succeeded, length:{0}", result.Metadata.ContentLength);
               }
               catch (OssException ex)
               {
                   Console.WriteLine("Failed with error code: {0}; Error info: {1}. 
    RequestID:{2}	HostID:{3}",
                       ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
               }
               catch (Exception ex)
               {
                   Console.WriteLine("Failed with error info: {0}", ex.Message);
               }
           }
    
           public static void AsyncGetObject(string bucketName)
           {
               const string key = "AsyncGetObject";
               try
               {
                   client.PutObject(bucketName, key, fileToUpload);
    
                   string result = "Notice user: put object finish";
                   client.BeginGetObject(bucketName, key, GetObjectCallback, result.Clone());
    
                   _event.WaitOne();
               }
               catch (OssException ex)
               {
                   Console.WriteLine("Failed with error code: {0}; Error info: {1}. 
    RequestID:{2}	HostID:{3}",
                       ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
               }
               catch (Exception ex)
               {
                   Console.WriteLine("Failed with error info: {0}", ex.Message);
               }
           }
    
           private static void GetObjectCallback(IAsyncResult ar)
           {
               try
               {
                   var result = client.EndGetObject(ar);
    
                   using (var requestStream = result.Content)
                   {
                       using (var fs = File.Open(dirToDownload + "/sample2.data", FileMode.OpenOrCreate))
                       {
                           int length = 4 * 1024;
                           var buf = new byte[length];
                           do
                           {
                               length = requestStream.Read(buf, 0, length);
                               fs.Write(buf, 0, length);
                           } while (length != 0);
                       }
                   }
    
                   Console.WriteLine(ar.AsyncState as string);
               }
               catch (Exception ex)
               {
                   Console.WriteLine(ex.Message);
               }
               finally
               {
                   _event.Set();
               }
           }
        }
    }
    using System;
    using System.Collections.Generic;
    using Aliyun.OSS.Common;
    
    namespace Aliyun.OSS.Samples
    {
        /// <summary>
        /// 删除OSS对象
        /// </summary>
        public static class DeleteObjectsSample
        {
            static string accessKeyId = Config.AccessKeyId;
            static string accessKeySecret = Config.AccessKeySecret;
            static string endpoint = Config.Endpoint;
            static OssClient client = new OssClient(endpoint, accessKeyId, accessKeySecret);
    
            public static void DeleteObject(string bucketName)
            {
                try
                {
                    string key = null;
                    var listResult = client.ListObjects(bucketName);
                    foreach (var summary in listResult.ObjectSummaries)
                    {
                        key = summary.Key;
                        break;
                    }
    
                    client.DeleteObject(bucketName, key);
    
                    Console.WriteLine("Delete object succeeded");
                }
                catch (OssException ex)
                {
                    Console.WriteLine("Failed with error code: {0}; Error info: {1}. 
    RequestID:{2}	HostID:{3}",
                        ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Failed with error info: {0}", ex.Message);
                }
            }
    
            public static void DeleteObjects(string bucketName)
            {
                try
                {
                    var keys = new List<string>();
                    var listResult = client.ListObjects(bucketName);
                    foreach (var summary in listResult.ObjectSummaries)
                    {
                        keys.Add(summary.Key);
                        break; //不跳出删除全部
                    }
                    var request = new DeleteObjectsRequest(bucketName, keys, false);
                    client.DeleteObjects(request);
    
                    Console.WriteLine("Delete objects succeeded");
                }
                catch (OssException ex)
                {
                    Console.WriteLine("Failed with error code: {0}; Error info: {1}. 
    RequestID:{2}	HostID:{3}", 
                        ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Failed with error info: {0}", ex.Message);
                }
            }
        }
    }
    
    using System;
    using System.IO;
    using System.Threading;
    using Aliyun.OSS.Common;
    using System.Text;
    using Aliyun.OSS.Util;
    
    namespace Aliyun.OSS.Samples
    {
        /// <summary>
        /// 上传文件或对象到OSS
        /// </summary>
        public static class PutObjectSample
        {
            static string accessKeyId = Config.AccessKeyId;
            static string accessKeySecret = Config.AccessKeySecret;
            static string endpoint = Config.Endpoint;
            static OssClient client = new OssClient(endpoint, accessKeyId, accessKeySecret);
    
            static string fileToUpload = Config.FileToUpload;
    
            static AutoResetEvent _event = new AutoResetEvent(false);
    
            /// <summary>
            /// sample for put object to oss
            /// </summary>
            public static void PutObject(string bucketName)
            {
                PutObjectFromFile(bucketName); //上传文件
    
                PutObjectFromString(bucketName); //上传String
    
                PutObjectWithDir(bucketName); //创建目录上传
    
                PutObjectWithMd5(bucketName); //MD5验证上传
    
                PutObjectWithHeader(bucketName); //设置Header上传
    
                AsyncPutObject(bucketName); //异步上传
            }
    
            public static void PutObjectFromFile(string bucketName)
            {
                const string key = "PutObjectFromFile";
                try
                {
                    client.PutObject(bucketName, key, fileToUpload);
                    Console.WriteLine("Put object:{0} succeeded", key);
                }
                catch (OssException ex)
                {
                    Console.WriteLine("Failed with error code: {0}; Error info: {1}. 
    RequestID:{2}	HostID:{3}",
                        ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Failed with error info: {0}", ex.Message);
                }
            }
    
            public static void PutObjectFromString(string bucketName)
            {
                const string key = "PutObjectFromString";
                const string str = "Aliyun OSS SDK for C#";
    
                try
                {
                    byte[] binaryData = Encoding.ASCII.GetBytes(str); 
                    var stream = new MemoryStream(binaryData);
                    
                    client.PutObject(bucketName, key, stream);
                    Console.WriteLine("Put object:{0} succeeded", key);
                }
                catch (OssException ex)
                {
                    Console.WriteLine("Failed with error code: {0}; Error info: {1}. 
    RequestID:{2}	HostID:{3}",
                        ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Failed with error info: {0}", ex.Message);
                }
            }
    
            public static void PutObjectWithDir(string bucketName)
            {
                const string key = "folder/sub_folder/PutObjectFromFile";
    
                try
                {
                    client.PutObject(bucketName, key, fileToUpload);
                    Console.WriteLine("Put object:{0} succeeded", key);
                }
                catch (OssException ex)
                {
                    Console.WriteLine("Failed with error code: {0}; Error info: {1}. 
    RequestID:{2}	HostID:{3}",
                        ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Failed with error info: {0}", ex.Message);
                }
            }
    
            public static void PutObjectWithMd5(string bucketName)
            {
                const string key = "PutObjectWithMd5";
    
                string md5;
                using (var fs = File.Open(fileToUpload, FileMode.Open))
                {
                    md5 = OssUtils.ComputeContentMd5(fs, fs.Length);
                }
    
                var meta = new ObjectMetadata() { ContentMd5 = md5 };
                try
                {
                    client.PutObject(bucketName, key, fileToUpload, meta);
    
                    Console.WriteLine("Put object:{0} succeeded", key);
                }
                catch (OssException ex)
                {
                    Console.WriteLine("Failed with error code: {0}; Error info: {1}. 
    RequestID:{2}	HostID:{3}",
                        ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Failed with error info: {0}", ex.Message);
                }
            }
    
            public static void PutObjectWithHeader(string bucketName)
            {
                const string key = "PutObjectWithHeader";
                try
                {
                    using (var content = File.Open(fileToUpload, FileMode.Open))
                    {
                        var metadata = new ObjectMetadata();                    
                        metadata.ContentLength = content.Length;
    
                        metadata.UserMetadata.Add("github-account", "qiyuewuyi");
    
                        client.PutObject(bucketName, key, content, metadata);
    
                        Console.WriteLine("Put object:{0} succeeded", key);
                    }
                }
                catch (OssException ex)
                {
                    Console.WriteLine("Failed with error code: {0}; Error info: {1}. 
    RequestID:{2}	HostID:{3}",
                        ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Failed with error info: {0}", ex.Message);
                }
            }
    
            public static void AsyncPutObject(string bucketName)
            {
                const string key = "AsyncPutObject";
                try
                {
                    // 1. put object to specified output stream
                    using (var fs = File.Open(fileToUpload, FileMode.Open))
                    {
                        var metadata = new ObjectMetadata();
                        metadata.UserMetadata.Add("mykey1", "myval1");
                        metadata.UserMetadata.Add("mykey2", "myval2");
                        metadata.CacheControl = "No-Cache";
                        metadata.ContentType = "text/html";
    
                        string result = "Notice user: put object finish";
                        client.BeginPutObject(bucketName, key, fs, metadata, PutObjectCallback, result.ToCharArray());
    
                        _event.WaitOne();
                    }
                }
                catch (OssException ex)
                {
                    Console.WriteLine("Failed with error code: {0}; Error info: {1}. 
    RequestID:{2}	HostID:{3}",
                        ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Failed with error info: {0}", ex.Message);
                }
            }
    
            private static void PutObjectCallback(IAsyncResult ar)
            {
                try
                {
                    client.EndPutObject(ar);
    
                    Console.WriteLine(ar.AsyncState as string);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
                finally
                {
                    _event.Set();
                }
            }
        }
    }

  • 相关阅读:
    绝对均匀图生成算法
    告别S! S! H! 秒杀终端工具——FastLogin快捷登录
    使用Atom打造无懈可击的Markdown编辑器
    程序异常分析指南
    javascript opacity兼容性随笔
    javascript event兼容性随笔
    javascript Xml兼容性随笔
    addEventListener、attachEvent、cancelBubble兼容性随笔
    算法--逆波兰表达式(数学逆波兰表达式和交并集逆波兰表达式)
    算法--区间数据计算
  • 原文地址:https://www.cnblogs.com/smartsmile/p/6234052.html
Copyright © 2020-2023  润新知