Export (0) Print
Expand All

Invoking tRFCs by Using the WCF Service Model

Transactional Remote Function Calls (tRFCs) guarantee a one-time execution of an RFC on an SAP system. You can invoke any of the RFCs surfaced by the SAP adapter as a tRFC. Invoking a tRFC in the WCF service model is similar to invoking an RFC with the following differences:

  • The SAP adapter surfaces tRFCs under a different node (TRFC) than RFCs (RFC).

  • tRFC client calls do not return values for SAP export and changing parameters.

  • tRFC operations include a GUID parameter that is mapped to the SAP transaction ID (TID) for the tRFC by the SAP adapter.

  • After you invoke a tRFC, you must invoke the RfcConfirmTransID operation to confirm (commit) the tRFC on the SAP system. This operation is surfaced directly under the TRFC node.

For more information about tRFC operations and the RfcConfirmTransID operation, see Operations on tRFCs.

The following sections show you how to invoke tRFCs on the SAP system by using the SAP adapter.

The SAP adapter surfaces all tRFC operations under a single service contract, "Trfc". This means that a single WCF client class, TrfcClient, is created for all of the tRFC operations that you want to invoke. Each target tRFC is represented as a method of this class. For each method:

  • Complex SAP types such as structures are surfaced as .NET classes with properties that correspond to the fields of the SAP type. These classes are defined in the following namespace: microsoft.lobservices.sap._2007._03.Types.Rfc.

The following code shows part of the TrfcClient class and the method that invokes BAPI_SALESORDER_CREATEFROMDAT2 (as a tRFC) on the SAP system. The TransactionalRfcOperationIdentifier parameter contains the GUID that is mapped to the SAP TID. Not all of the parameters to the method are shown.

