Export (0) Print
Expand All

Receiving Inbound RFC Calls by Using the WCF Service Model

The Microsoft BizTalk Adapter for mySAP Business Suite can act as an RFC server to receive RFCs invoked by a SAP system.

To receive the inbound RFCs in the WCF service model, you must:

  • Ensure that an RFC destination exists on the SAP system.

  • Ensure that the RFC is defined on the SAP system.

  • Generate a WCF service contract (interface) for the RFC operation from the metadata exposed by the adapter. To do this, you use the Add Adapter Service Reference Visual Studio Plug-in or the ServiceModel Metadata Utility Tool (svcutil.exe).

  • Implement a WCF service from this interface. The methods of the WCF service contain the logic necessary to process the RFC and return a response to the adapter (and hence the SAP system).

  • Host this WCF service using a service host (System.ServiceModel.ServiceHost).

The following sections show you how to receive RFCs from the SAP system by using the SAP adapter.

Before you can send an RFC from the SAP system to the SAP adapter, you must ensure that the following are true on the SAP system:

  • An RFC destination for the SAP adapter must exist. The SAP adapter registers itself with an RFC destination to receive RFCs from the SAP system. You supply parameters in the SAP connection URI such as the SAP Gateway Host, the SAP Gateway Service, and the SAP Program ID that the adapter uses to register itself. For information about how to create an RFC destination, see Creating an RFC Destination in an SAP System.

  • The RFC must be defined on the SAP system. You must create a function module that defines the RFC on the SAP system. The SAP adapter uses the RFC definition on the SAP system to retrieve metadata about the RFC (both at design time and at run time). For more information see Creating an RFC in an SAP System.

    Dd787814.note(en-US,BTS.10).gifNote
    You must define the RFC on the SAP system; however you implement the RFC in your adapter client code. The RFC must be defined on the SAP system so that the adapter can retrieve metadata for the RFC.

The following is an example of the source code on the SAP system for an RFC that adds two integers and returns their result. The code merely calls the RFC through a specified destination. The implementation of the function is done by the SAP adapter client code.

FUNCTION Z_RFC_SAMPLE_ADD.
*"---------------------------------------------------------------------*"*"Local interface:
*"  IMPORTING
*"     VALUE(X) TYPE  INT4
*"     VALUE(Y) TYPE  INT4
*"     VALUE(DEST) TYPE  CHAR20 DEFAULT 'SAPADAPTER'
*"  EXPORTING
*"     VALUE(RESULT) TYPE  INT4
*"---------------------------------------------------------------------CALL FUNCTION 'Z_RFC_MKD_ADD' DESTINATION DEST
  EXPORTING X = X
            Y = Y
  IMPORTING RESULT = RESULT.
 
ENDFUNCTION.

You use the Add Adapter Service Reference Visual Studio Plug-in or the ServiceModel Metadata Utility Tool (svcutil.exe) to generate a WCF service contract for the RFCs that you want to receive from the SAP system. The following sections show the managed code classes and interfaces generated for the Z_RFC_MKD_ADD operation.

The Rfc Interface (WCF service contract)

The SAP adapter surfaces all RFC operations under a single service contract, "Rfc". This means that a single interface, Rfc, is created for all of the RFC operations that you want to receive. Each target RFC operation is represented as a method of this interface. Each method takes a single parameter, which represents the message contract for the request message of the operation, and returns an object, which represents the message contract of the response message of the operation.

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
[System.ServiceModel.ServiceContractAttribute(Namespace="http://Microsoft.LobServices.Sap/2007/03/", ConfigurationName="Rfc")]
public interface Rfc {
    
    // CODEGEN: Generating message contract since the wrapper namespace (http://Microsoft.LobServices.Sap/2007/03/Rfc/) of message Z_RFC_MKD_ADDRequest does not match the default value (http://Microsoft.LobServices.Sap/2007/03/)
    [System.ServiceModel.OperationContractAttribute(Action="http://Microsoft.LobServices.Sap/2007/03/Rfc/Z_RFC_MKD_ADD", ReplyAction="http://Microsoft.LobServices.Sap/2007/03/Rfc/Z_RFC_MKD_ADD/response")]
    Z_RFC_MKD_ADDResponse Z_RFC_MKD_ADD(Z_RFC_MKD_ADDRequest request);
}

The Request and Response Messages

Each RFC operation takes a parameter that represents the request message and returns an object that represents the response message. The properties of the request message contain the IMPORT and (input) CHANGING parameters of the RFC. The properties of the response message contain the EXPORT and (output) CHANGING parameters for the operation.

