WCF simple tutorial (1) getting started

WCF is a very important technology in the DotNet system. However, many team members in the group feel that they are too broad, the configuration files are too complex, and there are too many new terms and cannot grasp the clues, I decided to conduct a group technical training and sort out the training handouts on the blog. It is not a big but comprehensive solution, but a quick start for beginners. Therefore, we want to start with an instance and deliberately hide some content that is not available at the beginning to lower the entry threshold. Please correct me if you have any errors.

Note: this series of articles is Based on. Net Framework 3.5. At the end of the tutorial, We will summarize the differences in 4.0.

----------------------- Separation line -----------------------

Article 1: getting started, build the first WCF Program

1. Server

Create a console application as the Server and create an API IData as the service contract. This contract interface must be placed on the Client side in a short time so that both parties can follow the same standards. Do not forget to add a reference to System. ServiceModel.

 
 

  
  
Using System;
  
  
Using System. ServiceModel;
  
  
Using System. Text;
  
  
Namespace Server
  
  
{
  
  
/// <Summary>
  
  
/// ServiceContract is used to mark this interface as a service contract of WCF, you can specify a Namespace like WebService, if not specified, is the default http://tempuri.org
  
  
/// </Summary>
  
  
[ServiceContract (Namespace = "WCF. Demo")]
  
  
Public interface IData
  
  
{
  
  
/// <Summary>
  
  
/// Use OperationContract to mark this method as an operation contract
  
  
/// </Summary>
  
  
[OperationContract]
  
  
String SayHello (string userName );
  
  
}
  
  
}
 
 

To create an implementation class for this interface, this class actually works. It works on the server and does not appear on the client:

 
 

  
  
Using System;
  
  
Using System. Text;
  
  
Namespace Server
  
  
{
  
  
/// <Summary>
  
  
/// Implement the IData interface. No contract mark is required here.
  
  
/// </Summary>
  
  
Public class DataProvider: IData
  
  
{
  
  
Public string SayHello (string userName)
  
  
{
  
  
Return string. Format ("Hello {0}.", userName );
  
  
}
  
  
}
  
  
}
 
 

Add an App. config file for the project, which defines parameters related to service release. In WCF, a common practice is to write Service Logic using code, but to define the service publishing method using configuration files, the advantage of this is loose coupling.

 
 

  
  
<? Xmlversion = "1.0" encoding = "UTF-8"?>
  
  
<Configuration>
  
  
<System. serviceModel>
  
  
<! -- When you see the services Section, it indicates that this is the definition of service-related content -->
  
  
<Services>
  
  
<! -- Define a service, and name is the full name of the contract implementation class -->
  
  
<Servicename = "Server. DataProvider">
  
  
<! -- To provide external services, you must have a service address, which is defined as http: // localhost: 8080/wcf. Note that the address always carries a type header. -->
  
  
<Host>
  
  
<BaseAddresses>
  
  
<AddbaseAddress = "http: // localhost: 8080/wcf"/>
  
  
</BaseAddresses>
  
  
</Host>
  
  
<! -- Defines the final node. The address is generally empty. If it is not empty, the final service address is added based on baseAddress, and the binding is specified as basicHttpBinding, this is the most basic http-based binding method, and contract indicates which contract service this is for -->
  
  
<Endpointaddress = "" binding = "basicHttpBinding" contract = "Server. IData"/>
  
  
</Service>
  
  
</Services>
  
  
</System. serviceModel>
  
  
</Configuration>
 
 

Everything is ready, with only the last step left. Release the service:

 
 

  
  
Using System;
  
  
Using System. ServiceModel;
  
  
Namespace Server
  
  
{
  
  
Class Program
  
  
{
  
  
Static void Main (string [] args)
  
  
{
  
  
// Define a ServiceHost. Note that the contract implementation class should be used in the parameter instead of the interface.
  
  
Using (ServiceHost host = new ServiceHost (typeof (Server. DataProvider )))
  
  
{
  
  
Host. Open ();
  
  
Console. WriteLine ("Service Running ...");
  
  
Console. ReadKey ();
  
  
Host. Close ();
  
  
}
  
  
}
  
  
}
  
  
}
 
 

Someone may ask where the service is released? No address specified? It is easy for beginners to understand.

Yes, the App. the definition in config plays a role, because the Server is specified in ServiceHost. dataProvider services, and App. name = "Server. the service of DataProvider has an endpoint, which defines the binding method as basicHttpBinding. The baseAddress of http is only one, that is, http: // localhost: 8080/wcf.

Compile and run the Service. The screen shows that the Service Running... is Running normally. If you use the command line netstat-ano | findstr "8080" to check whether the output is as follows:

 
 

  
  
TCP    0.0.0.0:8080         0.0.0.0:0          LISTENING      4 
  
  
TCP    [::]:8080            [::]:0             LISTENING      4 
 
 

It indicates that our program has started listening on TCP port 8080. It is worth noting that PID is 4, which is a system process rather than our own process. This indicates that the system function HTTP. sys is used when the WCF program provides http services externally ).

In this case, if you access http: // localhost: 8080/wcf in a browser, no error is reported, but the message "metadata publishing for this service is disabled" is displayed ", this is because http get is not allowed by default to obtain the Service's WSDL. We don't need to worry about it and it will not affect subsequent use. Let's look at this issue later.

2. Client

Create a console application as the Client and copy the IData interface in the Server, because this is a service contract.

Add an App to the project. in the config file, you need to define the client access parameters. Here I have removed some unused parameters to keep the configuration file simple and prevent you from getting dizzy.

 
 

  
  
<? Xmlversion = "1.0" encoding = "UTF-8"?>
  
  
<Configuration>
  
  
<System. serviceModel>
  
  
<! -- When you see the client, it indicates the client settings -->
  
  
<Client>
  
  
<! -- Define the End Node for access. The name is also random. Note that the address is the address of the baseAddress + endpoint specified when the Server is released, and the binding should also be matched. The contract should not be mentioned, because IData. the namespace is not modified when cs is copied, so it is still the Server. IData -->
  
  
<Endpointname = "DataService" address = "http: /localhost: 8080/wcf" binding = "basicHttpBinding" contract = "Server. IData"/>
  
  
</Client>
  
  
</System. serviceModel>
  
  
</Configuration>
 
 

Then write the code to call the SayHello method published by the Server:

 
 

  
  
Using System;
  
  
Using System. ServiceModel;
  
  
Using System. ServiceModel. Channels;
  
  
Namespace Client
  
  
{
  
  
Class Program
  
  
{
  
  
Static void Main (string [] args)
  
  
{
  
  
// There are multiple client access methods. Only one method is displayed here.
  
  
// Use the CreateChannel method of ChannelFactory to create an IData proxy object. The parameter "DataService" is the name of the endpoint defined in App. config.
  
  
Var proxy = new ChannelFactory <Server. IData> ("DataService"). CreateChannel ();
  
  
// Call the SayHello Method
  
  
Console. WriteLine (proxy. SayHello ("WCF "));
  
  
// Be sure to close the connection after use, because the server has the maximum number of connections. If you do not close the connection, it will occupy valid connections for a certain period of time.
  
  
(IChannel) proxy). Close ();
  
  
}

  
  
}
  
  
}
 
 

Compile and run the program. The screen should be able to print "Hello WCF .". The first entry-level demo is completed. It should be relatively simple. The configuration of App. config is a little complicated. We will see later that you can do it without configuring it, but we do not recommend this from the perspective of loose coupling.

This article from the rabbit nest blog, please be sure to keep this source http://boytnt.blog.51cto.com/966121/796884