[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
public partial class TrfcClient : System.ServiceModel.ClientBase<Trfc>, Trfc {

    ....
    
    
    /// <summary>The Metadata for this RFC was generated using the RFC SDK.</summary>
    public void BAPI_SALESORDER_CREATEFROMDAT2(
                string BEHAVE_WHEN_ERROR, 
                string BINARY_RELATIONSHIPTYPE, 
                string CONVERT, 
                string INT_NUMBER_ASSIGNMENT, 
                microsoft.lobservices.sap._2007._03.Types.Rfc.BAPISDLS LOGIC_SWITCH, 
                microsoft.lobservices.sap._2007._03.Types.Rfc.BAPISDHD1 ORDER_HEADER_IN, 

                …

               microsoft.lobservices.sap._2007._03.Types.Rfc.BAPIADDR1[] PARTNERADDRESSES, 
                microsoft.lobservices.sap._2007._03.Types.Rfc.BAPIRET2[] RETURN, 
                ref System.Guid TransactionalRfcOperationIdentifier) { ...  }
}

The following code shows the method that is generated for the RfcConfirmTransID operation. You must ensure that this method is generated as part of the TrfcClient. The RfcConfirmTransID operation is surfaced directly under the TRFC node.

    public void RfcConfirmTransID(System.Guid TransactionalRfcOperationIdentifier) {…}

The steps to create an application that invokes tRFCs are similar to the steps you follow to invoke RFCs, with the following exceptions:

  • You must retrieve the target operations under the TRFC node.

  • You must retrieve the RfcConfirmTransID operation. This is surfaced directly under the TRFC node.

  • To confirm (commit) a tRFC operation on the SAP system, you must invoke the RfcConfirmTransID operation with the GUID that was returned for that tRFC operation.

To create a tRFC client application
  1. Generate a TrfcClient class. Use the Add Adapter Service Reference Visual Studio Plug-in or the ServiceModel Metadata Utility Tool (svcutil.exe) to generate a TrfcClient class that targets the RFCs with which you want to work. For more information about how to generate a WCF client, see Generating a WCF Client or a WCF Service Contract for SAP Artifacts. Ensure that the RfcConfirmTransID operation is included in the TrfcClient class.

  2. Create an instance of the TrfcClient class generated in step 1 and specify a client binding. Specifying a client binding involves specifying the binding and endpoint address that the TrfcClient will use. You can do this either imperatively in code or declaratively in configuration. For more information about how to specify a client binding, see Specifying a Client Binding for the SAP System. The following code initializes the TrfcClient from configuration and sets the credentials for the SAP system.

    TrfcClient trfcClient = new TrfcClient("SAPBinding_Rfc");
    
    trfcClient.ClientCredentials.UserName.UserName = "YourUserName";
    trfcClient.ClientCredentials.UserName.Password = "YourPassword";
    
  3. Open the TrfcClient.

    trfcClient.Open();
    
  4. Invoke the appropriate method on the TrfcClient created in step 2 to invoke the target tRFC on the SAP system. You can pass a variable that contains a GUID or that contains an empty GUID for the TransactionalRrcOperationIdentifier parameter. If you pass an empty GUID, the SAP adapter generates one for you. The following code invokes BAPI_SALESORDER_CREATEFROMDAT2 as a tRFC on the SAP system (not all parameters to the method are shown). A GUID is specified.

    transactionalRfcOperationIdentifier = Guid.NewGuid();
                    
    //invoke RFC_CUSTOMER_GET as a tRFC
    trfcClient.BAPI_SALESORDER_CREATEFROMDAT2(
                                    request.BEHAVE_WHEN_ERROR,
                                    request.BINARY_RELATIONSHIPTYPE,
                                    request.CONVERT,
    
                                    ...
    
                                    ref transactionalRfcOperationIdentifier);
    
  5. To confirm the TID associated with the tRFC on the SAP system, invoke the RfcConfirmTransID method on the TrfcClient. Specify the GUID returned in step 4 for the TransactionRfcOperationIdentifier parameter.

    trfcClient.RfcConfirmTransID(transactionalRfcOperationIdentifier);
    
  6. Close the TrfcClient when you are done using it (after you have finished invoking all tRFCs).

    trfcClient.Close(); 
    

Example

The following example shows how to invoke BAPI_SALESORDER_CREATE as a tRFC.

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

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

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

using microsoft.lobservices.sap._2007._03.Types.Rfc;


// This example demonstrates sending BAPI_SALESORDER_CREATEFROMDAT2 as a tRFC. The client has 
// methods to:
//      send the BAPI (BAPI_SALESORDER_CREATEFROMDAT2)and to
//      Confirm the transaction (RfcConfirmTransID)
// An instance of BAPI_SALESORDER_CREATEFROMDAT2Request (generated) 
// is used to format the BAPI before invoking BAPI_SALESORDER_CREATEFROMDAT2. This 
// is not necessary, but is done to make it easier to read the code.
// tRFC invocations always includes a ref parameter that contains a GUID. You can optionally 
// set this parameter when you invoke the method; however, you must use the value returned by
// the adapter when you call RfcConfirmTransID to confirm the transaction on the SAP system. 
// You can call the utility method, SAPAdapterUtilities.ConvertGuidToTid, to get the value
// of the SAP transaction Id from the GUID that the adapter returns.
namespace SapTrfcClientSM
{
    class Program
    {
        static void Main(string[] args)
        {
            TrfcClient sapTrfcClient = null;

            try
            {
                Console.WriteLine("SAP TRFC client sample started");
                Console.WriteLine("Creating the TRFC client");
                // Create the SAP Trfc Client from configuration
                sapTrfcClient = new TrfcClient("SAPBinding_Trfc");
                sapTrfcClient.ClientCredentials.UserName.UserName = "YourUserName";
                sapTrfcClient.ClientCredentials.UserName.Password = "YourPassword";

                Console.WriteLine("Opening the TRFC client");
                // Open the Trfc Client
                sapTrfcClient.Open();

                // Create a GUID -- note: this is optional. If you do not pass a GUID,
                // for the TransactionalRfcOperationIdentifier parameter, the SAP adapter will 
                // generate one, associate it with the SAP TID, and set the 
                // TransactionalRfcOperationIdentifier parameter.
                Guid tidGuid = Guid.NewGuid();

                BAPI_SALESORDER_CREATEFROMDAT2Request request = new BAPI_SALESORDER_CREATEFROMDAT2Request();

                request.ORDER_HEADER_IN = new BAPISDHD1();
                request.ORDER_HEADER_IN.DOC_TYPE = "TA";
                request.ORDER_HEADER_IN.SALES_ORG = "1000";
                request.ORDER_HEADER_IN.DISTR_CHAN = "10";
                request.ORDER_HEADER_IN.DIVISION = "00";
                request.ORDER_HEADER_IN.SALES_OFF = "1000";
                request.ORDER_HEADER_IN.REQ_DATE_H = DateTime.Now;
                request.ORDER_HEADER_IN.PURCH_DATE = DateTime.Now;
                request.ORDER_HEADER_IN.PURCH_NO_C = "Cust PO";
                request.ORDER_HEADER_IN.CURRENCY = "EUR";

                BAPISDITM[] orderItems = new BAPISDITM[1];
                orderItems[0] = new BAPISDITM();
                orderItems[0].MATERIAL = "P-109";
                orderItems[0].PLANT = "1000";
                orderItems[0].TARGET_QU = "ST";
                request.ORDER_ITEMS_IN = orderItems;

                BAPIPARNR[] orderPartners = new BAPIPARNR[1];
                orderPartners[0] = new microsoft.lobservices.sap._2007._03.Types.Rfc.BAPIPARNR();
                orderPartners[0].PARTN_ROLE = "AG";
                orderPartners[0].PARTN_NUMB = "0000001390";
                request.ORDER_PARTNERS = orderPartners;

                // Create a GUID -- note: this is optional. If you do not pass a GUID,
                // for the TransactionalRfcOperationIdentifier parameter, the SAP adapter will 
                // generate one, associate it with the SAP TID, and set the 
                // TransactionalRfcOperationIdentifier parameter.
                request.TransactionalRfcOperationIdentifier = Guid.NewGuid();

                Console.WriteLine("Invoking BAPI_SALESORDER_CREATEFROMDAT2 as a tRFC");
                
                //invoke RFC_CUSTOMER_GET as a tRFC
                sapTrfcClient.BAPI_SALESORDER_CREATEFROMDAT2(request.BEHAVE_WHEN_ERROR,
                                                                request.BINARY_RELATIONSHIPTYPE,
                                                                request.CONVERT,
                                                                request.INT_NUMBER_ASSIGNMENT,
                                                                request.LOGIC_SWITCH,
                                                                request.ORDER_HEADER_IN,
                                                                request.ORDER_HEADER_INX,
                                                                request.SALESDOCUMENTIN,
                                                                request.SENDER,
                                                                request.TESTRUN,
                                                                request.EXTENSIONIN,
                                                                request.ORDER_CCARD,
                                                                request.ORDER_CFGS_BLOB,
                                                                request.ORDER_CFGS_INST,
                                                                request.ORDER_CFGS_PART_OF,
                                                                request.ORDER_CFGS_REF,
                                                                request.ORDER_CFGS_REFINST,
                                                                request.ORDER_CFGS_VALUE,
                                                                request.ORDER_CFGS_VK,
                                                                request.ORDER_CONDITIONS_IN,
                                                                request.ORDER_CONDITIONS_INX,
                                                                request.ORDER_ITEMS_IN,
                                                                request.ORDER_ITEMS_INX,
                                                                request.ORDER_KEYS,
                                                                request.ORDER_PARTNERS,
                                                                request.ORDER_SCHEDULES_IN,
                                                                request.ORDER_SCHEDULES_INX,
                                                                request.ORDER_TEXT,
                                                                request.PARTNERADDRESSES,
                                                                request.RETURN,
                                                                ref request.TransactionalRfcOperationIdentifier);

                string sapTxId = null;
                sapTxId = SAPAdapterUtilities.ConvertGuidToTid(request.TransactionalRfcOperationIdentifier);

                Console.WriteLine("BAPI_SALESORDER_CREATEFROMDAT2 Sent");
                Console.WriteLine("The SAP Transaction Id is " + sapTxId);

                // Invoke the RfcConfirmTransID method to confirm (commit) the transaction on
                // the SAP system. This step is required to complete the transaction. The SAP
                // adapter will always return a TranactionalRfcOperationIdentifier, whether 
                // one was supplied in the call or not.
                sapTrfcClient.RfcConfirmTransID(request.TransactionalRfcOperationIdentifier);

                Console.WriteLine("SAP Transaction {0} has been committed", sapTxId);

                Console.WriteLine("\nHit <RETURN> to end");
                Console.ReadLine();

            }
            catch (ConnectionException cex)
            {
                Console.WriteLine("Exception occurred connecting to the SAP system");
                Console.WriteLine(cex.InnerException.Message);
                throw;
            }
            catch (Exception ex)
            {
                Console.WriteLine("Exception is: " + ex.Message);
                if (ex.InnerException != null)
                {
                    Console.WriteLine("Inner Exception is: " + ex.InnerException.Message);
                }
                throw;
            }
            finally
            {
                // Close the client
                if (sapTrfcClient != null)
                {
                    if (sapTrfcClient.State == CommunicationState.Opened)
                        sapTrfcClient.Close();
                    else
                        sapTrfcClient.Abort();
                }
            }

        }
    }
}
Show:
© 2014 Microsoft