Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Der Microsoft BizTalk-Adapter für mySAP Business Suite kann als RFC-Server fungieren, um RFCs zu empfangen, die von einem SAP-System aufgerufen werden.
Um die eingehenden RFCs im WCF-Dienstmodell zu empfangen, müssen Sie:
Stellen Sie sicher, dass ein RFC-Ziel im SAP-System vorhanden ist.
Stellen Sie sicher, dass rfc im SAP-System definiert ist.
Generieren Sie einen WCF-Dienstvertrag (Schnittstelle) für den RFC-Vorgang aus den vom Adapter verfügbar gemachten Metadaten. Dazu verwenden Sie das Add Adapter Service Reference Visual Studio Plug-In oder das ServiceModel Metadata Utility Tool (svcutil.exe).
Implementieren Sie einen WCF-Dienst über diese Schnittstelle. Die Methoden des WCF-Diensts enthalten die Logik, die erforderlich ist, um rfc zu verarbeiten und eine Antwort auf den Adapter (und damit das SAP-System) zurückzugeben.
Hosten Sie diesen WCF-Dienst mithilfe eines Diensthosts (System.ServiceModel.ServiceHost).
In den folgenden Abschnitten erfahren Sie, wie Sie RFCs aus dem SAP-System mithilfe des SAP-Adapters empfangen.
Einrichten des SAP-Systems zum Senden eines RFC an den SAP-Adapter
Bevor Sie ein RFC aus dem SAP-System an den SAP-Adapter senden können, müssen Sie sicherstellen, dass folgendes auf dem SAP-System zutrifft:
Ein RFC-Ziel für den SAP-Adapter muss vorhanden sein. Der SAP-Adapter registriert sich mit einem RFC-Ziel, um RFCs vom SAP-System zu empfangen. Sie stellen Parameter im SAP-Verbindungs-URI wie dem SAP-Gatewayhost, dem SAP-Gatewaydienst und der SAP-Programm-ID bereit, die der Adapter zum Registrieren verwendet. Informationen zum Einrichten eines RFC-Ziels im SAP-System finden Sie unter Erstellen eines RFCs, eines RFC-Ziels und Senden eines RFCs aus dem SAP-System.
Der RFC muss im SAP-System definiert werden. Sie müssen ein Funktionsmodul erstellen, das rfc im SAP-System definiert. Der SAP-Adapter verwendet die RFC-Definition im SAP-System, um Metadaten zum RFC abzurufen (sowohl zur Entwurfszeit als auch zur Laufzeit). Weitere Informationen finden Sie unter Erstellen eines RFC in einem SAP-System.
Hinweis
Sie müssen rfc im SAP-System definieren; Sie implementieren jedoch rfc in Ihrem Adapterclientcode. Der RFC muss im SAP-System definiert werden, damit der Adapter Metadaten für rfc abrufen kann.
Im Folgenden sehen Sie ein Beispiel für den Quellcode im SAP-System für einen RFC, der zwei ganze Zahlen hinzufügt und ihr Ergebnis zurückgibt. Der Code ruft lediglich den RFC über ein angegebenes Ziel auf. Die Implementierung der Funktion erfolgt durch den SAP-Adapterclientcode.
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.
Der WCF-Dienstvertrag für einen RFC
Sie verwenden das Add Adapter Service Reference Visual Studio Plug-In oder das ServiceModel Metadata Utility Tool (svcutil.exe), um einen WCF-Dienstvertrag für die RFCs zu generieren, die Sie vom SAP-System erhalten möchten. In den folgenden Abschnitten werden die für den Z_RFC_MKD_ADD Vorgang generierten Klassen und Schnittstellen mit verwaltetem Code angezeigt.
Rfc Interface (WCF-Dienstvertrag)
Der SAP-Adapter zeigt alle RFC-Vorgänge unter einem einzigen Servicevertrag , "Rfc", an. Dies bedeutet, dass eine einzelne Schnittstelle, Rfc, für alle RFC-Vorgänge erstellt wird, die Sie empfangen möchten. Jeder RFC-Zielvorgang wird als Methode dieser Schnittstelle dargestellt. Jede Methode verwendet einen einzelnen Parameter, der den Nachrichtenvertrag für die Anforderungsnachricht des Vorgangs darstellt, und gibt ein Objekt zurück, das den Nachrichtenvertrag der Antwortnachricht des Vorgangs darstellt.
[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);
}
Die Anforderungs- und Antwortnachrichten
Jeder RFC-Vorgang verwendet einen Parameter, der die Anforderungsnachricht darstellt, und gibt ein Objekt zurück, das die Antwortnachricht darstellt. Die Eigenschaften der Anforderungsnachricht enthalten die PARAMETER IMPORT und (Input) CHANGING des RFC. Die Eigenschaften der Antwortnachricht enthalten die Parameter EXPORT und (Ausgabe) CHANGING für den Vorgang.
[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;
}
}
Der generierte WCF-Dienst
Das Add-Adapter Service Reference Plug-In generiert auch einen WCF-Dienst, der den WCF-Dienstvertrag (RFC) implementiert. Die Methoden dieser Klasse sind stubbed. Diese Klasse wird in einer separaten Datei generiert. Sie können Ihren Code direkt in den Methoden dieser Klasse implementieren.
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.");
}
}
}
So erstellen Sie eine RFC-Serveranwendung
Um RFCs aus dem SAP-System mithilfe des WCF-Dienstmodells zu empfangen, können Sie die Schritte in der Übersicht über das WCF-Dienstmodell mit dem SAP-Adapter ausführen. Achten Sie darauf, "Rfc" für den Dienstvertrag anzugeben, wenn Sie den Dienstendpunkt hinzufügen (Schritt 6 des Verfahrens zum Erstellen und Implementieren eines WCF-Diensts).
Der folgende Code zeigt ein vollständiges Beispiel für den Empfang der Z_RFC_MKD_RFC von einem SAP-System mithilfe des SAP-Adapters. Dieser RFC akzeptiert zwei ganzzahlige Parameter und gibt das Ergebnis an das SAP-System zurück.
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);
}
}
}
}
}
Siehe auch
Entwickeln von Anwendungen mithilfe des WCF-Dienstmodells
Nachrichtenschemas für RFC-Vorgänge