[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
[System.ServiceModel.MessageContractAttribute(WrapperName="Z_RFC_MKD_ADD", WrapperNamespace="http://Microsoft.LobServices.Sap/2007/03/Rfc/", IsWrapped=true)]
public partial class Z_RFC_MKD_ADDRequest {
    
    [System.ServiceModel.MessageBodyMemberAttribute(Namespace="http://Microsoft.LobServices.Sap/2007/03/Rfc/", Order=0)]
    public string DEST;
    
    [System.ServiceModel.MessageBodyMemberAttribute(Namespace="http://Microsoft.LobServices.Sap/2007/03/Rfc/", Order=1)]
    public System.Nullable<int> X;
    
    [System.ServiceModel.MessageBodyMemberAttribute(Namespace="http://Microsoft.LobServices.Sap/2007/03/Rfc/", Order=2)]
    public System.Nullable<int> Y;
    
    public Z_RFC_MKD_ADDRequest() {
    }
    
    public Z_RFC_MKD_ADDRequest(string DEST, System.Nullable<int> X, System.Nullable<int> Y) {
        this.DEST = DEST;
        this.X = X;
        this.Y = Y;
    }
}

[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
[System.ServiceModel.MessageContractAttribute(WrapperName="Z_RFC_MKD_ADDResponse", WrapperNamespace="http://Microsoft.LobServices.Sap/2007/03/Rfc/", IsWrapped=true)]
public partial class Z_RFC_MKD_ADDResponse {
    
    [System.ServiceModel.MessageBodyMemberAttribute(Namespace="http://Microsoft.LobServices.Sap/2007/03/Rfc/", Order=0)]
    public int RESULT;
    
    public Z_RFC_MKD_ADDResponse() {
    }
    
    public Z_RFC_MKD_ADDResponse(int RESULT) {
        this.RESULT = RESULT;
    }
}

The Generated WCF Service

The Add Adapter Service Reference Plug-in also generates a WCF service that implements the WCF service contract (Rfc). The methods of this class are stubbed. This class is generated in a separate file. You can implement your code directly in the methods of this class.

namespace SAPBindingNamespace {
    
    
    public class SAPBindingService : Rfc {
        
        // CODEGEN: Generating message contract since the wrapper namespace (http://Microsoft.LobServices.Sap/2007/03/Rfc/) of message Z_RFC_MKD_ADDRequest does not match the default value (http://Microsoft.LobServices.Sap/2007/03/)
        public virtual Z_RFC_MKD_ADDResponse Z_RFC_MKD_ADD(Z_RFC_MKD_ADDRequest request) {
            throw new System.NotImplementedException("The method or operation is not implemented.");
        }
    }
}

To receive RFCs from the SAP system by using the WCF service model, you can follow the steps in Overview of Using the WCF Service Model with the Adapter. Be sure to specify 'Rfc' for the service contract when you add the service endpoint (step 6 of the procedure for creating and implementing a WCF service).

The following code shows a complete example of how to receive the Z_RFC_MKD_RFC from an SAP system by using the SAP adapter. This RFC takes two integer parameters and returns the result to the SAP system.

using System;
using System.Collections.Generic;
using System.Text;

// Add WCF, WCF LOB Adapter SDK, and SAP adapter namepaces
using System.ServiceModel;
using Microsoft.Adapters.SAP;
using Microsoft.ServiceModel.Channels;

// Include this namespace for the WCF LOB Adapter SDK and SAP adapter exceptions
using Microsoft.ServiceModel.Channels.Common;


namespace SapRfcServerSM
{
    // Implement a WCF service callback class by sub-classing the generated service callback class (SAPBindingService).
    // You must annotate this class with the InstanceContextMode.Single ServiceBehavior
    // If you implement your code in SAPBindingService.cs be sure to annotate the SAPBindingService class
    // The callback method should return a Z_RFC_MKD_ADDResponse to indicate successful processing
    // or throw an exception to indicate an error.
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single,UseSynchronizationContext = false)]
    class RfcServerClass : SAPBindingNamespace.SAPBindingService
    {

        public override Z_RFC_MKD_ADDResponse Z_RFC_MKD_ADD(Z_RFC_MKD_ADDRequest request)
        {
            // If either parameter is null, throw an exception 
            if (request.X == null || request.Y == null)
                throw new System.ArgumentNullException();

            int result = (int) (request.X + request.Y);

            Console.WriteLine("\nRfc Received");
            Console.WriteLine("X =\t\t" + request.X.ToString());
            Console.WriteLine("Y =\t\t" + request.Y.ToString());
            Console.WriteLine("Result =\t" + result);
            Console.WriteLine("\nHit <RETURN> to end");

            
            return new Z_RFC_MKD_ADDResponse(result);
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            // Listener connection for the service URI -- the connection URI must contain credentials
            Uri serviceUri = new Uri("sap://User=YourUserName;Passwd=YourPassword;Client=800;Lang=EN;@a/ADAPSAP47/00?ListenerGwServ=SAPGW00&ListenerGwHost=ADAPSAP47&ListenerProgramId=ADDER");

            // The baseUri cannot contain userinfoparams or query_string parameters
            Uri[] baseUri = new Uri[] { new Uri("sap://a/ADAPSAP47/00") };

            Console.WriteLine("RFC server sample started");

            // create service instance
            RfcServerClass rfcServerInstance = new RfcServerClass();

            try
            {
                Console.WriteLine("Initializing service host -- please wait");
                // Create and initialize a service host
                using (ServiceHost srvHost = new ServiceHost(rfcServerInstance, baseUri))
                {

                    // Add service endpoint 
                    // Specify AcceptCredentalsInUri=true for the binding
                    // NOTE: The contract for the service endpoint is "Rfc".
                    //       This is the generated WCF service callback interface (see SAPBindingInterface.cs).
                    SAPBinding binding = new SAPBinding();
                    binding.AcceptCredentialsInUri = true;
                    srvHost.AddServiceEndpoint("Rfc", binding, serviceUri);
                    srvHost.Open();

                    Console.WriteLine("\nReady to receive Z_RFC_MKD_ADD RFC");
                    Console.WriteLine("Hit <RETURN> to end");

                    // Wait to receive request
                    Console.ReadLine();
                }
            }
            catch (ConnectionException cex)
            {
                Console.WriteLine("Exception occurred connecting to the SAP system");
                Console.WriteLine(cex.InnerException.Message);
            }
            catch (TargetSystemException tex)
            {
                Console.WriteLine("Exception occurred on the SAP system");
                Console.WriteLine(tex.InnerException.Message);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Exception is: " + ex.Message);
                if (ex.InnerException != null)
                {
                    Console.WriteLine("Inner Exception is: " + ex.InnerException.Message);
                }
            }
        }
    }
}
Show:
© 2014 Microsoft