DDNS动态更新

     /// <summary>
     /// DnsPod DDNS工具类
     /// </summary>
     public class DDNSToolkit
     {
         private static string userName = ConfigurationManager.AppSettings["DNSUserName"];
         private static string password = ConfigurationManager.AppSettings["DNSPassword"];
         /// <summary>
         /// 公共参数
         /// </summary>
         private object baseParam = new
             {
                 login_email = userName,//用户帐号，必选
                 login_password = password,//用户密码，必选
                 format = "json",//返回的数据格式，可选，默认为xml，建议用json
                 lang = "cn",//返回的错误语言，可选，默认为en，建议用cn
                 error_on_empty = "no"//没有数据时是否返回错误，可选，默认为yes，建议用no
             };

         #region 域名相关

         /// <summary>
         /// Return the domain_Id,when the domains contains more then one entity,returns the first one!
         /// </summary>
         /// <returns></returns>
         public int DomainGetId(string keyword)//获取域名ID
         {
             var domainId = -;
             if (!string.IsNullOrWhiteSpace(keyword))
                 keyword = "keyword=" + keyword;
             /*api说明 https://www.dnspod.cn/docs/domains.html#domain-list
             公共参数
             type 域名权限种类，可选参数，默认为’all’。包含以下类型：
                 all：所有域名
                 mine：我的域名
                 share：共享给我的域名
                 ismark：星标域名
                 pause：暂停域名
                 vip：VIP域名
                 recent：最近操作过的域名
                 share_out：我共享出去的域名
             offset 记录开始的偏移，第一条记录为 0，依次类推，可选参数
             length 共要获取的记录的数量，比如获取20条，则为20，可选参数
             group_id 分组ID，获取指定分组的域名，可选参数
             keyword，搜索的关键字，如果指定则只返回符合该关键字的域名，可选参数*/
             var dataBaseObj = GetDNSApi("https://dnsapi.cn/Domain.List", keyword);
             if (dataBaseObj != null)
             {
                 if (dataBaseObj["status"]["code"] == "")
                 {
                     if (dataBaseObj["domains"].Length > )
                     {
                         domainId = Convert.ToInt32(dataBaseObj["domains"][]["id"]);
                     }
                 }
                 else
                 {
                     throw new ArgumentException(string.Format("DNSPod API：Domain.List调用异常，说明:{0}", dataBaseObj["status"]["message"]));
                 }
             }
             return domainId;
         }

         #endregion

         #region 记录相关
         /// <summary>
         /// Get the recordId
         /// </summary>
         /// <param name="domainId">domainId</param>
         /// <param name="subDomain">The name for subDomain</param>
         /// <returns></returns>
         public int RecordGetIdBySubdomain(int domainId, string subDomain)//获取记录ID
         {
             var recordId = -;
             /*api说明 https://www.dnspod.cn/docs/records.html#record-list
             公共参数
             domain_id 域名ID，必选
             offset 记录开始的偏移，第一条记录为 0，依次类推，可选
             length 共要获取的记录的数量，比如获取20条，则为20，可选
             sub_domain 子域名，如果指定则只返回此子域名的记录，可选
             keyword，搜索的关键字，如果指定则只返回符合该关键字的记录，可选*/
             var dataBaseObj = GetDNSApi("https://dnsapi.cn/Record.List", new { domain_id = domainId, sub_domain = subDomain });
             if (dataBaseObj != null)
             {
                 if (dataBaseObj["status"]["code"] == "")
                 {
                     if (dataBaseObj["records"].Length > )
                     {
                         domainId = Convert.ToInt32(dataBaseObj["records"][]["id"]);
                     }
                 }
                 else
                 {
                     throw new ArgumentException(string.Format("DNSPod API：Record.List调用异常，说明:{0}", dataBaseObj["status"]["message"]));
                 }
             }

             return recordId;
         }

         /// <summary>
         /// Create subdomain record
         /// </summary>
         /// <param name="domainId">domainId</param>
         /// <param name="value">value:IP、CNAME、MX</param>
         /// <param name="subDomain">subdomain name,like "www",defalut is "@"</param>
         /// <param name="recordId"></param>
         /// <returns></returns>
         public bool RecordCreate(int domainId, string value, string subDomain, out int recordId)//创建记录
         {
             recordId = -;
             bool flag = false;
             /*api说明 https://www.dnspod.cn/docs/records.html#record-create
             公共参数
             domain_id 域名ID, 必选
             sub_domain 主机记录, 如 www, 默认@，可选
             record_type 记录类型，通过API记录类型获得，大写英文，比如：A, 必选
             record_line 记录线路，通过API记录线路获得，中文，比如：默认, 必选
             value 记录值, 如 IP:200.200.200.200, CNAME: cname.dnspod.com., MX: mail.dnspod.com., 必选
             mx {1-20} MX优先级, 当记录类型是 MX 时有效，范围1-20, MX记录必选
             ttl {1-604800} TTL，范围1-604800，不同等级域名最小值不同, 可选*/
             var dataBaseObj = GetDNSApi("https://dnsapi.cn/Record.Create", new
             {
                 domain_id = domainId,
                 sub_domain = subDomain,
                 value = value,
                 record_type = "A",
                 record_line = "默认"
             });
             if (dataBaseObj != null)
             {
                 if (dataBaseObj["status"]["code"] == "")
                 {
                     flag = true;
                     recordId = Convert.ToInt32(dataBaseObj["record"]["id"]);
                 }
                 else
                 {
                     throw new ArgumentException(string.Format("DNSPod API：Record.Create调用异常，说明:{0}", dataBaseObj["status"]["message"]));
                 }
             }
             return flag;
         }
         /// <summary>
         /// 修改记录
         /// </summary>
         /// <param name="domainId"></param>
         /// <param name="recordId"></param>
         /// <param name="subdomain"></param>
         /// <param name="value"></param>
         /// <param name="message"></param>
         /// <returns></returns>
         public bool RecordUpdate(int domainId, int recordId, string subdomain, string value, out string message)//修改记录
         {
             message = string.Empty;
             bool flag = false;
             /*api说明 https://www.dnspod.cn/docs/records.html#record-modify
             公共参数
             domain_id 域名ID，必选
             record_id 记录ID，必选
             sub_domain 主机记录，默认@，如 www，可选
             record_type 记录类型，通过API记录类型获得，大写英文，比如：A，必选
             record_line 记录线路，通过API记录线路获得，中文，比如：默认，必选
             value 记录值, 如 IP:200.200.200.200, CNAME: cname.dnspod.com., MX: mail.dnspod.com.，必选
             mx {1-20} MX优先级, 当记录类型是 MX 时有效，范围1-20, mx记录必选
             ttl {1-604800} TTL，范围1-604800，不同等级域名最小值不同，可选*/
             var resObj = GetDNSApi("https://dnsapi.cn/Record.Modify", new
                 {
                     domain_id = domainId,
                     record_id = recordId,
                     value = value,
                     sub_domain = subdomain,
                     record_type = "A",
                     record_line = "默认"
                 });
             if (resObj != null)
             {
                 if (resObj["status"]["code"] == "")
                 {
                     /*更新成功，返回记录详情（记录中的各参数）
                      * "record": {
                      *       "id":16894439,
                      *       "name":"@",
                      *       "value":"3.2.2.2",
                      *       "status":"enable"
                      *   }
                      */
                     message = GetObjectPropertiesString(resObj["record"]);
                     flag = true;
                 }
                 else
                 {
                     message = resObj["status"]["message"];
                     throw new ArgumentException(string.Format("DNSPod API：Record.Modify调用异常，说明:{0}", resObj["status"]["message"]));
                 }
             }
             return flag;
         }
         /// <summary>
         /// 设置记录备注
         /// </summary>
         /// <param name="domainId">域名ID</param>
         /// <param name="recordId">记录ID</param>
         /// <param name="remark">备注信息</param>
         /// <returns></returns>
         public bool RecordRemark(int domainId, int recordId, string remark = "")//设置记录备注
         {
             bool flag = false;
             var resObj = GetDNSApi("https://dnsapi.cn/Record.Remark", new
             {
                 domain_id = domainId,
                 record_id = recordId,
                 remark = remark
             });
             if (resObj != null && resObj["status"]["code"] == "")
                 flag = true;
             return flag;
         }

         #endregion

         #region 辅助方法

         /// <summary>
         /// Send the webrequest to the api,and get the data of JSON！
         /// </summary>
         /// <param name="apiAddress">The API address for DNSPod</param>
         /// <param name="data">The object type parameter with key/value pairs，like{type:"POST"}</param>
         /// <returns></returns>
         private dynamic GetDNSApi(string apiAddress, object data)
         {
             return GetDNSApi(apiAddress, GetApiParamDataString(data));
         }
         /// <summary>
         /// Send the webrequest to the api,and get the data of JSON！
         /// </summary>
         /// <param name="apiAddress">The API address for DNSPod</param>
         /// <param name="data">The data that will send to the api,like "type=post"，split with "&" for more parameters!</param>
         /// <returns>The returned data object</returns>
         private dynamic GetDNSApi(string apiAddress, string data)
         {

             //若有额外参数，则将公共参数添加至参数请求中
             if (!string.IsNullOrWhiteSpace(data))
             {
                 data = string.Format("{0}&{1}", GetApiParamDataString(baseParam), data);
             }
             else
             {
                 data = GetApiParamDataString(baseParam);//若无额外参数，只提交公共参数
             }
             HttpWebRequest request = (HttpWebRequest)WebRequest.Create(apiAddress);
             request.Method = "POST";
             request.Headers.Add("content", "text/html; charset=UTF-8");
             request.ContentType = "application/x-www-form-urlencoded";
             request.UserAgent = "ROS DDNS/V1";
             byte[] postData = Encoding.UTF8.GetBytes(data);
             request.ContentLength = postData.Length;
             Stream smp = request.GetRequestStream();//得到请求流
             smp.Write(postData, , postData.Length);//写入请求流
             smp.Close();//关闭流

             HttpWebResponse response = (HttpWebResponse)request.GetResponse();
             StreamReader stream = new StreamReader(response.GetResponseStream(), System.Text.Encoding.UTF8);
             string responseString = stream.ReadToEnd();//得到返回数据
             stream.Close();
             response.Close();
             request = null;
             dynamic obj = null;
             if (!string.IsNullOrWhiteSpace(responseString))
             {
                 obj = new JavaScriptSerializer().Deserialize(responseString, typeof(object) as dynamic);
             }
             return obj;
         }
         /// <summary>
         ///
         /// </summary>
         /// <param name="data"></param>
         /// <returns>The returned data of JSON</returns>
         private string GetApiParamDataString(object data)
         {
             var dataString = string.Empty;
             if (data != null)
             {
                 //利用反复取可读属性或实例，返回属性集合
                 var objProperties = (from x in data.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance) where x.CanRead select x).ToList();
                 //将属性名与值拼接，返回string类型的数组
                 var arrProValue = (from y in objProperties select string.Format("{0}={1}", y.Name, y.GetValue(data, new object[]))).ToList().ToArray();
                 //将数组以“&”连接
                 dataString = string.Join("&", arrProValue);
             }
             return dataString;
         }
         private string GetObjectPropertiesString(object obj)
         {
             var dataStr = new StringBuilder();
             if (obj != null)
             {
                 var d = obj as Dictionary<string, object>;
                 foreach (var item in d)
                 {
                     dataStr.AppendLine(string.Format("{0}   -   {1}", item.Key, item.Value));
                 }
             }
             return dataStr.ToString();
         }

         #endregion
     }

     #region 辅助类，用于返回dynamic类型对象

     public class JsonParser
     {
         /// <summary>
         /// 从json字符串到对象。
         /// </summary>
         /// <param name="jsonStr"></param>
         /// <returns></returns>
         public static dynamic FromJson(string jsonStr)
         {
             JavaScriptSerializer jss = new JavaScriptSerializer();
             jss.RegisterConverters(new JavaScriptConverter[] { new DynamicJsonConverter() });

             dynamic glossaryEntry = jss.Deserialize(jsonStr, typeof(object)) as dynamic;
             return glossaryEntry;
         }
     }
     public class DynamicJsonConverter : JavaScriptConverter
     {
         public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
         {
             if (dictionary == null)
                 throw new ArgumentNullException("dictionary");

             if (type == typeof(object))
             {
                 return new DynamicJsonObject(dictionary);
             }

             return null;
         }

         public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
         {
             throw new NotImplementedException();
         }

         public override IEnumerable<Type> SupportedTypes
         {
             get { return new ReadOnlyCollection<Type>(new List<Type>(new Type[] { typeof(object) })); }
         }
     }

     public class DynamicJsonObject : DynamicObject
     {
         private IDictionary<string, object> Dictionary { get; set; }

         public DynamicJsonObject(IDictionary<string, object> dictionary)
         {
             this.Dictionary = dictionary;
         }

         public override bool TryGetMember(GetMemberBinder binder, out object result)
         {
             result = this.Dictionary[binder.Name];

             if (result is IDictionary<string, object>)
             {
                 result = new DynamicJsonObject(result as IDictionary<string, object>);
             }
             else if (result is ArrayList)
             {
                 result = new List<DynamicJsonObject>((result as ArrayList).ToArray().Select(x => new DynamicJsonObject(x as IDictionary<string, object>)));
             }
             //else if (result is ArrayList && (result as ArrayList) is IDictionary<string, object>)
             //{
             //    result = new List<DynamicJsonObject>((result as ArrayList).ToArray().Select(x => new DynamicJsonObject(x as IDictionary<string, object>)));
             //}
             //else if (result is ArrayList)
             //{
             //    result = new List<object>((result as ArrayList).ToArray());
             //}
             return this.Dictionary.ContainsKey(binder.Name);
         }
     }
     #endregion