Dado o exemplo escrito em C# contém os seguintes padrões:

C# Exemplo

utilizando o Sistema;
usando System.Linq;
usando System.Collections.Generic;
usando System.IO;
usando System.Net;
usando System.Text;
usando System.Web.Script.Serialization;
exemplo de espaço de nome
{
Programa de classe
{
classe OperatioResult
{
público bool Sucesso { get; set; }
resultado de cadeia pública { obter; definir; }
fio de substituição pública ToString()
{
retorno String.Format(“Sucesso: {0} ; Resultado: {1} “, Sucesso, Resultado);
}
}
Erro de classeResult
{
público bool Sucesso { get; set; }
string pública[] ErroDescrição { obter; definir; }
fio de substituição pública ToString()
{
retorno String.Join (Environment.NewLine, ErrorDescription);
}
}
plataforma de classe
{
público int Id { get; set; }
nome da cadeia pública { get; set; }
bool público disponível { obter; definir; }
fio de substituição pública ToString()
{
retorno String.Format(“Id: {0} ; Nome: {1} ; Disponível: {2} “, Id, Nome, Disponível);
}
}
Monitor de classe
{
público int Id { get; set; }
nome da cadeia pública { get; set; }
bool público disponível { obter; definir; }
bool público IsDeleted { get; set; }
público bool IsPrivate { get; set; }
fio de substituição pública ToString()
{
retorno String.Format(“Id: {0} ; Nome: {1} ; Disponível: {2} ; Excluído: {3} ; IsPrivate: {4} “,
ID, Nome, Disponível, Excluído, ÉPrivate);
}
}
classe WeeklyInterval
{
cadeia pública[] Dias { obter; definir; }
int público From_Min { obter; definir; }
int público To_Min { obter; definir; }
bool público Incluído { obter; definir; }
fio de substituição pública ToString()
{
retorno String.Format(“Dias: [{0}]; From_Min: {1} (Tempo: {4}); To_Min: {2} (Tempo: {5}); incluso: {3}”,
String.Join(“, “Dias), From_Min, To_Min, Incluído, TimeSpan.FromMinutes(From_Min), TimeSpan.FromMinutes(To_Min));
}
}
classe DateTimeInterval
{
público longo De { obter; definir; }
público longo Para { obter; definir; }
fio de substituição pública ToString()
{
retorno String.Format(“De: {0} (Tempo: {2} ); Para: {1} (Tempo: {3} )”,
De, To, UnixBaseTime.AddMilliseconds(From), UnixBaseTime.AddMilliseconds(To));
}
}
classe AtribuídoToInfo
{
resumo
ler apenas
/resumo
int[] Dispositivos públicos { obter; definir; }
resumo
ler apenas
/resumo
int[] público int[] Notification_Groups { obter; definir; }
fio de substituição pública ToString()
{
retorno String.Format(“Dispositivos: [ {0} ]; Notification_Groups: {1} []”,
String.Join(“, Devices.Select(id = > id.ToString()). ToArray()),
String.Join(“, Notification_Groups.Select(id = > id.ToString()). ToArray());
}
}
agendador de classe
{
público int Id { get; set; }
nome da cadeia pública { get; set; }
descrição da sequência pública { obter; definir; }
public WeeklyInterval[] Weekly_Intervals { get; set; }
datatimeinterval público[] Date_Time_Intervals { obter; definir; }
público AtribuídoToInfo Assigned_To { obter; definir; }
fio de substituição pública ToString()
{
retorno String.Format(“Id: {0}; nome: {1}; descrição: {2}; Weekly_Intervals:{3}]; Date_Time_Intervals:{4}]; Atribuído AoInfo: {5}”,
ID, Nome, Descrição,
String.Join(“, Weekly_Intervals.Select(wi = > wi. ToString()). ToArray()),
String.Join(“, Date_Time_Intervals.Select(dti = > dti. ToString()). ToArray()), Assigned_To);
}
}
classe SiteNotifyGroup
{
público int Id { get; set; }
int público Time_Shift_Min { obter; definir; }
}
Notificações de classe
{
público bool E_Mail_Flag { obter; definir; }
E_Mail_Address de cadeia pública { obter; definir; }
int público E_Mail_TimeInterval_Min { obter; definir; }
público bool WL_Device_Flag { obter; definir; }
WL_Device_Email_Address de cadeia pública { obter; definir; }
int público WL_Device_TimeInterval_Min { obter; definir; }
público bool Phone_Flag { obter; definir; }
Phone_Area_Code de cadeia pública { obter; definir; }
Phone_Phone de cordas públicas { obter; definir; }
int público Phone_TimeInterval_Min { obter; definir; }
público bool SMS_Flag { obter; definir; }
SMS_Phone de cordas públicas { obter; definir; }
público int SMS_TimeInterval_Min { obter; definir; }
público bool Script_Flag { obter; definir; }
Script_Batch_File_Name de cordas públicas { obter; definir; }
int público Script_TimeInterval_Min { obter; definir; }
int público SNMP_TimeInterval_Min { obter; definir; }
sitenotifygroup público[] Notification_Groups { obter; definir; }
}
serverViewDevice classe
{
público int Id { get; set; }
int público Platform_Id { obter; definir; }
nome da cadeia pública { get; set; }
público int Number_Of_Tasks { obter; definir; }
Status_Description de cadeia pública { obter; definir; }
público bool Adiar { get; set; }
público bool Send_Uptime_Alert { obter; definir; }
int público Owner_Device_Id { obter; definir; }
frequência int pública { obter; definir; }
int público Filter_Id { obter; definir; }
int público Scheduler_Id { obter; definir; }
Notificações públicas Notificações { obter; definir; }
público bool Avoid_Simultaneous_Checks { obter; definir; }
público bool False_Positive_Check { obter; definir; }
int público Alert_Silence_Min { obter; definir; }
int[] Localizações públicas { obter; definir; }
}
TaskType classe
{
público int Id { get; set; }
nome da cadeia pública { get; set; }
}
classe NameValuePair
{
nome da cadeia pública { get; set; }
valor de cadeia pública { obter; definir; }
}
classe HTTPTask
{
int público Device_Id { obter; definir; }
público int Id { get; set; }
público int Task_Type_Id { obter; definir; }
nome da cadeia pública { get; set; }
public int Timeout { get; set; }
public string RequestType { get; set; }
Url de string pública { get; set; }
string pública Keyword1 { get; set; }
string pública Keyword2 { get; set; }
string pública Keyword3 { get; set; }
nome de usuário de string pública { obter; definir; }
cadeia pública UserPass { get; set; }
público bool FullPageDownload { get; set; }
público bool Download_Html { obter; definir; }
público bool Download_Frames { obter; definir; }
público bool Download_StyleSheets { obter; definir; }
público bool Download_Scripts { obter; definir; }
público bool Download_Images { obter; definir; }
público bool Download_Objects { obter; definir; }
público bool Download_Applets { obter; definir; }
público bool Download_Additional { obter; definir; }
nome públicoValuePair[] GetParams { get; set; }
nome públicoValuePair[] PostParams { get; set; }
nome públicoValuePair[] HeaderParams { get; set; }
string PrepareScript { get; set; }
}
enum RequestMethod
{
Obter
Postar
}
recipiente cookiecontainer estático privado;
leitura estática pública apenas DateTime UnixBaseTime = novo DateTime(1970, 1, 1, 0, 0, 0, 0, 0);
configuração função de solicitação
solicitação de sequência estática privada (ação de sequência de string, RequestMethod requestType, dados de sequência)
{
Solicitação webrequest = WebRequest.Criar(“https://api.dotcom-monitor.com/config_api_v1/” + ação);
pedir. Método = solicitaçãoType.ToString();
((HttpWebRequest). CookieContainer = recipiente;
se (solicitarType == RequestMethod.POST)
{
string postData = dados;
se (postData.Length > 0)
{
byte[] byteArray = Encoding.UTF8.GetBytes(postData);
pedir. ContentType = “application/json”;
pedir. ContentLength = byteArray.Length;
Fluxo de dadosStream = solicitação. GetRequestStream();
dataStream.Write(byteArray, 0, byteArray.Length);
}
mais
{
pedir. ContentLength = 0;
}
}
tentar
{
usando (resposta do var = solicitação. GetResponse())
{
usando (fluxo var = resposta. GetResponseStream())
{
se (fluxo != nulo)
{
usando (leitor de var = novo StreamReader(stream))
{
leitor de retorno. ReadToEnd();
}
}
}
}
}
pegar (exceção ex)
{
usando (fluxo var = ex. Response.GetResponseStream())
{
usando (leitor de var = novo StreamReader(stream))
{
lançar nova exceção (leitor. ReadToEnd());
}
}
}
sequência de retorno.Vazio;
}

vazio estático Principal()
{
ignorar erros de certificado
ServicePointManager.ServerCertificateValidationCallback = delegado { retorno verdadeiro; };
inicializar recipiente de biscoito
contêiner = novo CookieContainer();
inicializar serializador javascript
serializador var = novo JavaScriptSerializer();
login
Console.WriteLine(“==Login==”);
resultado da sequência,
tentar
{
resultStr = Solicitação(“login”, RequestMethod.POST,
serializador. Serialize(
novo {
Nome de usuário = “1”,
Senha = “1”
}
));
resultado var = serializador. Deserializar < OperatioResult > (resultadoStr);
Console.WriteLine (resultado). ToString());
}
pegar (exceção ex)
{
var err = serializador. Deserializar < ErrorResult > (ex. Mensagem);
Console.WriteLine(err. ToString());
}
obter plataformas
Console.WriteLine(“==Obter plataformas==”);
Plataformas iEnumerable < > – nulas;
tentar
{
resultStr = Solicitação(“plataformas”, RequestMethod.GET, String.Empty);
plataformas = serializador. Plataforma deserialização[] < > (resultStr);
}
captura (exceção ex)
{
var err = serializador. Deserializar < ErrorResult > (ex. Mensagem);
Console.WriteLine(err. ToString());
}
foreach (plataforma var em plataformas)
{
Console.WriteLine (plataforma);
}
obter dispositivos por plataforma
Console.WriteLine(“==Obter dispositivos por plataforma==”);
int svDeviceId = 0;
foreach (plataforma var em plataformas. Onde (p = > p.Disponível))
{
resultStr = Solicitação(String.Format(“dispositivos/”, {0} plataforma. Nome), RequestMethod.GET, String.Empty);
var ds = serializador. Deserializar < int[] > (resultStr);
foreach (var id in ds)
{
se (svDeviceId == 0 && e plataforma. ID == 1)
{
svDeviceId = id;
}
Console.WriteLine(” {0} – {1} “, plataforma. Nome, id);
}
}
obter serverView dispositivo por id
Console.WriteLine(“==Obter dispositivo por id==”);
resultStr = Solicitação(String.Format(“dispositivo/ {0} “, svDeviceId), RequestMethod.GET, String.Empty);
dispositivo var = serializador. Deserializar < ServerViewDevice > (resultStr);
editar dispositivo
Console.WriteLine(“==Editar dispositivo==”);
dispositivo. Nome = dispositivo. Nome + ” (editado)”;
tentar
{
resultStr = Solicitação(String.Format(“dispositivo/ {0} “, dispositivo. Id), RequestMethod.POST,
serializador. Serialize(dispositivo));
resultado var = serializador. Deserializar < OperatioResult > (resultadoStr);
Console.WriteLine (resultado). ToString());
}
pegar (exceção ex)
{
var err = serializador. Deserializar < ErrorResult > (ex. Mensagem);
Console.WriteLine(err. ToString());
}
obter monitores
Console.WriteLine(“==Get monitores==”);
Monitor iEnumerable < > = serializador. Monitor deserialização[] < > (Request(String.Format(“locais/”, {0} dispositivo. Platform_Id),
RequestMethod.GET, String.Empty));
foreach (monitor do VAR em monitores)
{
Console.WriteLine(monitor);
}
obter frequências
Console.WriteLine(“==Obter frequências==”);
frequências var = serializador. Deserializar < int[] > (Request(String.Format(“frequências/ {0} “, dispositivo. Platform_Id),
RequestMethod.GET, String.Empty));
foreach (frequência var em frequências)
{
Console.WriteLine(frequência);
}
obter grupos de notificação
Console.WriteLine(“==Obter grupos de notificação==”);
var ngs = serializador. Deserializar < int[] > (Solicitação(“grupos”, RequestMethod.GET, String.Empty));
foreach (var ng in ngs)
{
Console.WriteLine(ng);
}
criar novo dispositivo
Console.WriteLine(“==Criar dispositivo==”);
dispositivo = novo ServerViewDevice
{
Platform_Id = plataformas. Single(p = > p.Name.ToLower() == “serverview”). id
Nome = “novo dispositivo”,
Frequência = frequência[0],
Adiar = verdadeiro,
Localizações = monitores. Onde(m = > m.Disponível && !m.IsPrivate && (m.Id%2 == 0)). Selecione(m = > m.Id). ToArray(),
Avoid_Simultaneous_Checks = verdade,
Notificações = novas Notificações
{
E_Mail_Flag = falso,
Pager_Flag = falso,
Phone_Flag = falso,
SMS_Flag = falso,
Script_Flag = falso,
WL_Device_Flag = falso,
Notification_Groups = ngs. Tome(1). Selecione(ng = > novo SiteNotifyGroup {Id = ng, Time_Shift_Min = 0 /*0 = Imediato*/}). ToArray()
}
};
int newDeviceId = 0;
tentar
{
resultStr = Solicitação (“dispositivos?verb=PUT”, RequestMethod.POST,
serializador. Serialize(dispositivo));
resultado var = serializador. Deserializar < OperatioResult > (resultadoStr);
newDeviceId = int. Parse (resultado). Resultado);
Console.WriteLine (resultado). ToString());
}
pegar (exceção ex)
{
var err = serializador. Deserializar < ErrorResult > (ex. Mensagem);
Console.WriteLine(err. ToString());
}
adicionar nova tarefa HTTP
Console.WriteLine(“==Criar tarefa HTTP==”);
resultStr = Solicitação (“tipos de tarefas/” + dispositivo. Platform_Id, RequestMethod.GET, String.Empty);
var tts = serializador. Deserializar < TaskType[] > (resultStr);
var httpTT = tts. Single(tt = > tt. Name.ToLower() == “http”);
tarefa var = novo HTTPTask
{
Device_Id = novoDeviceId,
Task_Type_Id = httpTT.Id,
Nome = “Nova tarefa HTTP”,
Tempo limite = 100500,
RequestType = “GET”,
URL = “amazon.de”
};
tentar
{
resultStr = Solicitação(“tarefas?verb=PUT”, RequestMethod.POST,
serializador. Serializar(tarefa));
resultado var = serializador. Deserializar < OperatioResult > (resultadoStr);
Console.WriteLine (resultado). ToString());
}
pegar (exceção ex)
{
var err = serializador. Deserializar < ErrorResult > (ex. Mensagem);
Console.WriteLine(err. ToString());
}

