API： C#

在 C# 上编写的给定示例包含以下模式：

• 登录
• 平台列表
• 按平台列出设备列表
• 服务器视图 （SV） 设备（按 ID）
• 编辑设备
• 获取监视器
• 获取频率
• 获取通知组
• 创建新的 SV 设备
• 添加新的 HTTP 任务
• 计划列表
• 创建新计划

C# 示例

使用系统;
使用系统.Linq;
使用系统.集合.通用;
使用System.IO;
使用System.Net;
使用系统.文本;
使用系统.Web.脚本.序列化;
命名空间示例
{
类程序
{
类 Operatio 结果
{
公共布尔成功 = 获取;集;|
公共字符串结果 = get;设置; |
公共重写字符串 ToString（）
{
返回字符串.格式（”成功 {0} ：;结果 {1} ：”成功，结果;”
}
}
类错误结果
{
公共布尔成功 = 获取;集;|
公共字符串 = 错误描述 = 获取;设置; |
公共重写字符串 ToString（）
{
返回字符串.联接（环境.换行、错误描述）;
}
}
类平台
{
公共 int Id = 获取;设置;|
公共字符串名称 = get;设置; |
公共布尔可用 = 获取;设置;|
公共重写字符串 ToString（）
{
返回字符串.格式（”ID：; {0}名称： {1} ;可用 {2} ：”，ID，名称，可用）;
}
}
类监视器
{
公共 int Id = 获取;设置;|
公共字符串名称 = get;设置; |
公共布尔可用 = 获取;设置;|
公共布尔已删除 = 获取;设置;|
公共布尔IsPrivate = 获取;设置;|
公共重写字符串 ToString（）
{
返回字符串.格式（”ID：; {0}名称： {1} ;可用： {2} ;已删除： {3} ;是私人 {4} 的：”，
ID、 名称、 可用、已删除、Isprivate;
}
}
类 每周间隔
{
公共字符串 = 天 = 获取;设置;|
公共From_Min [ 获取; 设置; |
公共int To_Min = 获取;集;|
包括公共布尔 = 获取;设置;|
公共重写字符串 ToString（）
{
返回字符串.格式（”天： |{0}];From_Min： {1} （时间： {4});To_Min： {2} （时间： {5});包括： {3}”,
字符串.加入（”，”，天），From_Min，To_Min，包括，时间跨度.从分钟（From_Min），时间跨度.从分钟（To_Min））;
}
}
类日期时间间隔
{
公共长从 [ 获取; 设置; ] 公共长到 [ 获取; 设置; ] 公共重写字符串 ToString（）
{
返回字符串.格式（”从 {0} ：（时间 {2} ：）;到： {1} （时间： {3} ）”
从，到，UnixBaseTime.add毫秒（来自），UnixBaseTime.add毫秒（到））;
}
}
类分配到信息
{
总结
只读
/摘要
公共 int_ 设备 = 获取;设置;|
总结
只读
/摘要
公共 int_ Notification_Groups [ 获取; 设置; |
公共重写字符串 ToString（）
{
返回字符串.格式（”设备：*;””””设备”：”””””””””””””””””” {0}Notification_Groups： {1} []，
字符串.联接（”，”设备.选择（id = > ID）。到 String（））。到Array（）），
字符串.联接（”，”，Notification_Groups.选择（id = > id）。到 String（））。到Array（））;）;
}
}
类计划程序
{
公共 int Id = 获取;设置;|
公共字符串名称 = get;设置; |
公共字符串 描述 = get;设置; |
公共每周间隔[Weekly_Intervals [ 获取; 设置; |
公共日期时间间隔=Date_Time_Intervals = 获取;设置;|
公共分配信息Assigned_To [ 获取; 设置; |
公共重写字符串 ToString（）
{
返回字符串.格式（”ID： {0};名字： {1};描述： {2};Weekly_Intervals： |{3}];Date_Time_Intervals： |{4}];分配到信息： {5}”,
Id， 名称， 描述，
字符串.加入（”，”，Weekly_Intervals.选择（wi = > wi。到 String（））。到Array（）），
字符串.联接（”，”，Date_Time_Intervals.选择（dti = > dti）。到 String（））。toArray（）），Assigned_To）;
}
}
类站点通知组
{
公共 int Id = 获取;设置;|
公共int Time_Shift_Min [ 获取; 设置; |
}
类通知
{
公共布尔E_Mail_Flag [ 获取; 设置; |
公共字符串E_Mail_Address = get;设置; |
公共因E_Mail_TimeInterval_Min [ 获取; 设置; |
公共布尔WL_Device_Flag [ 获取; 设置; |
公共字符串WL_Device_Email_Address = get;设置; |
公共WL_Device_TimeInterval_Min [ 获取; 设置; |
公共布尔Phone_Flag [ 获取; 设置; |
公共字符串Phone_Area_Code = get;设置; |
公共字符串Phone_Phone = get;设置; |
公共Phone_TimeInterval_Min [ 获取; 设置; |
公共布尔SMS_Flag [ 获取; 设置; |
公共字符串SMS_Phone = get;设置; |
公共int SMS_TimeInterval_Min [ 获取; 设置; |
公共布尔Script_Flag [ 获取; 设置; |
公共字符串Script_Batch_File_Name = get;设置; |
公共因Script_TimeInterval_Min [ 获取; 设置; |
公共SNMP_TimeInterval_Min [ 获取; 设置; |
公共网站通知组[ Notification_Groups [ 获取; 设置; |
}
类服务器查看设备
{
公共 int Id = 获取;设置;|
公共int Platform_Id [ 获取; 设置; |
公共字符串名称 = get;设置; |
公共int Number_Of_Tasks [ 获取; 设置; |
公共字符串Status_Description = get;设置; |
公共布尔推迟 [ 获取; 设置; |
公共波尔Send_Uptime_Alert [ 获取; 设置; |
公共int Owner_Device_Id [ 获取; 设置; |
公共 int 频率 = 获取;设置;|
公共Filter_Id [ 获取; 设置; |
公共Scheduler_Id [ 获取; 设置; |
公共通知通知 = 获取;设置;|
公共布尔Avoid_Simultaneous_Checks [ 获取; 设置; |
公共布尔False_Positive_Check [ 获取; 设置; |
公共Alert_Silence_Min [ 获取; 设置; |
公共 int_ 位置 = 获取;设置;|
}
类任务类型
{
公共 int Id = 获取;设置;|
公共字符串名称 = get;设置; |
}
类名称值对
{
公共字符串名称 = get;设置; |
公共字符串 值 = get;设置; |
}
类 HTTPTask
{
公共Device_Id [ 获取; 设置; |
公共 int Id = 获取;设置;|
公共因Task_Type_Id [ 获取; 设置; |
公共字符串名称 = get;设置; |
公共 int 超时 = 获取;设置;|
公共字符串请求类型 = get;设置; |
公共字符串 Url = get;设置; |
公共字符串关键字1 = get;设置; |
公共字符串关键字2 = get;设置; |
公共字符串关键字3 = get;设置; |
公共字符串用户名 = get;设置; |
公共字符串 UserPass = get;设置; |
公共布尔全页下载 [ 获取; 设置; |
公共布尔Download_Html [ 获取; 设置; |
公共布尔Download_Frames [ 获取; 设置; |
公共布尔Download_StyleSheets [ 获取; 设置; |
公共布尔Download_Scripts [ 获取; 设置; |
公共波尔Download_Images [ 获取; 设置; |
公共波尔Download_Objects [ 获取; 设置; |
公共波尔Download_Applets [ 获取; 设置; |
公共波尔Download_Additional [ 获取; 设置; |
公共名称ValuePair_getParams = get;set;|
公共名称ValuePair_= 后帕拉姆斯 [ 获取; 设置; |
公共名称值Pair_ 标题 Params = 获取;设置;|
字符串准备脚本 = 获取;设置;|
}
枚举请求方法
{
获取
发布
}
专用静态 Cookie 容器容器;
公共静态只读日期时间 UnixBaseTime = 新的日期时间（1970，1，1，0，0，0;
设置请求功能
专用静态字符串请求（字符串操作、请求方法请求类型、字符串数据）
{
Web 请求 = WebRequest.Create（”https：//api.com-monitor.com/config_api_v1/” = 操作）;
请求。方法 = 请求类型.ToString（）;
（（httpWeb请求）请求）。饼干容器 = 容器;
如果（请求类型 = RequestMethod.POST）
{
字符串后数据 = 数据;
如果（后数据.长度 > 0）
{
字节 = 字节数组 = 编码.UTF8.GetBytes（后数据）;
请求。内容类型 = “应用程序/json”;
请求。内容长度 = 字节数组长度;
流数据流 = 请求。获取请求流（）;
数据流.写入（字节数组，0，字节数组.长度）;
}
还
{
请求。内容长度 = 0;
}
}
尝试
{
使用（var 响应 = 请求）。获取响应（））
{
使用 （var 流 = 响应）。获取响应流（））
{
如果（流 ！= 空）
{
使用（var 读取器 = 新的流阅读器（流））
{
返回读取器。阅读结束（）;
}
}
}
}
}
渔获（例外前）
{
使用 （var 流 = ex.响应.获取响应流（））
{
使用（var 读取器 = 新的流阅读器（流））
{
引发新的异常（读取器）。阅读结束（））;
}
}
}
返回字符串.空;
}

静态空隙主（）
{
忽略证书错误
服务点管理器.服务器证书验证回拨 = 委托 = 返回 true;*;
初始化 Cookie 容器
容器 = 新的 Cookie 容器（）;
初始化 javascript 序列化器
var 序列化器 = 新的 JavaScript 序列化器（）;
登录
控制台.Writeline（”=登录*”）;
字符串结果Str;
尝试
{
结果=请求（”登录”，RequestMethod.POST，
序列化器。序列化（
新 |
用户名 = “1”，
密码 = “1”
}
));
var 结果 = 序列化器。去序列化 < Operatio结果 > （结果斯特）;
控制台.写入行（结果。到 String（））;
}
渔获（例外前）
{
var 错误 = 序列化器。反序列 < 化错误结果 > （例如消息;
控制台.写入行（错误）。到 String（））;
}
获取平台
控制台.WriteLine（”*获取平台*”）;
IE500 平台 < > = 空;
尝试
{
结果Str = 请求（”平台”，请求方法.GET，字符串.空）;
平台 = 序列化器。序列化 < 平台 > *（结果）
}
捕获（例外前）
{
var 错误 = 序列化器。反序列 < 化错误结果 > （例如消息;
控制台.写入行（错误）。到 String（））;
}
每个（平台中的 var 平台）
{
控制台.写入线（平台）;
}
按平台获取设备
控制台.WriteLine（”*按平台获取设备*”）;
int svDeviceId = 0;
每个（在平台中的 var 平台）。地点（p = > p.可用）
{
结果Str = 请求（String.Format（”设备 {0} /”，平台）。名称），请求方法.GET，字符串.空）;
var ds = 序列化器。反序列 < 化int_（ > 结果斯特）;
每个（在 ds 中 var ID）
{
如果（svDeviceId = 0 &amp;平台）。ID = 1）
{
svDeviceId = id;
}
控制台.WriteLine（” {0} – {1} “，平台。姓名、ID）;
}
}
按 ID 获取服务器查看设备
控制台.WriteLine（”*按 id*获取设备”）;
结果Str = 请求（String.Format（”设备 {0} /”，svDeviceId），请求方法.GET，字符串.空）;
var 设备 = 序列化器。序列化 < 服务器查看设备 > （结果斯特）;
编辑设备
控制台.Writeline（”=编辑设备*”）;
装置。名称 = 设备。名称 = “（编辑）”;
尝试
{
结果Str = 请求（String.Format（”设备 {0} /”，设备）。ID），RequestMethod.POST，
序列化器。序列化（设备）;
var 结果 = 序列化器。去序列化 < Operatio结果 > （结果斯特）;
控制台.写入行（结果。到 String（））;
}
渔获（例外前）
{
var 错误 = 序列化器。反序列 < 化错误结果 > （例如消息;
控制台.写入行（错误）。到 String（））;
}
获取监视器
控制台.Writeline（”*获取监视器*”）;
IE500 监视器 < > 监视器 = 序列化器。反序列化 < 监视器 > *（请求（字符串.格式（”位置 {0} /”，设备）。Platform_Id）
请求方法.GET，字符串.空））;
每个（监视器中的 var 监视器）
{
控制台.写入线（监视器）;
}
获取频率
控制台.Writeline（”*获取频率*”）;
var 频率 = 序列化器。反序列化 < 英寸 > *（请求（字符串.格式（”频率 {0} /”，设备）。Platform_Id）
请求方法.GET，字符串.空））;
每个（频率的 var 频率）
{
控制台.写入线（频率）;
}
获取通知组
控制台.Writeline（”*获取通知组*”）;
var ngs = 序列化器。反序列化 < > int_（请求（”组”，请求方法.GET，字符串.空）;
每个（var ng 在 ngs）
{
控制台.写入线（ng）;
}
创建新设备
控制台.Writeline（”*创建设备*”）;
设备 = 新的服务器查看设备
{
Platform_Id = 平台。单（p = > p.名称.ToLower（） = “服务器视图”）。Id
名称 = “新设备”
频率 = 频率[0]，
延迟 = 正确，
位置 = 监视器。位置（m = > m.可用 &amp;amp;m.isPrivate &amp;amp;（m.Id%2 = 0）。选择（m = > m.Id）。到Array（），
Avoid_Simultaneous_Checks = 真实，
通知 = 新通知
{
E_Mail_Flag = 错误，
Pager_Flag = 错误，
Phone_Flag = 错误，
SMS_Flag = 错误，
Script_Flag = 错误，
WL_Device_Flag = 错误，
Notification_Groups = ngs。拿（1）。选择（ng = > 新站点通知组 [Id = ng，Time_Shift_Min = 0 /{0 } 立即\}）。到Array（）
}
};
int 新设备 Id = 0;
尝试
{
结果=请求（”设备”动词_PUT”，RequestMethod.POST，
序列化器。序列化（设备）;
var 结果 = 序列化器。去序列化 < Operatio结果 > （结果斯特）;
新设备 Id = int。分析（结果）。结果）;
控制台.写入行（结果。到 String（））;
}
渔获（例外前）
{
var 错误 = 序列化器。反序列 < 化错误结果 > （例如消息;
控制台.写入行（错误）。到 String（））;
}
添加新的 HTTP 任务
控制台.Writeline（”*创建 HTTP 任务*”）;
结果Str = 请求（”任务类型/” = 设备。Platform_Id，请求方法.GET，字符串.空）;
var tts = 序列化器。序列化 < 任务类型 > *（结果斯特）;
var httpTT = tts。单（tt = > tt。名称.ToLower（） = “http”;
var 任务 = 新的 HTTPTask
{
Device_Id = 新设备 Id，
Task_Type_Id = httpTT.Id，
名称 = “新 HTTP 任务”，
超时 = 100500，
请求类型 = “GET”，
Url = “amazon.de”
};
尝试
{
结果=请求（”任务？动词_PUT”，RequestMethod.POST，
序列化器。序列化（任务）;
var 结果 = 序列化器。去序列化 < Operatio结果 > （结果斯特）;
控制台.写入行（结果。到 String（））;
}
渔获（例外前）
{
var 错误 = 序列化器。反序列 < 化错误结果 > （例如消息;
控制台.写入行（错误）。到 String（））;
}

获取计划程序
控制台.Writeline（”*获取计划程序*”）;
var ss = 序列化器。反序列化 < > int_（请求（”计划程序”，请求方法.GET，字符串.空）;
每个（在 sss 中）的 vars）
{
控制台.写入线（序列化器。反序列化 < 计划程序 > （”计划程序/”=s，请求方法.GET，字符串.空））;”
}
创建新的计划程序
控制台.WriteLine（”*创建新的调度程序*”）;
var 调度程序 = 新计划程序
{
名称 = “新建”，
描述 = “descr”，
Date_Time_Intervals = 新*
{
新的日期时间间隔
{
从 = （长） （新的日期时间 （2， 2， 2， 0， 0） – UnixBaseTime）。总毫秒，
至 = （长） （新日期时间（2013， 2， 2， 30， 0） – UnixBaseTime）。总毫秒，
}
},
Weekly_Intervals = 新*
{
新的每周间隔
{
天 = 新 *”mo”，”tu”，”sa”，、
From_Min = （int） 新的 TimeSpan （7， 0， 0）。总分钟数，
To_Min = （int） 新的 TimeSpan （13， 0， 0）。总分钟数，
包含 = 错误
}
}
};
尝试
{
结果St = 请求（”计划程序”，verb_PUT”，RequestMethod.POST，
序列化器。序列化（调度程序）;
var 结果 = 序列化器。去序列化 < Operatio结果 > （结果斯特）;
控制台.写入行（结果。到 String（））;
}
渔获（例外前）
{
var 错误 = 序列化器。反序列 < 化错误结果 > （例如消息;
控制台.写入行（错误）。到 String（））;
}
控制台.阅读键（）;
}
}
}