public JsonHCSProxyGenerator(JsonHCS jsonHCS = null, params IProxyPlugin[] plugins)
{
this.jsonHCS = jsonHCS ?? new JsonHCS(true);
if (plugins.Length == 0)
{
plugins = new IProxyPlugin[] { new ActionResultPlugin(), new BasicPlugin() };
}
proxyGenerator = new ProxyGenerator();
pluginManager = new PluginManager(plugins);
}
public Task <T> Handle <T>(JsonHCS jsonHCS, string route, List <Parameter> parameters, Type targetType, IInvocation invocation)
{
foreach (var plugin in Plugins.Where(p => p.IsHandler))
{
if (plugin.CanHandle(typeof(T), invocation))
{
return(plugin.Handle <T>(this, jsonHCS, route, parameters, targetType, invocation));
}
}
return(Task.FromException <T>(new NotImplementedException("No plugins could handle this request")));
}
static async Task Run()
{
var settings = new JsonHCS_Settings()
{
CookieSupport = true, //I want to support sessions and thus cookies
AddDefaultAcceptHeaders = true, //Adds default acceptance headers for json types
UserAgent = "MyAwesomeSampleAgent" //Because why not, this is usually ignored anyways
};
using (JsonHCS client = new JsonHCS(settings))
{
//Use it
const string Url = "https://www.w3schools.com/jquery/demo_ajax_json.js"; //change to actual url
Console.WriteLine("Get json string:");
var json = await client.GetStringAsync(Url);
Console.WriteLine(json);
Console.WriteLine("Type: " + json.GetType().FullName);
Console.WriteLine();
Console.WriteLine("Get object:");
var obj = await client.GetJsonAsync(Url);
Console.WriteLine(obj);
Console.WriteLine("Type: " + obj.GetType().FullName);
Console.WriteLine();
Console.WriteLine("Get dynamic.firstName:");
dynamic objFN = await client.GetJsonAsync(Url);
Console.WriteLine(objFN.firstName);
Console.WriteLine("Type: " + objFN.firstName.GetType().FullName);
Console.WriteLine();
Console.WriteLine("Get<ExpectedResponce> ToString:");
var ERobj = await client.GetJsonAsync <ExpectedResponce>(Url);
Console.WriteLine(ERobj);
Console.WriteLine("Type: " + ERobj.GetType().FullName);
Console.WriteLine();
Console.WriteLine("Get JObject[\"firstname\"]:");
var JObj = await client.GetJObjectAsync(Url);
Console.WriteLine(JObj["firstName"]);
Console.WriteLine("Type: " + JObj["firstName"].GetType().FullName);
Console.WriteLine();
}
}
public override Task <T> Handle <T>(PluginManager manager, JsonHCS jsonHCS, string route, List <Parameter> parameters, Type targetType, IInvocation invocation)
{
if (targetType == typeof(HubConnection))
{
return(CreateOrGetHub(route) as Task <T>);
}
if (targetType.IsConstructedGenericType && (targetType.GetGenericTypeDefinition() == typeof(HubConnection <>) || targetType.GetGenericTypeDefinition() == typeof(HubConnection <,>)))
{
return(Convert <T>(CreateOrGetHubObject(route, targetType)));
}
if (GetAttribute <HubMethodAttribute>(invocation.Method) is HubMethodAttribute att)
{
return(InvokeOnHub <T>(att, route, targetType, invocation));
}
return(Task.FromException <T>(new NotSupportedException("The method invocation was not supported")));
}
private void _CreateAPI()
{
WebClient = new JsonHCS(new JsonHCS_Settings()
{
CookieSupport = true,
AddDefaultAcceptHeaders = true,
UserAgent = "PlugSharp",
//Host = "plug.dj",
//AcceptLanguage = "en-US, en; q=0.5",
//Referer = "https://plug.dj/nightcore-331",
//Origin = "https://plug.dj"
});
var pg = new JsonHCSNet.Proxies.JsonHCSProxyGenerator(WebClient);
API = pg.CreateClassProxy <PlugAPI>();
}
protected static bool GetBodyOrFormContent(JsonHCS jsonHCS, List <Parameter> parameters, out HttpContent content)
{
var bodyContent = GetBodyContent(parameters);
if (bodyContent != null)
{
content = new StringContent(jsonHCS.SerializeJson(bodyContent));
content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
return(true);
}
var formContent = GetFormContent(parameters);
if (formContent.Count() > 0)
{
content = new FormUrlEncodedContent(formContent);
return(true);
}
content = null;
return(false);
}
public override Task <T> Handle <T>(PluginManager manager, JsonHCS jsonHCS, string route, List <Parameter> parameters, Type targetType, IInvocation invocation)
{
//Get HttpResponseMessage with default implementation
var task = manager.Handle <System.Net.Http.HttpResponseMessage>(jsonHCS, route, parameters, typeof(System.Net.Http.HttpResponseMessage), invocation);
Task <T> returntask;
//implement own usage
if (targetType.IsConstructedGenericType)
{
returntask = this.GetType().GetMethod("GetActionResultT").MakeGenericMethod(targetType.GetGenericArguments().First()).Invoke(this, new object[] { task, jsonHCS }) as Task <T>;
}
else if (typeof(ApiDefinition.ActionResult) == targetType)
{
returntask = GetActionResult(task, jsonHCS) as Task <T>;
}
else
{
returntask = GetIActionResult(task, jsonHCS) as Task <T>;
}
return(returntask);
}
public override async Task <T> Handle <T>(PluginManager manager, JsonHCS jsonHCS, string route, List <Parameter> parameters, Type targetType, IInvocation invocation)
{
route = ApplyRouteParameters(route, parameters);
route = ApplyQueryParameters(route, parameters);
var headers = GetHeaders(parameters);
var method = FindHttpMethod(invocation.Method, parameters);
if (method == HttpMethod.Get && targetType == typeof(System.IO.Stream))
{
return((T)(object)await jsonHCS.GetStreamAsync(route).ConfigureAwait(false));
}
else if (method == HttpMethod.Get && targetType == typeof(System.IO.MemoryStream))
{
return((T)(object)await jsonHCS.GetMemoryStreamAsync(route).ConfigureAwait(false));
}
GetBodyOrFormContent(jsonHCS, parameters, out HttpContent content);
var completion = HasAttribute(invocation.Method, typeof(HeaderHttpCompletionOptionAttribute)) ? HttpCompletionOption.ResponseHeadersRead : HttpCompletionOption.ResponseContentRead;
var response = await jsonHCS.SendRequestAsync(method, route, content, headers, completion).ConfigureAwait(false);
if (targetType == typeof(void) || targetType == typeof(HttpResponseMessage))
{
return((T)(object)response);
}
else if (HasAttribute(invocation.Method, typeof(RawStringAttribute)))
{
return((T)(object)await JsonHCS.ReadContentAsString(response).ConfigureAwait(false));
}
else if (targetType == typeof(JObject))
{
return((T)(object)jsonHCS.DeserializeJObject(await JsonHCS.ReadContentAsString(response).ConfigureAwait(false)));
}
else
{
return(jsonHCS.DeserializeJson <T>(await JsonHCS.ReadContentAsString(response).ConfigureAwait(false)));
}
}
public override Task <string> GetStringAsync()
{
return(JsonHCS.ReadContentAsString(Response));
}
public GenericResult(HttpResponseMessage Response, JsonHCS jsonHCS)
{
response = Response;
this.jsonHCS = jsonHCS;
}
static async Task Run()
{
var client = new JsonHCS(new JsonHCS_Settings()
{
Timeout = 10000, ThrowOnFail = true, CatchErrors = false, AddJsonAcceptHeaders = true
});
JsonHCSProxyGenerator pg = new JsonHCSProxyGenerator(client, new SignalRPlugin(), new ActionResultPlugin(), new BasicPlugin());
var proxy = pg.CreateClassProxy <ValuesController>("http://localhost:5000/");
await Task.Delay(5000);
for (int o = 0; o < 4; o++)
{
//Proxy speed comparison:
Stopwatch s = new Stopwatch();
s.Start();
for (int i = 0; i < 400; i++)
{
var all = await client.GetJsonAsync <IEnumerable <string> >("http://localhost:5000/api/values");
//Console.WriteLine(all.Count());
var one = await client.GetJsonAsync("http://localhost:5000/api/values/2");
//Console.WriteLine(one);
await client.PostAsync("http://localhost:5000/api/values", "Value");
//Console.WriteLine("Done");
}
s.Stop();
Console.WriteLine("Direct:");
Console.WriteLine(s.ElapsedMilliseconds);
s.Reset();
s.Start();
for (int i = 0; i < 400; i++)
{
var allrequest = await proxy.Get();
if (allrequest.IsSuccess)
{
var all = await allrequest.GetResultAsync();
//Console.WriteLine(all.Count());
}
var one = await(await proxy.Get(2)).GetResultAsync();
//Console.WriteLine(one);
var post = await proxy.Post("Value");
//Console.WriteLine(post.IsSuccess ? "Done" : "Failed");
}
s.Stop();
Console.WriteLine("Proxy:");
Console.WriteLine(s.ElapsedMilliseconds);
}
//SignalR plugin demo:
var api = pg.CreateClassProxy <API>("http://localhost:5000/");
var hub = await api.Connect();
hub.On.Receive += On_Receive;
var received = 0;
using (hub.On.Message.Subscribe(s => { Console.WriteLine($"{DateTime.Now.TimeOfDay}: Subscription was updated to: {s}"); received++; }, () => Console.WriteLine($"{DateTime.Now.TimeOfDay}: Subscription closed!")))
{
Console.WriteLine($"{DateTime.Now.TimeOfDay}: Sending Test 1");
await hub.Send.Broadcast("Test 1");
Console.WriteLine($"{DateTime.Now.TimeOfDay}: Sending Test 2");
await hub.Send.Broadcast("Test 2");
Console.WriteLine($"{DateTime.Now.TimeOfDay}: Sending Test 3");
await hub.Send.Broadcast("Test 3");
while (received < 3)
{
await Task.Delay(10);
}
}
}
public async Task <ApiDefinition.ActionResult <T> > GetActionResultT <T>(Task <System.Net.Http.HttpResponseMessage> response, JsonHCS jsonHCS)
{
return(new ActionResultSupport.GenericResult <T>(await response.ConfigureAwait(false), jsonHCS));
}
public abstract Task <T> Handle <T>(PluginManager manager, JsonHCS jsonHCS, string route, List <Parameter> parameters, Type targetType, IInvocation invocation);
internal JsonHCSProxy(PluginManager pluginManager, JsonHCS jsonHCS, string baseUrl)
{
this.pluginManager = pluginManager;
this.jsonHCS = jsonHCS;
this.baseUrl = baseUrl;
}