obter agendadores
Console.WriteLine(“==Get schedulers==”);
var ss = serializador. Deserializar < int[] > (Solicitação(“agendadores”, RequestMethod.GET, String.Empty));
foreach (var s in ss)
{
Console.WriteLine (serializador. Agendador deserialização < > (“Agendador/” + s, RequestMethod.GET, String.Empty));
}
criar novos agendadores
Console.WriteLine(“==Criar novos agendadores==”);
cronograma do VAR = novo Agendador
{
Nome = “Novo”,
Descrição = “descr”,
Date_Time_Intervals = novo[] {
novo DateTimeInterval
{
De = (longo) (novo DateTime(2013, 2, 2, 2, 0, 0, 0) – UnixBaseTime). TotalMilliseconds,
Para = (longo) (novo DateTime(2013, 2, 2, 2, 2, 30, 0, 0) – UnixBaseTime). TotalMilliseconds,
}
},
Weekly_Intervals = novo[] {
novo WeeklyInterval
{
Dias = novo[] {“mo”, “tu”, “sa”},
From_Min = (int) novo TimeSpan(7, 0, 0). TotalMinutes,
To_Min = (int) novo TimeSpan(13, 0, 0). TotalMinutes,
Incluído = falso
}
}
};
tentar
{
resultStr = Solicitação(“schedulers?verb=PUT”, RequestMethod.POST,
serializador. Serialize(agendador));
resultado var = serializador. Deserializar < OperatioResult > (resultadoStr);
Console.WriteLine (resultado). ToString());
}
pegar (exceção ex)
{
var err = serializador. Deserializar < ErrorResult > (ex. Mensagem);
Console.WriteLine(err. ToString());
}
Console.ReadKey();
}
}
}