- Overview of Web Services and .NET
- Creating a Simple Web Service
- Using a Web Service Within an Application
- Summary
- Q&A
- Workshop
This chapter is from the book
This chapter is from the book
This chapter is from the book
Using a Web Service Within an Application
One of the advantages of Web Services is that they can provide functionality that other applications and even other Web Services can use to build new solutions. You can use Web Services published by other organizations, or you can use your own organization's Web Services. Either way, your use of the Web Service is the same.
In order to demonstrate using a Web Service within an application, create a new managed C++ application named WebServiceApp. The Visual Studio .NET template creates a console application that will work for this test application. You could just as easily use the Web Service from a Windows Form–based application in the same manner.
Adding Web References
Adding a Web reference allows an application to use a Web Service. Adding a Web reference adds proxy classes for the Web Service classes that the application accesses. For example, the Web Service you just created has the MyCPPWebService class. The proxy class has the same name and has stubs in place of the methods. When you use the proxy class, it formats the appropriate request, sends it to the Web Service, and then waits for a response. When the response is received, the proxy class interprets the response and returns it as the return value of the corresponding proxy class method.
Use the Solution Explorer or the Project, Add Web Reference menu item to display the dialog shown in Figure 11.8. This dialog allows you to select a Web service from a UDDI provider or from your local Web server or another Web server, for which you must provide the URL in the address bar. Because the Web Service you want is on your local Web server, select the hyperlink that says "Web References on Local Web Server".
){kind=link}
Once you select the hyperlink, the URL http://localhost/default.vsdisco file is displayed. You will see a list of linked reference groups on the right side. One of these links should be http://localhost/WebService/WebService.vsdisco. Select this hyperlink to display the Web Service you created earlier. Figure 11.9 shows the Web Service and how it is displayed.
){kind=link}
Selecting the Add Reference button adds this Web Service to your new application. When the Web Service is added, Visual Studio builds a proxy class in C# and compiles it automatically. It then also adds the appropriate header file, WebService.h, which loads the WebService.dll component file just compiled. Finally, an XML file named WebService.wsdl is added to the project. It is used to regenerate the C# source file that creates the WebService.dll file.
Figure 11.8 The Add Web Reference dialog in Visual Studio .NET.
Figure 11.9 WebService on localhost shown in the Add Web Reference dialog.
Using a Web Reference
After adding the Web reference to the application, you only need to include the WebService.h file to make the MyCPPWebService proxy class available for use. The WebService.h file contains the necessary code for importing the metadata of your Web Service by using the #using keyword on the proxy DLL that was built when you added the Web reference.
Open the WebServiceApp.cpp file and add the statements shown in Listing 11.4 to the main() function. This creates an instance of the MyCPPWebService proxy class. You use it to communicate with the Web Service.
Listing 11.4 WebServiceApp.cpp—Additions to the main() Function to Use the MyCPPWebService Web Service Proxy Class
1: #include "stdafx.h"
2: #include "WebService.h"
3:
4: #using <mscorlib.dll>
5: #include <tchar.h>
6:
7: using namespace System;
8:
9: // This is the entry point for this application
10: int _tmain(void)
11: {
12: MyCPPWebService* pWebService = new MyCPPWebService;
13:
14: Console::WriteLine(pWebService->CurrentDateTime());
15: Console::WriteLine(pWebService->RectangleArea( 10.5, 20.25 ));
16:
17: return 0;
18: }
Compiling and executing the application results in a console window that displays the current date and time and the area calculation. When you instantiate the MyCPPWebService proxy class, a connection to the referenced Web Service is verified automatically.
Using Web Service Directories
Web Service directories provide a central location to register Web Services so that clients of other organizations can discover and use remote Web Services. Web Service directories, such as UDDI (Universal Description, Discovery, and Integration), provide this service.
Think of a Web Service directory as a search engine for Web Services available for public use. Without the Web Services directories, it would be impossible to find a Web Service on the Internet, just as it would be impossible to find a Web site without a search engine.
UDDI specifications define a standard way to publish and discover information about Web Services. Businesses and developers can use the UDDI registry to programmatically locate information about Web Services exposed by other organizations.
It is not a requirement that any exposed Web Service be registered with a directory. However, as with a Web site, where you have to know the URL, any user of the Web Service would have to know the URL to find the discovery file for the Web Service. For more information on UDDI, you can go to the Web site http://www.uddi.org.
Discovering Web Services
After the client knows where the discovery file is for a Web Service (either by using a Web Service directory or by some other means), the client can ask for the discovery document or documents. A discovery document describes the Web service using XML and the Web Services Description Language (WSDL) standard. The file generally has a .disco or .vsdisco extension and is not necessary if the client already knows the location of the service description file.
The Web Service discovery file contains URLs to the Web Service description documents that you wish to expose for usage. The following is an example of a discovery file for a Web Service:
<?xml version="1.0" ?> <disco:discovery xmlns:disco="http://machine.domain.com/disco" xmlns:wsdl="http://machine.domain.com/disco/wsdl"> <wsdl:contractRef ref="http://MyWebServer/UserName.asmx?WSDL"/> </disco:discovery>
In the preceding Web Service discovery file, a client is given a URL of http://MyWebServer/UserName.asmx?WSDL when it connects to discover the Web Services. The <contractRef> tag determines which Web Services are exposed in the discovery file.
When you're creating a new Web Service with the Visual C++ .NET Web Service Wizard, a discovery file is created. This discovery file turns on the automatic discovery of Web Services and therefore does not need to explicitly name the Web Services. The only issue with this method is that all Web Services are discovered and exposed. Here is an example of such a discovery file:
<?xml version="1.0" encoding="utf-8" ?> <dynamicDiscovery xmlns="urn:schemas-dynamicdiscovery:disco.2000-03-17"> <exclude path="_vti_cnf" /> <exclude path="_vti_pvt" /> <exclude path="_vti_log" /> <exclude path="_vti_script" /> <exclude path="_vti_txt" /> <exclude path="Web References" /> </dynamicDiscovery>
The <exclude path> tag excludes those directories from the discovery process. Therefore, you can overcome the issue of dynamic discovery by adding the directory of the Web Service that you do not want discovered and exposed.