//在某产品下申请创建一批设备
private static void TestApplyDeviceWithNames()
{
IClientProfile clientProfile = DefaultProfile.GetProfile("<your-region-id>", "<your-access-key-id>", "<your-access-key-secret>");
DefaultAcsClient client = new DefaultAcsClient(clientProfile);
ApplyDeviceWithNamesRequest request = new ApplyDeviceWithNamesRequest();
request.ProductKey = "<productKey>";
List <String> DeviceNames = new List <string>();
for (int i = 1; i < 20; i++)
{
if (i < 10)
{
DeviceNames.Add("device_20171206_00" + i);
}
else
{
DeviceNames.Add("device_20171206_0" + i);
}
}
request.DeviceNames = DeviceNames;
try
{
ApplyDeviceWithNamesResponse response = client.GetAcsResponse(request);
Console.WriteLine(response.Success);
Console.WriteLine(response.ErrorMessage);
Console.WriteLine("apply id: " + response.ApplyId);
}
catch (ServerException e)
{
Console.WriteLine(e.ErrorCode);
Console.WriteLine(e.ErrorMessage);
}
catch (ClientException e)
{
Console.WriteLine(e.ErrorCode);
Console.WriteLine(e.ErrorMessage);
}
Console.ReadKey();
}
static void Main(string[] args)
{
IClientProfile profile = DefaultProfile.GetProfile("cn-hangzhou", "<accessKeyId>", "<secret>");
DefaultAcsClient client = new DefaultAcsClient(profile);
CommonRequest request = new CommonRequest();
request.Method = MethodType.POST;
request.Domain = "dysmsapi.aliyuncs.com";
request.Version = "2017-05-25";
request.Action = "SendSms";
// request.Protocol = ProtocolType.HTTP
// 随机生成6位验证码
var rd = new Random();
var code = new
{
code = rd.Next(100000, 999999)
};
request.AddQueryParameters("PhoneNumbers", "18173608896");
request.AddQueryParameters("SignName", "jonty博客");
request.AddQueryParameters("TemplateCode", "SMS_197465032");
// 验证码参数，code 转json格式
request.AddBodyParameters("TemplateParam", code.ToJson());
try
{
CommonResponse response = client.GetCommonResponse(request);
Console.WriteLine(System.Text.Encoding.Default.GetString(response.HttpResponse.Content));
}
catch (ServerException e)
{
Console.WriteLine(e);
}
catch (ClientException e)
{
Console.WriteLine(e);
}
}
/// <summary>
/// 发送邮件
/// </summary>
/// <param name="PhoneNumbers">电话号码</param>
/// <param name="code">验证码</param>
public SendSmsResponse SendResetEmail(string PhoneNumbers, string code)
{
String product = "Dysmsapi"; //短信API产品名称
String domain = "dysmsapi.aliyuncs.com"; //短信API产品域名
String accessKeyId = AliyunVariable.AliyunAccessKeyId; //你的accessKeyId
String accessKeySecret = AliyunVariable.AliyunAccessKeySecret; //你的accessKeySecret
IClientProfile profile = DefaultProfile.GetProfile("cn-hangzhou", accessKeyId, accessKeySecret);
DefaultProfile.AddEndpoint("cn-hangzhou", "cn-hangzhou", product, domain);
IAcsClient acsClient = new DefaultAcsClient(profile);
SendSmsRequest request = new SendSmsRequest();
try
{
//必填:待发送手机号。支持以逗号分隔的形式进行批量调用，批量上限为20个手机号码,批量调用相对于单条调用及时性稍有延迟,验证码类型的短信推荐使用单条调用的方式
request.PhoneNumbers = PhoneNumbers;
//必填:短信签名-可在短信控制台中找到
request.SignName = AliyunVariable.AliyunSignName;
//必填:短信模板-可在短信控制台中找到
request.TemplateCode = Enum_SendEmailCode.AuthenticationCode.Enum_GetString();
//可选:模板中的变量替换JSON串,如模板内容为"亲爱的${name},您的验证码为${code}"时,此处的值为
request.TemplateParam = new ModifyPasswordAuthentication(code).GetString();
//可选:outId为提供给业务方扩展字段,最终在短信回执消息中将此值带回给调用者
request.OutId = "21212121211";
//请求失败这里会抛ClientException异常
SendSmsResponse sendSmsResponse = acsClient.GetAcsResponse(request);
return(sendSmsResponse);
}
catch (ServerException e)
{
Console.WriteLine(e.ErrorCode);
Console.WriteLine(e.ErrorMessage);
throw e;
}
catch (ClientException e)
{
Console.WriteLine(e.ErrorCode);
Console.WriteLine(e.ErrorMessage);
throw e;
}
}
public static SendBatchSmsResponse sendSms()
{
IClientProfile profile = DefaultProfile.GetProfile("cn-hangzhou", accessKeyId, accessKeySecret);
DefaultProfile.AddEndpoint("cn-hangzhou", "cn-hangzhou", product, domain);
IAcsClient acsClient = new DefaultAcsClient(profile);
SendBatchSmsRequest request = new SendBatchSmsRequest();
//request.Protocol = ProtocolType.HTTPS;
//request.TimeoutInMilliSeconds = 1;
SendBatchSmsResponse response = null;
try
{
//必填:待发送手机号。支持JSON格式的批量调用，批量上限为100个手机号码,批量调用相对于单条调用及时性稍有延迟,验证码类型的短信推荐使用单条调用的方式
request.PhoneNumberJson = "[\"1500000000\",\"1500000001\"]";
//必填:短信签名-支持不同的号码发送不同的短信签名
request.SignNameJson = "[\"云通信\",\"云通信\"]";
//必填:短信模板-可在短信控制台中找到
request.TemplateCode = "SMS_1000000";
//必填:模板中的变量替换JSON串,如模板内容为"亲爱的${name},您的验证码为${code}"时,此处的值为
//友情提示:如果JSON中需要带换行符,请参照标准的JSON协议对换行符的要求,比如短信内容中包含\r\n的情况在JSON中需要表示成\\r\\n,否则会导致JSON在服务端解析失败
request.TemplateParamJson = "[{\"name\":\"Tom\", \"code\":\"123\"},{\"name\":\"Jack\", \"code\":\"456\"}]";
//可选-上行短信扩展码(扩展码字段控制在7位或以下，无特殊需求用户请忽略此字段)
//request.SmsUpExtendCodeJson = "[\"90997\",\"90998\"]";
//请求失败这里会抛ClientException异常
response = acsClient.GetAcsResponse(request);
}
catch (ServerException e)
{
Console.Write(e.ErrorCode);
}
catch (ClientException e)
{
Console.Write(e.ErrorCode);
Console.Write(e.Message);
}
return(response);
}
public async Task <SendSmsResponse> SendSmsAsync(SendSmsRequest request)
{
var verifiedCode = new Random().Next(100000, 999999).ToString();
string product = "Dysmsapi"; //短信API产品名称（短信产品名固定，无需修改）
string domain = "dysmsapi.aliyuncs.com"; //短信API产品域名（接口地址固定，无需修改）
string accessKeyId = ""; //你的accessKeyId，此处需要替换成开发者自己的AK(在阿里云访问控制台寻找)
string accessKeySecret = ""; //你的accessKeySecret，此处需要替换成开发者自己的AK(在阿里云访问控制台寻找)
IClientProfile profile = DefaultProfile.GetProfile("cn-hangzhou", accessKeyId, accessKeySecret);
DefaultProfile.AddEndpoint("cn-hangzhou", "cn-hangzhou", product, domain);
IAcsClient acsClient = new DefaultAcsClient(profile);
SendSmsResponse response = null;
await Task.Run(() =>
{
try
{
//必填:待发送手机号。支持以逗号分隔的形式进行批量调用，批量上限为1000个手机号码,批量调用相对于单条调用及时性稍有延迟,验证码类型的短信推荐使用单条调用的方式，发送国际/港澳台消息时，接收号码格式为00+国际区号+号码，如“0085200000000”
request.PhoneNumbers = "18771506573";
//必填:短信签名-可在短信控制台中找到
request.SignName = "凡迹网";
//必填:短信模板-可在短信控制台中找到，发送国际/港澳台消息时，请使用国际/港澳台短信模版
request.TemplateCode = "SMS_107090067";
//可选:模板中的变量替换JSON串,如模板内容为"亲爱的${name},您的验证码为${code}"时,此处的值为
request.TemplateParam = "{\"code\":\"dalao\"}";
//可选:outId为提供给业务方扩展字段,最终在短信回执消息中将此值带回给调用者
request.OutId = "yourOutId";
//请求失败这里会抛ClientException异常
response = acsClient.GetAcsResponse(request);
}
catch (ServerException e)
{
throw e;
}
catch (ClientException e)
{
throw e;
}
});
return(response);
}
static void Main()
{
IClientProfile clientProfile = DefaultProfile.GetProfile("cn-hangzhou", "<your access key id>", "<your access key secret>");
DefaultAcsClient client = new DefaultAcsClient(clientProfile);
QueryDeviceStatRequest request = new QueryDeviceStatRequest();
request.AppKey = < Your AppKey >;
request.QueryType = "TOTAL"; ////NEW: 新增设备查询, TOTAL: 留存设备查询
request.DeviceType = "ALL"; //iOS,ANDROID,ALL
String startTime = DateTime.UtcNow.AddDays(-7).ToString("yyyy-MM-ddTHH\\:mm\\:ssZ"); //查询近7天的数据
String endTime = DateTime.UtcNow.ToString("yyyy-MM-ddTHH\\:mm\\:ssZ");
request.StartTime = startTime;
request.EndTime = endTime;
try
{
QueryDeviceStatResponse response = client.GetAcsResponse(request);
Console.WriteLine("RequestId:" + response.RequestId);
foreach (QueryDeviceStatResponse.AppDeviceStat stat in response.AppDeviceStats)
{
Console.WriteLine("time:" + stat.Time);
Console.WriteLine("DeviceType:" + stat.DeviceType);
Console.WriteLine("count:" + stat.Count);
}
Console.ReadLine();
}
catch (ServerException e)
{
Console.WriteLine(e.ErrorCode);
Console.WriteLine(e.ErrorMessage);
Console.ReadLine();
}
catch (ClientException e)
{
Console.WriteLine(e.ErrorCode);
Console.WriteLine(e.ErrorMessage);
Console.ReadLine();
}
}
public void Send(string phoneNumber, string code)
{
IClientProfile profile = DefaultProfile.GetProfile("cn-hangzhou", _config.Value.AccessKeyId, string.Empty);
DefaultAcsClient client = new DefaultAcsClient(profile);
CommonRequest request = new CommonRequest();
request.Method = MethodType.POST;
request.Domain = _config.Value.Domain;
request.Version = "2017-05-25";
request.Action = "SendSms";
request.Protocol = ProtocolType.HTTP;
request.AddQueryParameters("PhoneNumbers", phoneNumber);
request.AddQueryParameters("SignName", _config.Value.SignName);
request.AddQueryParameters("TemplateCode", _config.Value.TemplateCode);
request.AddQueryParameters("TemplateParam", JsonConvert.SerializeObject(new MessageContent {
Code = code
}, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
}));
CommonResponse response = client.GetCommonResponse(request);
Console.WriteLine(System.Text.Encoding.Default.GetString(response.HttpResponse.Content));
if (response.HttpStatus >= 400)
{
AliyunSMSReponse content = null;
try
{
content = JsonConvert.DeserializeObject <AliyunSMSReponse>(response.Data);
}
catch (Exception ex)
{
throw new MessageException(Constants.CODE_UNKONWN_ERROR, response.Data, ex);
}
throw new MessageException(Constants.CODE_UNKONWN_ERROR, content.Message);
}
}
public void WithRoleSessionDurationSecondss()
{
DefaultProfile.ClearDefaultProfile();
var mock = new Mock <AlibabaCloudCredentials>();
AlibabaCloudCredentials longLivedCredentials = mock.Object;
string roleArn = "roleArn";
IClientProfile profile = DefaultProfile.GetProfile("cn-shanghai", "accessKeyId", "accessKeySecret");
STSAssumeRoleSessionCredentialsProvider instance = new STSAssumeRoleSessionCredentialsProvider(longLivedCredentials, roleArn, profile);
long roleSessionDurationSeconds = 1000;
// No Exception
instance.WithRoleSessionDurationSeconds(roleSessionDurationSeconds);
Assert.Throws <ArgumentOutOfRangeException>(
() =>
{
instance.WithRoleSessionDurationSeconds(100);
}
);
}
public virtual AlibabaCloudCredentials GetRamRoleArnAlibabaCloudCredential()
{
if (String.IsNullOrEmpty(this.accessKeyId) && String.IsNullOrEmpty(this.accessKeySecret) && String.IsNullOrEmpty(this.regionId))
{
throw new ClientException("Missing required variable option for 'default Client'");
}
RamRoleArnCredential credential = new RamRoleArnCredential(
this.accessKeyId,
this.accessKeySecret,
this.roleArn,
this.roleSessionName,
STSAssumeRoleSessionCredentialsProvider.GetNewRoleSessionName(),
STSAssumeRoleSessionCredentialsProvider.DEFAULT_DURATION_SECONDS);
this.defaultProfile = DefaultProfile.GetProfile(this.regionId, this.accessKeyId, this.accessKeySecret);
var sTSAssumeRoleSessionCredentialsProvider = (STSAssumeRoleSessionCredentialsProvider)alibabaCloudCredentialProvider;
RamRoleArnCredential ramRoleArnCredential = (RamRoleArnCredential)sTSAssumeRoleSessionCredentialsProvider.GetCredentials();
return(ramRoleArnCredential);
}
static void Main(string[] args)
{
IClientProfile profile = DefaultProfile.GetProfile("cn-hangzhou", "*********", "********"); // todo: 补充AK信息
DefaultProfile.AddEndpoint("cn-hangzhou", "cn-hangzhou", "Dybaseapi", "dybaseapi.aliyuncs.com");
DefaultAcsClient client = new DefaultAcsClient(profile);
string queueName = "Alicom-Queue-***********-SmsReport"; // todo: 补充队列名称
string messageType = "SmsReport"; // todo: 补充消息类型
int maxThread = 2;
for (int i = 0; i < maxThread; i++)
{
TestTask testTask = new TestTask("PullMessageTask-thread-" + i, messageType, queueName, client);
Thread t = new Thread(new ThreadStart(testTask.Handle));
//启动线程
t.Start();
}
}
public static void StopInstance()
{
IClientProfile profile = DefaultProfile.GetProfile("cn-hangzhou", "<accessKeyId>", "<accessSecret>");
DefaultAcsClient client = new DefaultAcsClient(profile);
var request = new StopInstanceRequest();
request.InstanceId = "ECS实例ID";
try {
var response = client.GetAcsResponse(request);
Console.WriteLine(System.Text.Encoding.Default.GetString(response.HttpResponse.Content));
}
catch (ServerException e)
{
Console.WriteLine(e);
}
catch (ClientException e)
{
Console.WriteLine(e);
}
}
public string SendSms(string code, string mobile, string templateID = "SMS_140731928")
{
IClientProfile profile = DefaultProfile.GetProfile(regionIdForPop, accessId, accessSecret);
DefaultProfile.AddEndpoint(regionIdForPop, regionIdForPop, product, domain);
IAcsClient acsClient = new DefaultAcsClient(profile);
SendSmsRequest request = new SendSmsRequest();
string result = "0";
try
{
//request.SignName = "上云预发测试";//"管理控制台中配置的短信签名（状态必须是验证通过）"
//request.TemplateCode = "SMS_71130001";//管理控制台中配置的审核通过的短信模板的模板CODE（状态必须是验证通过）"
//request.RecNum = "13567939485";//"接收号码，多个号码可以逗号分隔"
//request.ParamString = "{\"name\":\"123\"}";//短信模板中的变量；数字需要转换为字符串；个人用户每个变量长度必须小于15个字符。"
//SingleSendSmsResponse httpResponse = client.GetAcsResponse(request);
request.PhoneNumbers = mobile;
request.SignName = "药代宝";
request.TemplateCode = templateID;
//request.TemplateParam = "{\"code\":\"123\"}";
request.TemplateParam = "{\"code\":\"" + code + "\"}";
request.OutId = "";
//请求失败这里会抛ClientException异常
SendSmsResponse sendSmsResponse = acsClient.GetAcsResponse(request);
if (sendSmsResponse.Code == "OK")//发送成功
{
result = "1";
}
return(result);
}
catch (ServerException e)
{
throw e;
}
catch (ClientException e)
{
throw e;
}
}
/// <summary>
/// 阿里云
/// </summary>
/// <param name="ramcode"></param>
/// <param name="PhoneNumbers"></param>
public string sendCode(string ramcode, string PhoneNumbers)
{
string returnCode = string.Empty;
String product = "Dysmsapi"; //短信API产品名称
String domain = "dysmsapi.aliyuncs.com"; //短信API产品域名
String accessKeyId = "LTAIZiLOrvoMRPS3"; //你的accessKeyId
String accessKeySecret = "SB93bYFfz4BhIU3cJqkj6Fx9omUD6i"; //你的accessKeySecret
IClientProfile profile = DefaultProfile.GetProfile("cn-hangzhou", accessKeyId, accessKeySecret);
//IAcsClient client = new DefaultAcsClient(profile);
// SingleSendSmsRequest request = new SingleSendSmsRequest();
DefaultProfile.AddEndpoint("cn-hangzhou", "cn-hangzhou", product, domain);
IAcsClient acsClient = new DefaultAcsClient(profile);
SendSmsRequest request = new SendSmsRequest();
try
{
//必填:待发送手机号。支持以逗号分隔的形式进行批量调用，批量上限为20个手机号码,批量调用相对于单条调用及时性稍有延迟,验证码类型的短信推荐使用单条调用的方式
request.PhoneNumbers = PhoneNumbers;//"13567939495";
//必填:短信签名-可在短信控制台中找到
request.SignName = "朗朗出行";
//必填:短信模板-可在短信控制台中找到
request.TemplateCode = "SMS_80220076";//SMS_78580141
//可选:模板中的变量替换JSON串,如模板内容为"亲爱的${name},您的验证码为${code}"时,此处的值为
request.TemplateParam = "{\"number\":\"" + ramcode + "\"}";
//可选:outId为提供给业务方扩展字段,最终在短信回执消息中将此值带回给调用者
request.OutId = "101010";
//请求失败这里会抛ClientException异常
SendSmsResponse sendSmsResponse = acsClient.GetAcsResponse(request);
returnCode = sendSmsResponse.Code;
System.Console.WriteLine(sendSmsResponse.Message);
}
catch (ServerException e)
{
System.Console.WriteLine(e.Message);
}
return(returnCode);
}
public bool SingleSendMail(SingleSendMailModel model)
{
var regionId = ConfigHelper.GetValuesByKey("EmailRegionId");
var accessKeyId = ConfigHelper.GetValuesByKey("EmailAccessKeyId");
var secret = ConfigHelper.GetValuesByKey("EmailSecret");
IClientProfile profile = DefaultProfile.GetProfile(regionId, accessKeyId, secret);
IAcsClient client = new DefaultAcsClient(profile);
SingleSendMailRequest request = new SingleSendMailRequest();
try
{
request.AccountName = model.AccountName;
request.FromAlias = model.FromAlias;
request.AddressType = model.AddressType;
request.TagName = model.TagName;
request.ReplyToAddress = model.ReplyToAddress;
request.ToAddress = model.ToAddress;
request.Subject = model.Subject;
if (model.EmailBodyType == EmailBodyType.Html)
{
request.HtmlBody = model.EMailBody;
}
else
{
request.TextBody = model.EMailBody;
}
SingleSendMailResponse httpResponse = client.GetAcsResponse(request);
return(httpResponse.HttpResponse.Status == 200);
}
catch (ServerException e)
{
LogHelper.Logger.Error(string.Format(MessageTips.SendEmailFail, "服务端原因", e.Message), e);
throw new SendEmailException(string.Format(MessageTips.SendEmailFail, "服务端原因", e.Message), e);
}
catch (ClientException e)
{
LogHelper.Logger.Error(string.Format(MessageTips.SendEmailFail, "客服端原因", e.Message), e);
throw new SendEmailException(string.Format(MessageTips.SendEmailFail, "客服端原因", e.Message), e);
}
}
static void Main()
{
IClientProfile clientProfile = DefaultProfile.GetProfile("cn-hangzhou", "<your access key id>", "<your access key secret>");
DefaultAcsClient client = new DefaultAcsClient(clientProfile);
QueryUniqueDeviceStatRequest request = new QueryUniqueDeviceStatRequest();
request.AppKey = < Your AppKey >;
request.Granularity = "DAY"; //DAY: 天粒度 MONTH: 月粒度
String startTime = DateTime.UtcNow.AddDays(-7).ToString("yyyy-MM-ddTHH\\:mm\\:ssZ"); //查询近7天的数据
String endTime = DateTime.UtcNow.AddDays(-7).ToString("yyyy-MM-ddTHH\\:mm\\:ssZ");
request.StartTime = startTime;
request.EndTime = endTime;
try
{
QueryUniqueDeviceStatResponse response = client.GetAcsResponse(request);
Console.WriteLine("RequestId:" + response.RequestId);
foreach (QueryUniqueDeviceStatResponse.AppDeviceStat stat in response.AppDeviceStats)
{
Console.WriteLine("time:" + stat.Time);
Console.WriteLine("count:" + stat.Count);
}
Console.ReadLine();
}
catch (ServerException e)
{
Console.WriteLine(e.ErrorCode);
Console.WriteLine(e.ErrorMessage);
Console.ReadLine();
}
catch (ClientException e)
{
Console.WriteLine(e.ErrorCode);
Console.WriteLine(e.ErrorMessage);
Console.ReadLine();
}
}
public void GetCredentials()
{
DefaultProfile.ClearDefaultProfile();
var mock = new Mock <AlibabaCloudCredentials>();
mock.Setup(foo => foo.GetAccessKeyId()).Returns("accessKeyId");
mock.Setup(foo => foo.GetAccessKeySecret()).Returns("accessKeySecret");
AlibabaCloudCredentials longLivedCredentials = mock.Object;
IClientProfile profile = DefaultProfile.GetProfile(
"cn-hangzhou",
"accessKeyId",
"accessKeySecret"
);
var mockInstance = new Mock <STSAssumeRoleSessionCredentialsProvider>(longLivedCredentials, "roleArn", profile);
AssumeRoleResponse response = new AssumeRoleResponse();
response.Credentials = new AssumeRoleResponse.AssumeRole_Credentials();
response.Credentials.AccessKeyId = "MockAccessKeyId";
response.Credentials.AccessKeySecret = "MockAccessKeyId";
response.Credentials.SecurityToken = "MockSecurityToken";
mockInstance.Setup(foo => foo.GetResponse(
It.IsAny <AssumeRoleRequest>()
)).Returns(response);
STSAssumeRoleSessionCredentialsProvider instance = mockInstance.Object;
var credentials = instance.GetCredentials(); // 执行credential初始化
Assert.IsType <BasicSessionCredentials>(credentials);
var credentials2 = instance.GetCredentials(); // 不执行credential初始化，直接获取
Assert.IsType <BasicSessionCredentials>(credentials);
Assert.Equal(credentials.GetAccessKeyId(), credentials2.GetAccessKeyId());
Assert.Equal(credentials.GetAccessKeySecret(), credentials2.GetAccessKeySecret());
}
public void ResolveConnectTimeoutTest()
{
IClientProfile profile = DefaultProfile.GetProfile("cn-hangzhou", AKID, AKSE);
var httpRequest = new HttpRequest();
var connectTimeout = 1024;
object[] resolveTimeoutArgs = { httpRequest, "ecs", "2014-05-10", "DescribeInstaces" };
object[] connectTimeoutArgs = { connectTimeout };
var type = typeof(DefaultAcsClient);
var resolveTimeoutMethodInfo =
type.GetMethod("ResolveTimeout", BindingFlags.NonPublic | BindingFlags.Instance);
var setConnectTimeoutMethodInfo = type.GetMethod("SetConnectTimeoutInMilliSeconds",
BindingFlags.Public | BindingFlags.Instance);
var resolveTimeout = Activator.CreateInstance(type, profile);
//Case1: Client connect timeout is 1024 ms, Request connect timeout is 2048 ms
//Expect: the final connect timeout should be 2048 ms
setConnectTimeoutMethodInfo.Invoke(resolveTimeout, connectTimeoutArgs);
httpRequest.SetConnectTimeoutInMilliSeconds(2048);
resolveTimeoutMethodInfo.Invoke(resolveTimeout, resolveTimeoutArgs);
Assert.Equal(2048, httpRequest.ConnectTimeout);
//Case2: Client connect timeout is 1024 ms, Request connect timeout is 0 ms
//Expect: the final connect timeout should be 1024 ms
httpRequest.SetConnectTimeoutInMilliSeconds(0);
resolveTimeoutMethodInfo.Invoke(resolveTimeout, resolveTimeoutArgs);
Assert.Equal(1024, httpRequest.ConnectTimeout);
//Case3: Client connect timeout is 0 ms, Request connect timeout is 2048 ms
//Expect: the final connect timeout should be 2048 ms
connectTimeout = 0;
setConnectTimeoutMethodInfo.Invoke(resolveTimeout, connectTimeoutArgs);
httpRequest.SetConnectTimeoutInMilliSeconds(2048);
resolveTimeoutMethodInfo.Invoke(resolveTimeout, resolveTimeoutArgs);
Assert.Equal(2048, httpRequest.ConnectTimeout);
}
public void IClientProfileInstance()
{
// when securityToken is not null
var mock = new Mock <IClientProfile>();
Credential credential = new Credential("accessKeyId", "accessKeySecret", "securityToken");
mock.Setup(foo => foo.GetCredential()).Returns(credential);
IClientProfile profile = mock.Object;
StaticCredentialsProvider instance = new StaticCredentialsProvider(profile);
Assert.IsType <BasicSessionCredentials>(instance.GetCredentials());
// when securityToken is null
var mock2 = new Mock <IClientProfile>();
Credential credential2 = new Credential("accessKeyId", "accessKeySecret");
mock2.Setup(foo => foo.GetCredential()).Returns(credential2);
IClientProfile profile2 = mock2.Object;
StaticCredentialsProvider instance2 = new StaticCredentialsProvider(profile2);
Assert.IsType <LegacyCredentials>(instance2.GetCredentials());
}
public static string sendSMS(string mobile)
{
IClientProfile profile = DefaultProfile.GetProfile("cn-hangzhou", accessKeyId, accessKeySecret);
DefaultProfile.AddEndpoint("cn-hangzhou", "cn-hangzhou", product, domain);
IAcsClient acsClient = new DefaultAcsClient(profile);
SendSmsRequest request = new SendSmsRequest();
try
{
//必填:待发送手机号。支持以逗号分隔的形式进行批量调用，批量上限为1000个手机号码,批量调用相对于单条调用及时性稍有延迟,验证码类型的短信推荐使用单条调用的方式
request.PhoneNumbers = mobile;
//必填:短信签名-可在短信控制台中找到
request.SignName = "美好食";
//必填:短信模板-可在短信控制台中找到
request.TemplateCode = "SMS_126290084";
//可选:模板中的变量替换JSON串,如模板内容为"亲爱的${name},您的验证码为${code}"时,此处的值为
request.TemplateParam = "{\"code\":\"" + ConvertJson.randomCode() + "\"}";
//可选:outId为提供给业务方扩展字段,最终在短信回执消息中将此值带回给调用者
// request.OutId = "yourOutId";
//请求失败这里会抛ClientException异常
SendSmsResponse sendSmsResponse = acsClient.GetAcsResponse(request);
// return sendSmsResponse.Message;
string json = "";
if (sendSmsResponse.Message == "OK")
{
json = "{\"data\":\"发送成功\"}";
}
else
{
json = "{\"data\":\"" + sendSmsResponse.Message + "\"}";
}
return(json);
}
catch (ServerException e)
{
return("发送失败!");
}
}
/// <summary>
/// 查询SMS发送信息详情
/// </summary>
/// <param name="PhoneNumber"></param>
/// <param name="bizId"></param>
/// <param name="SendDate"></param>
/// <returns></returns>
public static QuerySendDetailsResponse QuerySendDetails(String PhoneNumber, String bizId, String SendDate)
{
//初始化acsClient,暂不支持region化
IClientProfile profile = DefaultProfile.GetProfile("cn-hangzhou", accessKeyId, accessKeySecret);
DefaultProfile.AddEndpoint("cn-hangzhou", "cn-hangzhou", product, domain);
IAcsClient acsClient = new DefaultAcsClient(profile);
//组装请求对象
QuerySendDetailsRequest request = new QuerySendDetailsRequest();
//必填-号码
//request.PhoneNumber = "15000000000";
request.PhoneNumber = PhoneNumber;
//可选-流水号
request.BizId = bizId;
//必填-发送日期 支持30天内记录查询，格式yyyyMMdd
//request.SendDate = DateTime.Now.ToString("yyyyMMdd");
request.SendDate = SendDate;
//必填-页大小
request.PageSize = 10;
//必填-当前页码从1开始计数
request.CurrentPage = 1;
QuerySendDetailsResponse querySendDetailsResponse = null;
try
{
querySendDetailsResponse = acsClient.GetAcsResponse(request);
}
catch (ServerException e)
{
Debug.LogErrorFormat("ServerException:{0}", e.ErrorCode);
}
catch (ClientException e)
{
Debug.LogErrorFormat("ClientException:{0}", e.ErrorCode);
}
return(querySendDetailsResponse);
}
public void ResolveProxy()
{
IClientProfile profile = DefaultProfile.GetProfile("cn-hangzhou", AKID, AKSE);
HttpRequest httpRequest = new HttpRequest("urls", new Dictionary <string, string>());
var acsRequest = new AssumeRoleRequest();
Type type = typeof(DefaultAcsClient);
var resolveProxy = Activator.CreateInstance(type, profile);
MethodInfo methodInfo = type.GetMethods(BindingFlags.NonPublic | BindingFlags.Instance)
.Where(x => x.Name == "ResolveProxy" && x.IsPrivate)
.First();
MethodInfo genericMethod = methodInfo.MakeGenericMethod(typeof(AssumeRoleResponse));
object[] parameters = { httpRequest, acsRequest };
genericMethod.Invoke(resolveProxy, parameters);
acsRequest.Protocol = ProtocolType.HTTP;
Environment.SetEnvironmentVariable("HTTP_PROXY", "http://*****:*****@192.168.16.1:10");
Environment.SetEnvironmentVariable("no_proxy", "localhost,127.0.0.1,localaddress,.localdomain.com");
genericMethod.Invoke(resolveProxy, parameters);
Assert.True(httpRequest.Headers.ContainsKey("Authorization"));
Environment.SetEnvironmentVariable("HTTP_PROXY", null);
httpRequest.Headers.Remove("Authorization");
acsRequest.Protocol = ProtocolType.HTTPS;
Environment.SetEnvironmentVariable("HTTPS_PROXY", "https://*****:*****@192.168.16.1:10");
genericMethod.Invoke(resolveProxy, parameters);
Assert.True(httpRequest.Headers.ContainsKey("Authorization"));
Environment.SetEnvironmentVariable("HTTPS_PROXY", null);
httpRequest.Headers.Remove("Authorization");
Environment.SetEnvironmentVariable("HTTPS_PROXY", "https://192.168.16.1:10");
genericMethod.Invoke(resolveProxy, parameters);
Assert.False(httpRequest.Headers.ContainsKey("Authorization"));
Environment.SetEnvironmentVariable("HTTPS_PROXY", null);
}
//获取一批设备的状态信息，包括状态、最后上线时间、登录IP
private static void TestBatchGetDeviceStatus()
{
IClientProfile clientProfile = DefaultProfile.GetProfile("<your-region-id>", "<your-access-key-id>", "<your-access-key-secret>");
DefaultAcsClient client = new DefaultAcsClient(clientProfile);
BatchGetDeviceStateRequest request = new BatchGetDeviceStateRequest();
request.ProductKey = "<productKey>";
List <String> DeviceNames = new List <string>();
DeviceNames.Add("<deviceName1>");
DeviceNames.Add("<deviceName2>");
DeviceNames.Add("<deviceName3>");
DeviceNames.Add("<deviceName4>");
DeviceNames.Add("<deviceName...>");
request.DeviceNames = DeviceNames;
try
{
BatchGetDeviceStateResponse response = client.GetAcsResponse(request);
Console.WriteLine(response.Success);
Console.WriteLine(response.ErrorMessage);
List <BatchGetDeviceStateResponse.BatchGetDeviceState_DeviceStatus> DeviceStatusList = response.DeviceStatusList;
foreach (BatchGetDeviceStateResponse.BatchGetDeviceState_DeviceStatus DeviceStatus in DeviceStatusList)
{
Console.WriteLine(DeviceStatus.DeviceName + ", " + DeviceStatus.Status + ", " + DeviceStatus.LastOnlineTime);
}
}
catch (ServerException e)
{
Console.WriteLine(e.ErrorCode);
Console.WriteLine(e.ErrorMessage);
}
catch (ClientException e)
{
Console.WriteLine(e.ErrorCode);
Console.WriteLine(e.ErrorMessage);
}
Console.ReadKey();
}
private static void TestRrpc()
{
IClientProfile clientProfile = DefaultProfile.GetProfile("<your-region-id>", "<your-access-key-id>", "<your-access-key-secret>");
DefaultAcsClient client = new DefaultAcsClient(clientProfile);
RRpcRequest request = new RRpcRequest();
request.ProductKey = "<productKey>";
request.DeviceName = "<deviceName>";
request.Timeout = 1000;
byte[] payload = Encoding.Default.GetBytes("Hello World.");
String payloadStr = Convert.ToBase64String(payload);
request.RequestBase64Byte = payloadStr;
try
{
RRpcResponse response = client.GetAcsResponse(request);
Console.WriteLine("publish rrpc message result: " + response.Success);
Console.WriteLine(response.ErrorMessage);
Console.WriteLine("message ID: " + response.MessageId);
Console.WriteLine("rrpc code: " + response.RrpcCode);
Console.WriteLine("payload Base64Byte: " + response.PayloadBase64Byte);
}
catch (ServerException e)
{
Console.WriteLine(e.ErrorCode);
Console.WriteLine(e.ErrorMessage);
}
catch (ClientException e)
{
Console.WriteLine(e.ErrorCode);
Console.WriteLine(e.ErrorMessage);
}
Console.ReadKey();
}
public HttpResponse DoAction <T>(AcsRequest <T> request, bool autoRetry,
int maxRetryNumber, IClientProfile profile) where T : AcsResponse
{
if (null == profile)
{
throw new ClientException("SDK.InvalidProfile", "No active profile found.");
}
var retry = autoRetry;
var retryNumber = maxRetryNumber;
var region = profile.GetRegionId();
if (null == request.RegionId)
{
request.RegionId = region;
}
request.SetProductDomain();
var credentials = credentialsProvider.GetCredentials();
if (credentials == null)
{
credentials = new DefaultCredentialProvider().GetAlibabaCloudClientCredential();
}
var signer = Signer.GetSigner(credentials);
var format = profile.GetFormat();
List <Endpoint> endpoints = null;
if (request.ProductDomain == null)
{
endpoints = clientProfile.GetEndpoints(request.Product, request.RegionId,
request.LocationProduct,
request.LocationEndpointType);
}
return(DoAction(request, retry, retryNumber, request.RegionId, credentials, signer, format, endpoints));
}
static string regionIdForPop = ConfigurationManager.AppSettings["regionIdForPop"]; //"cn-hangzhou";
#region 发送短信
/// <summary>
/// 发送短信
/// </summary>
/// <param name="NumPhone"></param>
/// <param name="validateNum"></param>
public static bool SmsSend(string NumPhone, string validateNum)
{
IClientProfile profile = DefaultProfile.GetProfile(regionIdForPop, accetKey, accetSerct);
DefaultProfile.AddEndpoint(regionIdForPop, regionIdForPop, product, domain);
IAcsClient acsClient = new DefaultAcsClient(profile);
SendSmsRequest request = new SendSmsRequest();
try
{
request.PhoneNumbers = NumPhone; //电话号码
request.SignName = singName; //签名
request.TemplateCode = tempCode; // "SMS_130950020";
request.TemplateParam = "{\"code\":\"" + validateNum + "\"}";
request.OutId = ""; //模板code中定义的参数，可以定义多个，这里我只定义了一个code；validateNum是传进来的验证码，在后端随机生成，可自行处理
SendSmsResponse sendSmsResponse = acsClient.GetAcsResponse(request);
var status = sendSmsResponse.HttpResponse.Status;
System.Console.WriteLine(sendSmsResponse.Message);
//成功
if (status == 200)
{
return(true);
}
else
{
return(false);
}
}
catch (ServerException ex)
{
string result = ex.Message;
return(false);
}
catch (ClientException ez)
{
string result = ez.Message;
return(false);
}
}
public async Task <HttpResponse> DoActionAsync <T>(AcsRequest <T> request, bool autoRetry,
int maxRetryNumber, IClientProfile profile) where T : AcsResponse
{
if (null == profile)
{
throw new ClientException("SDK.InvalidProfile", "No active profile found.");
}
var regionId = profile.GetRegionId();
if (null != request.RegionId)
{
regionId = request.RegionId;
}
var credential = profile.GetCredential();
var signer = profile.GetSigner();
var format = profile.GetFormat();
var endpoints = await profile.GetEndpointsAsync(regionId, request.Product, credential, request.LocationProduct);
return(await DoActionAsync(request, autoRetry, maxRetryNumber, regionId, credential, signer, format, endpoints));
}
public static string aliSendSms(string strCode, string strTel)
{
String product = "Dysmsapi"; //短信API产品名称
String domain = "dysmsapi.aliyuncs.com"; //短信API产品域名
String accessKeyId = "xxxxx"; //你的accessKeyId
String accessKeySecret = "cS9yaOQNhp3tTxNEYwR0bj0yETRrRm"; //你的accessKeySecret
IClientProfile profile = DefaultProfile.GetProfile("cn-hangzhou", accessKeyId, accessKeySecret);
//IAcsClient client = new DefaultAcsClient(profile);
// SingleSendSmsRequest request = new SingleSendSmsRequest();
DefaultProfile.AddEndpoint("cn-hangzhou", "cn-hangzhou", product, domain);
IAcsClient acsClient = new DefaultAcsClient(profile);
SendSmsRequest request = new SendSmsRequest();
try
{
//必填:待发送手机号。支持以逗号分隔的形式进行批量调用，批量上限为20个手机号码,批量调用相对于单条调用及时性稍有延迟,验证码类型的短信推荐使用单条调用的方式
request.PhoneNumbers = strTel;
//必填:短信签名-可在短信控制台中找到
request.SignName = "单程序屋";
//必填:短信模板-可在短信控制台中找到
request.TemplateCode = "SMS_157070710";
//可选:模板中的变量替换JSON串,如模板内容为"亲爱的${name},您的验证码为${code}"时,此处的值为
request.TemplateParam = $"{{\"code\":\"{strCode}\"}}";
//可选:outId为提供给业务方扩展字段,最终在短信回执消息中将此值带回给调用者
// request.OutId = "2019030721092201";
//请求失败这里会抛ClientException异常
SendSmsResponse sendSmsResponse = acsClient.GetAcsResponse(request);
//result表示执行结果，是由阿里云返回给本地服务器的
String result = sendSmsResponse.Message;
// System.Console.WriteLine(result);
}
catch (Exception e)
{
}
return("1");
}
/// <summary>
/// 阿里平台发短信方法
/// </summary>
/// <param name="mobile">接收短信手机号码</param>
/// <param name="templateID">阿里短信平台短信模板号</param>
/// <param name="SignName">阿里短信平台短信签名</param>
/// <param name="templateParam">短信内容Json格式，参数在短信模板中定义</param>
/// <returns></returns>
public string ALISendSMS(string mobile, string templateID, string SignName, string templateParam)
{
IClientProfile profile = DefaultProfile.GetProfile(regionIdForPop, accessId, accessSecret);
DefaultProfile.AddEndpoint(regionIdForPop, regionIdForPop, product, domain);
IAcsClient acsClient = new DefaultAcsClient(profile);
SendSmsRequest request = new SendSmsRequest();
string result = "0";
try
{
request.PhoneNumbers = mobile;
//request.SignName = "";
request.SignName = SignName;
request.TemplateCode = templateID;
request.TemplateParam = templateParam;
request.OutId = "";
//请求失败这里会抛ClientException异常
SendSmsResponse sendSmsResponse = acsClient.GetAcsResponse(request);
if (sendSmsResponse.Code == "OK")//发送成功
{
result = "1";
}
else
{
result = sendSmsResponse.Code;
}
return(result);
}
catch (ServerException e)
{
throw e;
}
catch (ClientException e)
{
throw e;
}
}
public static void AddBackendServers()
{
IClientProfile profile = DefaultProfile.GetProfile("cn-hangzhou", "<accessKeyId>", "<accessSecret>");
DefaultAcsClient client = new DefaultAcsClient(profile);
var request = new AddBackendServersRequest();
request.LoadBalancerId = "<loadBalancerId>";
request.BackendServers = "<backendServers>";
try {
var response = client.GetAcsResponse(request);
Console.WriteLine(System.Text.Encoding.Default.GetString(response.HttpResponse.Content));
}
catch (ServerException e)
{
Console.WriteLine(e);
}
catch (ClientException e)
{
Console.WriteLine(e);
}
}
public void SedMessage()
{
String product = "Dysmsapi"; //短信API产品名称
String domain = "dysmsapi.aliyuncs.com"; //短信API产品域名
String accessId = "";
String accessSecret = "";
String regionIdForPop = "cn-hangzhou";
IClientProfile profile = DefaultProfile.GetProfile(regionIdForPop, accessId, accessSecret);
DefaultProfile.AddEndpoint(regionIdForPop, regionIdForPop, product, domain);
IAcsClient acsClient = new DefaultAcsClient(profile);
SendSmsRequest request = new SendSmsRequest();
try
{
//request.SignName = "上云预发测试";//"管理控制台中配置的短信签名（状态必须是验证通过）"
//request.TemplateCode = "SMS_71130001";//管理控制台中配置的审核通过的短信模板的模板CODE（状态必须是验证通过）"
//request.RecNum = "13567939485";//"接收号码，多个号码可以逗号分隔"
//request.ParamString = "{\"name\":\"123\"}";//短信模板中的变量；数字需要转换为字符串；个人用户每个变量长度必须小于15个字符。"
//SingleSendSmsResponse httpResponse = client.GetAcsResponse(request);
request.PhoneNumbers = "15908150902";
request.SignName = "";
request.TemplateCode = "SMS_152543887";
request.TemplateParam = "{\"name\":\"许洪远\",\"88.88\"}";
request.OutId = "xxxxxxxx";
//请求失败这里会抛ClientException异常
SendSmsResponse sendSmsResponse = acsClient.GetAcsResponse(request);
System.Console.WriteLine(sendSmsResponse.Message);
}
catch (System.Runtime.Remoting.ServerException e)
{
System.Console.WriteLine("ServerException");
}
catch (ClientException e)
{
System.Console.WriteLine("ClientException");
}
}
