Shulou(Shulou.com)06/02 Report--

How to simulate the basic architecture of WCF through an ASP.NET program, aiming at this problem, this article introduces the corresponding analysis and solution in detail, hoping to help more partners who want to solve this problem to find a more simple and feasible method.

The purpose is to supplement the technical analysis of WCF, to describe some content, and to include a lot of content that is painfully abandoned because of the length of the space.

I will give a general explanation of the basic architecture of WCF. However, instead of giving a straightforward description of WCF's workflow, I will take a different approach, using the familiar ASP.NET as a request processing platform to simulate the entire WCF client and server architecture through a simple managed program.

The WCF framework handles the process and the components involved

Our simulation program will let you build a mini version of the WCF framework, in order to show that some special components are used in the whole WCF process. Let's start with a brief introduction to the processing flow of the WCF client-side and server-side framework for a simple WCF service call, and the important components used at each stage of the process.

The following list lists the functions provided by the WCF server-side framework for handling a simple WCF service invocation request, and the components hosted by the corresponding functions:

Receiving the request message and sending the reply message: the server listens and receives the request from the customer at the transport layer, and sends the encoded reply message to the client through the transport layer.

Decoding of the request message and encoding of the reply message: the received byte array is decoded to generate the request message object, and the reply message is converted into byte groups by programming. The message is encoded and decoded through MessageEncoder, and MessageEncoderFactory is responsible for creating the object

Deserialization of request messages and serialization of reply messages: deserialize the request message, generate corresponding input parameters for the execution of the service operation, and serialize the result (return value or ref/out parameter) executed by the service operation, and generate a reply message. Serialization and deserialization are done through DispatchMessageFormatter

Creation of service objects: create or activate service object instances. IntanceProvider is used to create or obtain service objects.

Execution of service operations: invokes the operation method of the created service object and passes in the input parameters generated by deserialization. OperationInvoker completes the final execution of the service operation

Compared with the server-side process, the client-side process is relatively simple and consists of only the following three necessary phases:

Serialization of request messages and deserialization of reply messages: generate a request message and serialize the input parameters into the request message, and deserialize the reply message into the return value or ref/out parameter of the method call. Serialization and deserialization are done through ClienthMessageFormatter

Encode the request message and decode the reply message: encode the request message to generate a byte array for transmission layer to send, and decode the byte array received by the transport layer to generate a recovery message. The message is encoded and decoded through MessageEncoder, and MessageEncoderFactory is responsible for creating the object

Sending the request message and receiving the reply message: send the encoded request message to the server at the transport layer, and receive the recovery message from the server

Figure 1 Compact WCF client and server components

Figure 1 reflects the necessary steps to make a service invocation and the relevant WCF components used. In this case demonstration, all we need to do is create these components by hand and use them to build a proposed version of the WCF framework through our own code. If the reader can have a clear understanding of the implementation of this case, I believe that the whole framework of WCF will not feel strange.

Figure 2 shows the basic structure of the solution for this case, which is divided into three projects. Contracts is used to define service contracts, which are referenced by servers and clients. The client is simulated by a Console application, while the server is implemented by an ASP.NET Website.

Figure 2 WCF framework simulation case application structure

Step 1. Create related components through the service contract type

WCF uses different components at different stages of the service invocation life cycle. We create all the components required by the server and the client in one way, so we add a Utility type to the Contracts project, in the Create

< T>

All components are created in the method and returned as output parameters, and the generic type T represents the service contract type. In this method, the output parameter encoderFactory is used by the server and the client to encode and decode the message. ClientFormatters and dispatchFormatters contain IClientMessageFormatter and IDispatchMessageFormatter based on the service operation in the form of a dictionary, where the Key of clientFormatters and dispatchFormatters is the operation name and the corresponding Action of the operation respectively. The operationInvokers and methods returned through the dictionary are also used to execute the corresponding operation method on the server, and Key is also the Action corresponding to the operation.

Public static class Utility {public static void Create

< T>

(out MessageEncoderFactory encoderFactory, out IDictionary

< string, IClientMessageFormatter>

ClientFormatters, out IDictionary

< string, IDispatchMessageFormatter>

DispatchFormatters, out IDictionary

< string, IOperationInvoker>

OperationInvokers, out IDictionary

< string, MethodInfo>

Methods) {/ / omitted implementation}}

