Using XML RPC With VB.NET

What is XML RPC?

XML RPC is a standard for calling functions / passing parameters to these functions / retrieving return values from these functions. The caller program and the called function typically exist on separate machines. If a server is available and it provides some functions then a client anywhere can call these functions via a simple HTTP (or HTTPS) URL.

The parameters are sent from the client to the server in a form of XML text. The server then receives the parameters and carries out the actions required by the to be called function. The return value is then returned to the client in the form of XML text as well. All this communication is performed via the more than widely used HTTP (or HTTPS) protocol. It's obvious from the above calling structure that XML RPC is totally platform independent and that it can be employed in virtually any environment due to the simplicity / effectiveness of the calling structure.

This tutorial will teach the reader how to implement an XML RPC capable client from VB.NET application and what the external components that can be used to achieve this target.

XML RPC Server and Client

XML RPC Server

Any kind of web services those are located in a server machine.

XML RPC Client

Is the program located on your machine and sends a request to a web service located on XML RPC server.

In this tutorial we will build a client application and use a test server available for test operations.

XML RPC in Microsoft .NET Framework with VB.NET

Although widely used, there is no native support for XML RPC in Microsoft .NET. Fortunately, there is a well established XML RPC library written by Charles Cook specifically for this purpose and called XML-RPC.Net. XML-RPC.Net is a .NET class library for implementing XML-RPC clients and servers.

You can obtain XML-RPC.Net from www.xml-rpc.net

Inside the download you will find the 'CookComputing.XmlRpc.dll' which is the DLL / Assembly that represents the xml-rpc.net library. The responsibility of this library is to put your ordinal function call into a form suitable to the used transfer protocol (In other words forms it into a packet), open the connection; send a request to the server containing the requested web service. The server run the request (run the called method) then returns the result to the xml-rpc.net library. The xml-rpc.net library will parse the incoming package, extracts the result from it, and returns it as a normal type to the called method. All the transfers in the above scenario are done using the XML language.

How to setup the XML-RPC.Net library into your VB.NET project?

To make use of the xml-rpc.net library inside your .net project you have to do the followings:

- Put the 'CookComputing.XmlRpc.dll' library in the same directory with the project's executable file (.EXE).
- Add a reference to the library in to your project by using the references node in Solution Explorer window.
- Add a reference to the 'CookComputing.XmlRpc' namespace in the 'imports' section at the top of your source code file as shown below.

Imports CookComputing.XmlRpc

Now the XML-RPC.Net library is set-up into your project and you can write code to make use of it.

Writing source code that makes use of XML-RPC.Net

We will build a small program that makes a simple addition operation. We will use the test math service available at "http://www.cookcomputing.com/xmlrpcsamples/math.rem"

Open up your Visual Studio 2005 and create a new Visual Basic project. In the 'Solution Explorer' window, left click the project name and click 'Add Reference...' on the appeared pop up menu as shown below.

Figure 1 - The Add Reference dialog box

Click the 'Browse' tab of the 'Add Reference' dialog box. Browse to the project's 'Bin' directory where you put your 'CookComputing.XmlRpc.dll' file. Select it then click 'Ok'. The DLL is now added to the references section of your project.

Design a suitable graphical user interface as the following one.

Figure 2 - Graphical User Interface

From the properties window name the first text box "TB_Num1", name the second one "TB_Num2", name the button "Btn_Add", and finally name the label "Lbl_Result".

Double click the form body to activate the Form1's load event handler, and double click the button to activate its click event handler. Now view the source code file of 'Form1'. At the top of the code file add the following imports statement to removes the need to qualify names when you use any defined methods or types from the referenced DLL.

Imports CookComputing.XmlRpc

To be able to perform calls to the needed services you have to do the followings:

Define the following interface outside the "Form1" class scope. Just put it on top of the "Form1" class declaration.

Interface IMath
<CookComputing.XmlRpc.XmlRpcMethod("math.Add")> _
Function Add(ByVal a As Integer, ByVal b As Integer) As Integer

End Interface

The above lines of code define a new interface called "IMath". Inside the interface is a function called "Add" takes two integer parameters and returns an integer as a result. The purpose of the line above the function prototype is to provide the suitable association between the declared 'Add' function and its counterpart in the test math services. So, when you type "Add(a,b)" in your code the "math.Add" function (which is located at the XML RPC server) will be called instead.

In the "Form1" class define the following variables.

Private mathProxy As IMath
Private ClientProtocol As XmlRpcClientProtocol
Private TxtUrl As String

As you see the first line defines a variable of the type "IMath". The second one defines a "ClientProtocol" variable of type "XmlRpcClientProtocol" which is a predefined type in the "CookComputing.XmlRpc" namespace. The last line defines an ordinary string variable.

In the "Form1_Load" event handler add the following lines of code.

Private Sub Form1_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load

    mathProxy = CType(XmlRpcProxyGen.Create(GetType(IMath)), IMath)
    ClientProtocol = CType(mathProxy, XmlRpcClientProtocol)
    TxtUrl = "http://www.cookcomputing.com/xmlrpcsamples/math.rem"
End Sub

The first line of code in this function calls the static "Create" method of "XmlRpcProxyGen" to create an instance of a dynamically generated class which implements the interface and derives from "XmlRpcClientProtocol". The second line returns the result of explicitly converting the "mathProxy" into "XmlRpcClientProtocol" type. The third line just assigns the URL of the server providing the XML RPC service. Note that the same URL could be used for a set of services (functions) like 'Subtract', 'Multiply', or 'Divide'.

In the 'Btn_Add_Click' event handler add the following lines of code.

Private Sub Btn_Add_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles Btn_Add.Click

    ClientProtocol.Url = TxtUrl
    Cursor = Cursors.WaitCursor

    Try
        Me.Lbl_Result.Text = ""
        Dim a As Integer = Me.TB_Num1.Text
        Dim b As Integer = Me.TB_Num2.Text
        Dim result As Integer = mathProxy.Add(a, b)
        Me.Lbl_Result.Text = result.ToString
    Catch ex As Exception
        MsgBox(ex.Message.ToString)
    End Try
    Cursor = Cursors.Default
End Sub

ClientProtocol.Url = TxtUrl assigns the URL of the test server to the 'ClientProtocol' URL property. In the 'Try' block we assign the two numbers written in text boxes to variables 'a' and 'b'. The mathProxy.Add(a, b) function of the defined 'mathproxy' is called and the result is assigned to the 'result' variable. Then the result is displayed in the label as shown below.

Figure 3 - This simple add operation is done in another server machine not on the current machine that runs the program.

You can download sample Using RPC With VB.NET sample Visual Studio project, used in this tutorial.

Tutorial toolbar: Tell A Friend | Add to favorites | Feedback |