Getting a POST endpoint to work in self-hosted (WebServiceHost) C# webservice?
So, I have been messing around with webservices for a while now, and I keep getting back to some basics, that I never seem to get right.
Question 1:
When using a WebServiceHost in .NET/C#, you can define a method/endpoint as using GET/POST/etc. Setting up a GET-method is easy and it works pretty much directly, and its easy to understand how it works. For example:
[OperationContract]
[WebInvoke(Method = "GET", UriTemplate = "/PutMessage/{jsonString}", BodyStyle = WebMessageBodyStyle.Bare, ResponseFormat = WebMessageFormat.Json, RequestFormat = WebMessageFormat.Json)]
string PutMessage(string jsonString);
If I call http:///MyWebService/PutMessage/{MyJsonString} I get passed on the the method, and all is well (more or less).
But then what does it mean when I define this as a POST instead?
[OperationContract]
[WebInvoke(Method = "POST", UriTemplate = "/PutMessage/{jsonString}", BodyStyle = WebMessageBodyStyle.Bare, ResponseFormat = WebMessageFormat.Json, RequestFormat = WebMessageFormat.Json)]
string PutMessage(string jsonString);
What does the UriTemplate do here? If I do a POST, I expect the data to be contained not in the URI, but in the "data section" of the post. But do I define the variable name in the data section? How does the WebServiceHost/.NET know that what is contained in the "data section" of the post is to be put into the variable jsonString? How do I post the data from the client side (not C#, let's say JQuery instead) so that it is interpreted correctly on the serer side?
(And how does the WebMessageFormat affet things? I have read everywhere about this (MSDN, Stackoverflow etc) but haven't found a clear and good answer.)
Question 2:
In my attempts to understand this, I thought I'd make a very simple POST-method, like this:
[OperationContract]
[WebInvoke]
string PutJSONRequest(string pc);
I then try call this method using Fiddler, but that does not work at all. I just get a 400 error back, saying "HTTP/1.1 400 Bad Request". I have a breakpoint on the very first line in the code of the method, and the method itself contains nothing:
public string PutJSONRequest(string pc)
{
return null;
}
Again, how does .NET know that what I POSTed using Fiddler should be contained in the "string pc"? How does it interpret it as a string, and what type of string (UT8, ASCII etc)?
This is the RAW HTTP request, sent from Fiddler:
POST http://<myip>:8093/AlfaCustomerApp/PutJSONRequest HTTP/1.1
User-Agent: Fiddler
Host: <myip>:8093
Content-Length: 3
Content-type: application/x-www-form-urlencoded; charset=UTF-8
asd
and it doesnt matter what type of Content-type I use, as far as I can see.
The response is a standard-thing, that I am not in control of myself:
HTTP/1.1 400 Bad Request
Content-Length: 1165
Content-Type: text/html
Server: Microsoft-HTTPAPI/2.0
Date: Mon, 15 Oct 2012 15:45:02 GMT
[then HTML code]
Any help would be appreciated. Thanks.
Solution 1:
I think a simple code can answer all your questions
Task.Factory.StartNew(()=>StartServer());
Thread.Yield();
StartClient();
void StartServer()
{
Uri uri = new Uri("http://localhost:8080/test");
WebServiceHost host = new WebServiceHost(typeof(WCFTestServer), uri);
host.Open();
}
void StartClient()
{
try
{
WebClient wc = new WebClient();
//GET
string response1 = wc.DownloadString("http://localhost:8080/test/PutMessageGET/abcdef");
//returns: "fedcba"
//POST with UriTemplate
string response2 = wc.UploadString("http://localhost:8080/test/PutMessagePOSTUriTemplate/abcdef",
JsonConvert.SerializeObject(new { str = "12345" }));
//returns: fedcba NOT 54321
//POST with BodyStyle=WebMessageBodyStyle.WrappedRequest
//Request: {"str":"12345"}
wc.Headers["Content-Type"] = "application/json";
string response3 = wc.UploadString("http://localhost:8080/test/PutMessagePOSTWrappedRequest",
JsonConvert.SerializeObject(new { str="12345" }));
//POST with BodyStyle=WebMessageBodyStyle.Bare
wc.Headers["Content-Type"] = "application/json";
string response4 = wc.UploadString("http://localhost:8080/test/PutMessagePOSTBare", "12345" );
}
catch (WebException wex)
{
Console.WriteLine(wex.Message);
}
}
[ServiceContract]
public class WCFTestServer
{
[OperationContract]
[WebInvoke(Method = "GET", UriTemplate = "/PutMessageGET/{str}", BodyStyle = WebMessageBodyStyle.Bare, ResponseFormat = WebMessageFormat.Json, RequestFormat = WebMessageFormat.Json)]
public string PutMessageGET(string str)
{
return String.Join("", str.Reverse());
}
[OperationContract]
[WebInvoke(Method = "POST", UriTemplate = "/PutMessagePOSTUriTemplate/{str}", BodyStyle = WebMessageBodyStyle.WrappedRequest, ResponseFormat = WebMessageFormat.Json, RequestFormat = WebMessageFormat.Json)]
public string PutMessagePOSTUriTemplate(string str)
{
return String.Join("", str.Reverse());
}
[OperationContract]
[WebInvoke(Method = "POST", BodyStyle=WebMessageBodyStyle.WrappedRequest, ResponseFormat = WebMessageFormat.Json, RequestFormat = WebMessageFormat.Json)]
public string PutMessagePOSTWrappedRequest(string str)
{
return String.Join("", str.Reverse());
}
[OperationContract]
[WebInvoke(Method = "POST", BodyStyle = WebMessageBodyStyle.Bare, ResponseFormat = WebMessageFormat.Json, RequestFormat = WebMessageFormat.Json)]
public string PutMessagePOSTBare(string str)
{
return String.Join("", str.Reverse());
}
}
PS: You can find the JsonConvert here
Solution 2:
I found out the answer. This is how to define a method, that can take the raw data sent in a HTTP POST:
[OperationContract]
[WebInvoke(BodyStyle=WebMessageBodyStyle.Bare)]
Stream PutMessage(Stream data);
and the implementation is like this:
public Stream PutMessage(Stream data)
{
byte[] buffer = new byte[65535];
int bytesRead, totalBytes = 0;
do
{
bytesRead = data.Read(buffer, 0, 65535);
totalBytes += bytesRead;
}
while (bytesRead > 0);
// Then you could interpret it as a String for example:
string jsonString = Encoding.UTF8.GetString(buffer, 0, totalBytes);
// yada yada
}