The implementation is as follows, because MessageEncoderFactory (TextMessageEncoderFactory), MessageFormatter (DataContractSerializerOperationFormatter), and OperationInvoker (SyncMethodInvoker) used in the WCF framework are all internal types, so they can only be created by reflection. The operation name and Action are mainly obtained by parsing the OperationContractAttribute applied to the service method based on the principle of reflection.

Public static void Create

< T>

(out MessageEncoderFactory encoderFactory, out IDictionary

< string, IClientMessageFormatter>

ClientFormatters, out IDictionary

< string, IDispatchMessageFormatter>

DispatchFormatters, out IDictionary

< string, IOperationInvoker>

OperationInvokers, out IDictionary

< string, MethodInfo>

Methods) {/ / ensure that type T is a service contract with ServiceContractAttribute applied object [] attributes = typeof (T) .GetCustomAttributes (typeof (ServiceContractAttribute), false); if (attributes.Length = = 0) {throw new InvalidOperationException (string.Format ("The type\" {0}\ "is not a ServiceContract!", typeof (T) .AssemblyQualifiedName));} / create a dictionary to save IClientMessageFormatter, IDispatchMessageFormatter, IOperationInvoker and MethodInfo clientFormatters = new Dictionary

< string, IClientMessageFormatter>

(); dispatchFormatters = new Dictionary

< string, IDispatchMessageFormatter>

(); operationInvokers = new Dictionary

< string, IOperationInvoker>

(); methods = new Dictionary

< string, MethodInfo>

(); / / MessageEncoderFactory string encoderFactoryType = "System.ServiceModel.Channels.TextMessageEncoderFactory,System.ServiceModel, Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"; encoderFactory = (MessageEncoderFactory) Activator.CreateInstance (Type.GetType (encoderFactoryType), MessageVersion.Default, Encoding.UTF8, int.MaxValue, int.MaxValue, new XmlDictionaryReaderQuotas ()); / / get OperationDecription list string defaultNamespace = "http://tempuri.org/"; ServiceContractAttribute serviceAttribute = (ServiceContractAttribute) attributes [0] String serviceNamepace = string.IsNullOrEmpty (serviceAttribute.Namespace)? DefaultNamespace: serviceAttribute.Namespace; string serviceName = string.IsNullOrEmpty (serviceAttribute.Name)? Typeof (T) .Name: serviceAttribute.Name; var operations = ContractDescription.GetContract (typeof (T)) .Operations; / / get specific types of IClientMessageFormatter, IDispatchMessageFormatter and IOperationInvoker / / IClientMessageFormatter+IDispatchMessageFormatter:DataContractSerializerOperationFormatter / / IOperationInvoker:SyncMethodInvoker string formatterTypeName = "System.ServiceModel.Dispatcher.DataContractSerializerOperationFormatter,System.ServiceModel, Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"; Type formatterType = Type.GetType (formatterTypeName) ConstructorInfo formatterConstructor = formatterType.GetConstructor (new Type [] {typeof (OperationDescription), typeof (DataContractFormatAttribute), typeof (DataContractSerializerOperationBehavior)}); string operationInvokerTypeName = "System.ServiceModel.Dispatcher.SyncMethodInvoker,System.ServiceModel, Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"; Type operationInvokerType = Type.GetType (operationInvokerTypeName); foreach (MethodInfo method in typeof (T). GetMethods ()) {attributes = method.GetCustomAttributes (typeof (OperationContractAttribute), true) If (attributes.Length > 0) {OperationContractAttribute operationAttribute = (OperationContractAttribute) attributes [0]; string operationName = string.IsNullOrEmpty (operationAttribute.Name)? Method.Name: operationAttribute.Name; / / get Action string action; if (string.IsNullOrEmpty (operationAttribute.Action)) {action = string.Format ("{0} {1} / {2}", serviceNamepace, serviceName, operationName) through OperationContractAttribute;} else {action = operationAttribute.Action } OperationDescription operation = operations.Where (op = > op.Name = = operationName) .ToArray

< OperationDescription>

() [0]; / / create DataContractSerializerOperationFormatter objects by reflection object formatter = formatterConstructor.Invoke (new object [] {operation, new DataContractFormatAttribute (), null}); clientFormatters.Add (operationName, formatter as IClientMessageFormatter); dispatchFormatters.Add (action, formatter as IDispatchMessageFormatter); / / create SyncMethodInvoker objects by reflection IOperationInvoker operationInvoker = (IOperationInvoker) Activator.CreateInstance (operationInvokerType, method) OperationInvokers.Add (action, operationInvoker); methods.Add (action, method);}}

Step 2. Create the service contract and implement the service

Next, create a service contract for this case and implement it. The service contract is defined in the Contracts project, and the specific service implementation is in the ASP.NET Web site on the simulated server side. For simplicity, the example of computing services is still used.

Namespace Artech.WcfFrameworkSimulator.Contracts {[ServiceContract (Namespace = "http://www.artech.com/")] public interface ICalculator {[OperationContract] double Add (double x, double y);}} public class CalculatorService: ICalculator {public double Add (double x, double y) {return x + y;}}

Step 3: realize the processing of the service invocation request by the server

We use a Web Page of ASP.NET to simulate the processing of service requests by the WCF server. The following code related to the Calculator type is actually the Code Behind of the Calculator.aspx. The whole process is not complicated. In the constructor, call the Create of Utility

< ICalculator>

Method to initialize the required components, and the logic for handling the specific service invocation request is written directly in the Load event of the Web Page.

First, a MessageEncoder is created through MessageCoderFactory to decode the received service invocation request in the form of HttpRequest and generate a request message. After the Action attribute of the current service operation is obtained through the request message, in the list of all MethodInfo based on the service contract obtained during the initialization process, the corresponding MethodInfo object of the current operation is obtained according to the Action. After the input parameters and output parameters of the operation method are obtained by means of the MethodInfo object, two object arrays are created, which are used to store the input parameters obtained by deserializing the request message through the DispatchMessageFormatter object and the output parameters obtained by executing the operation method through OperationInvoker. Before OperationInvoker executes the action method, the service object is created directly through reflection, which is done through InstanceProvider in the real WCF framework.

The result of performing an action method through OperationInvoker takes two forms: the return value and the output parameters (including reference parameters). They are serialized by being passed into the DispatchMessageFormatter and a reply message object is generated. The reply message is encoded by the MessageEncoder created by MessageCoderFactory and returned through HttpResponse.

Public partial class Calculator: System.Web.UI.Page {private static MessageVersion messageversion = MessageVersion.Default; private static MessageEncoderFactory encoderFactory; private static IDictionary

< string, IDispatchMessageFormatter>

DispatchFormatters; private static IDictionary

< string, IOperationInvoker>

OperationInvokers; private static IDictionary

< string, MethodInfo>

Methods; protected Calculator () {IDictionary

< string, IClientMessageFormatter>

ClientFormatters; Utility.Create

< ICalculator>

(out encoderFactory, out clientFormatters, out dispatchFormatters, out operationInvokers, out methods);} protected void Page_Load (object sender, EventArgs e) {/ / Decode HttpPRequest to generate request message object Message request = encoderFactory.Encoder.ReadMessage (this.Request.InputStream, int.MaxValue, "application/soap+xml; charset=utf-8") / / get Action string action = request.Headers.Action; / / get the MethodInfo object corresponding to the service operation MethodInfo method = methods [action] from the MethodInfo dictionary through Action through the request message; / / get the number of output parameters int outArgsCount = 0 Foreach (var parameter in method.GetParameters ()) {if (parameter.IsOut) {outArgsCount++;}} / / create an array container to hold the input parameter object int inputArgsCount = method.GetParameters () .Length-outArgsCount generated after the request message is reversed. Object [] parameters = new object [inputArgsCount]; acquichFormaters [action] .acquiializeRequest (request, parameters); List

< object>

InputArgs = new List

< object>

(); object [] outArgs = new object [outArgsCount]; / / create a service object. In WCF, the service object creates object serviceInstance = Activator.CreateInstance (typeof (CalculatorService)) through InstanceProvider; / / execute the service operation object result = operationInvokers.invoke (serviceInstance, parameters, out outArgs) / / serialize the results performed by the operation (return values or output parameters) to generate a reply message Message reply = dispatchFormatters [action] .SerializeReply (messageversion, outArgs, result); this.Response.ClearContent (); this.Response.ContentEncoding = Encoding.UTF8; this.Response.ContentType = "application/soap+xml; charset=utf-8" / / A pair of reply messages are encoded, and the encoded messages are returned to encoderFactory.Encoder.WriteMessage (reply, this.Response.OutputStream) through HttpResponse; this.Response.Flush ();}}

Step 4: realize the processing of the service invocation request by the client

Since the processing of service requests on the client side is realized through a RealProxy (ServiceChannelFactory), in order to truly simulate the WCF processing framework, a custom RealProxy is used here to process client-side related service invocation requests. The ServiceRealProxy defined in the following code

< IContract>

It is such a custom RealProxy.

The relevant component objects used to process service invocation requests, such as MessageEncoderFactory and IClientMessageFormatter dictionaries, as well as required properties, such as the version of the message and the destination address of the service, are specified by the constructor. The specific request processing is implemented in the overridden Invoke method. First of all, the name of the service operation is obtained by parsing the OperationContractAttribute applied to the current method, so that the Key can get the corresponding IClientMessageFormatter object of the current service operation from the IClientMessageFormatter dictionary. The input parameters of the current action method call are serialized through the IClientMessageFormatter object to generate a request message. After adding the necessary addressing headers to the request message, the request message is encoded through the MessageEncoder created by MessageEncoderFactory. The encoded message is sent to the server in the form of HttpRequest, thus completing the sending of the service invocation request.

After the result of the service call is returned in the form of HttpResponse, it is decoded through MessageEncoder and a reply message is generated. After the reply message is deserialized through IClientMessageFormatter, the result reflected in the XML InfoSet implementation in the message is transformed into concrete objects, which are finally mapped to the return value and output parameters (including reference parameters) of the method call.

Namespace Artech.WcfFrameworkSimulator.Client {public class ServiceRealProxy

< IContract>

: RealProxy {private Uri _ remoteAddress; private IDictionary

< string, IClientMessageFormatter>

_ messageFormatters; private MessageVersion _ messageVersion = MessageVersion.Default; private MessageEncoderFactory _ messageEncoderFactory; public ServiceRealProxy (MessageVersion messageVersion, Uri address, IDictionary

< string, IClientMessageFormatter>

MessageFormaters, MessageEncoderFactory messageEncoderFactory): base (typeof (IContract)) {object [] attribute = typeof (IContract) .GetCustomAttributes (typeof (ServiceContractAttribute), false); if (attribute.Length = = 0) {throw new InvalidOperationException (string.Format ("The type\" {0}\ "is not a ServiceContract!", typeof (IContract) .AssemblyQualifiedName)) } this._messageVersion = messageVersion; this._remoteAddress = address; this._messageFormatters = messageFormaters; this._messageEncoderFactory = messageEncoderFactory;} public override IMessage Invoke (IMessage msg) {IMethodCallMessage methodCall = (IMethodCallMessage) msg; / / Get Operation name. Object [] attributes = methodCall.MethodBase.GetCustomAttributes (typeof (OperationContractAttribute), true); if (attributes.Length = = 0) {throw new InvalidOperationException (string.Format ("The method\" {0}\ "is not a valid OperationContract., methodCall.MethodName));} OperationContractAttribute attribute = (OperationContractAttribute) attributes [0]; string operationName = string.IsNullOrEmpty (attribute.Name)? MethodCall.MethodName: attribute.Name; / / serialization request message Message requestMessage = this._ messageFormaters [operationName] .SerializeRequest (this._messageVersion, methodCall.InArgs); / / add the necessary WS-Address header EndpointAddress address = new EndpointAddress (this._remoteAddress); requestMessage.Headers.MessageId = new UniqueId (Guid.NewGuid ()) RequestMessage.Headers.ReplyTo = new EndpointAddress ("http://www.w3.org/2005/08/addressing/anonymous"); address.ApplyTo (requestMessage); / / A pair of request messages are encoded and the bytes generated by the encoding are sent to the server via HttpWebRequest HttpWebRequest webRequest = (HttpWebRequest) HttpWebRequest.Create (this._remoteAddress); webRequest.Method =" Post " WebRequest.KeepAlive = true; webRequest.ContentType = "application/soap+xml; charset=utf-8"; ArraySegment

< byte>

Bytes = this._messageEncoderFactory.Encoder.WriteMessage (requestMessage, int.MaxValue, BufferManager.CreateBufferManager (long.MaxValue, int.MaxValue); webRequest.ContentLength = bytes.Array.Length; webRequest.GetRequestStream (). Write (bytes.Array, 0, bytes.Array.Length); webRequest.GetRequestStream (). Close (); WebResponse webResponse = webRequest.GetResponse (); / / A pair of HttpResponse is decoded to generate a reply message. Message responseMessage = this._messageEncoderFactory.Encoder.ReadMessage (webResponse.GetResponseStream (), int.MaxValue); / / the reply message is deserialized to generate the corresponding object and mapped to the return value of the method call or the ref/out parameter object [] allArgs = (object []) Array.CreateInstance (typeof (object), methodCall.ArgCount); Array.Copy (methodCall.Args, allArgs, methodCall.ArgCount) Object [] refOutParameters = new object [GetRefOutParameterCount (methodCall.MethodBase)]; object returnValue = this._ messageFormaters [operationName] .encrypializeReply (responseMessage, refOutParameters); MapRefOutParameter (methodCall.MethodBase, allArgs, refOutParameters); / / return values and ref/out parameters to return new ReturnMessage (returnValue, allArgs, allArgs.Length, methodCall.LogicalCallContext, methodCall) in the form of ReturnMessage } private int GetRefOutParameterCount (MethodBase method) {int count = 0; foreach (ParameterInfo parameter in method.GetParameters ()) {if (parameter.IsOut | | parameter.ParameterType.IsByRef) {count++ }} return count;} private void MapRefOutParameter (MethodBase method, object [] allArgs, object [] refOutArgs) {List

< int>

RefOutParamPositionsList = new List

< int>

(); foreach (ParameterInfo parameter in method.GetParameters ()) {if (parameter.IsOut | | parameter.ParameterType.IsByRef) {refOutParamPositionsList.Add (parameter.Position);}} int [] refOutParamPositionArray = refOutParamPositionsList.ToArray (); for (int I = 0; I

< refOutArgs.Length; i++) { allArgs[refOutParamPositionArray[i]] = refOutArgs[i]; } } } } 在真正的WCF客户端框架下，客户端通过ChannelFactory< T>

Create a service proxy object to invoke the service, and here we also create a factory type that performs similar functions: SerivceProxyFactory

< T>

The generic type T represents the service contract type.

The Create method for creating a service proxy is simple: first through Utility.Create

< T>

Method to create the relevant component objects necessary for the client to make service invocations, and create a ServiceRealProxy through these objects together with the parameters of the method (message version and service destination address)

< T>

Object, the final return is the TransparentProxy of the RealProxy.

Namespace Artech.WcfFrameworkSimulator.Client {public static class SerivceProxyFactory

< T>

{public static T Create (MessageVersion messageVersion, Uri remoteAddress) {MessageEncoderFactory encoderFactory; IDictionary

< string, IClientMessageFormatter>

ClientFormatters; IDictionary

< string, IDispatchMessageFormatter>

DispatchFormatters; IDictionary

< string, IOperationInvoker>

OperationInvokers; IDictionary

< string, MethodInfo>

Methods; Utility.Create

< T>

(out encoderFactory, out clientFormatters, out dispatchFormatters, out operationInvokers, out methods); ServiceRealProxy

< T>

RealProxy = new ServiceRealProxy

< T>

(messageVersion, remoteAddress, clientFormatters, encoderFactory); return (T) realProxy.GetTransparentProxy ();}}

Then SerivceProxyFactory can be used in the final client code.

< T>

Create a service proxy to make the service invocation, where the destination address of the service is actually the address of the .aspx Web Page above used to simulate the WCF server-side framework.

Namespace Artech.WcfFrameworkSimulator.Client {class Program {static void Main (string [] args) {ICalculator calculator = SerivceProxyFactory

< ICalculator>

.Create (MessageVersion.Default, new Uri ("http://localhost/Artech.WcfFrameworkSimulator/Calculator.aspx")); double result = calculator.Add (1,2); Console.WriteLine (" x + y = {2} when x = {0} and y = {1} ", 1,2, result);}

Execution result:

X + y = 3 when x = 1 and y = 2

This is the answer to the question on how to simulate the basic structure of WCF through an ASP.NET program. I hope the above content can be of some help to you. If you still have a lot of doubts to be solved, you can follow the industry information channel to learn more about it.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.