You need to know the url (web address) of the web service
You need to understand what the web service will return
You need to know what kind of security the web service accepts (My example uses Basic Authentication)
You need to understand under which context you are consuming the service (My example uses a Proxy server to communicate)

I found a site that automatically generates a class based on the result of the JSON web service at http://json2csharp.com/. This site can generate an class either by you specifying the url to the web service or providing the JSON result from the service you wish to consume.

Lets just assume in the example that my service will return {“variable1″:1,”variable2″:”a return string”}

By definition this means one variable with an int and one with a string.

JSON2CSHARP will return a usable class for me to use in my code;

public class RootObject
{
    public int variable1 { get; set; }
    public string variable2 { get; set; }
}

Lets go ahead and add some more code to consume this now when we have a nice helper class to contain my result.

string url = “http://yourserver/service?someparams=somevalue“;

HttpWebRequest wr = (HttpWebRequest)WebRequest.Create(url);
string username = “username”;
string password = “********”;

// Use the CredentialCache so we can attach the authentication to the request
CredentialCache mycache = new CredentialCache();

// We want to use Basic Authentication
mycache.Add(new Uri(url), “Basic”, new NetworkCredential(username, password));
wr.Credentials = mycache;
wr.Headers.Add(“Authorization”, “Basic ” + Convert.ToBase64String(new ASCIIEncoding().GetBytes(username + “:” + password)));

// Proxy (if you do not need it – ommit it)
wr.Proxy = new WebProxy(http://proxyserver:8080);

// Get the response from the web service
HttpWebResponse response = (HttpWebResponse)wr.GetResponse();
Stream r_stream = response.GetResponseStream();

//convert it
StreamReader response_stream = new StreamReader(r_stream, System.Text.Encoding.GetEncoding(“utf-8″));

string jSon = response_stream.ReadToEnd();

//clean up your stream
response_stream.Close();

System.Web.Script.Serialization.JavaScriptSerializer jsSerializer = new System.Web.Script.Serialization.JavaScriptSerializer();
 RootObject result = jsSerializer.Deserialize<RootObject>(jSon);

http://msdn.microsoft.com/en-us/library/cc151052.aspx

//extract from the link above

// my own code comes here

The other way is of course to authenticate youself by providing this information to CRM Web service.

account account = new account();

account.name = “Fabrikam”;

Guid accountid = crmService.Create(account);

http://msdn.microsoft.com/en-us/library/ms531033(VS.85).aspx

Don’t forget that the webservice.htc file needs to be downloaded aswell.

What you will find is that when a web service proxy is generated the class is substituted with a newly created class that mimics the public properties of your class but it is really not the same class. This means you can not typecast between them.

Solution 1 would be to hijack the Reference.cs, make sure you are using the namespace where you class resides and finally remove the class specification from the file. The disadvantage is that each time a web reference is refreshed, these changes are lost.

Solution 2 would make sure that your changes are kept, because you can specifiy that certain classes should not be replaced by a new proxy version.

http://www.microsoft.com/belux/msdn/nl/community/columns/jdruyts/wsproxy.mspx

Either you create a reference to the CRM Web service in your Visual Studio project and the proxy classes are generated.

Or you can reference microsoft.crm.sdk.dll and microsoft.crm.sdktypeproxy.dll that exists&nbsp;in the CRM SDK.

You will soon notice that if you create a Request object, or maybe a BusinessEntity, DynamicEntity they are not compatible with eachother, and furthermore they might not even have the same methods and properties.

My recommendation is to use the CRM SDK only and never create a Web reference from within Visual Studio. The CRM SDK objects have more friendly properties and methods.