SoapExtension Class (System.Web.Services.Protocols)

Imports System
Imports System.Web.Services
Imports System.Web.Services.Protocols
Imports System.IO

' Define a SOAP Extension that traces the SOAP request and SOAP response
' for the XML Web service method the SOAP extension is applied to.
Public Class TraceExtension
    Inherits SoapExtension

    Private oldStream As Stream
    Private newStream As Stream
    Private m_filename As String

    ' Save the Stream representing the SOAP request or SOAP response into
    ' a local memory buffer.
    Public Overrides Function ChainStream(ByVal stream As Stream) As Stream
        oldStream = stream
        newStream = New MemoryStream()
        Return newStream
    End Function

    ' When the SOAP extension is accessed for the first time, the XML Web
    ' service method it is applied to is accessed to store the file
    ' name passed in, using the corresponding SoapExtensionAttribute.    
    Public Overloads Overrides Function GetInitializer(ByVal methodInfo As _
        LogicalMethodInfo, _
    ByVal attribute As SoapExtensionAttribute) As Object
        Return CType(attribute, TraceExtensionAttribute).Filename
    End Function

    ' The SOAP extension was configured to run using a configuration file
    ' instead of an attribute applied to a specific XML Web service
    ' method.  Return a file name based on the class implementing the Web
    ' Service's type.
    Public Overloads Overrides Function GetInitializer(ByVal WebServiceType As _
      Type) As Object
        ' Return a file name to log the trace information to, based on the
        ' type.
        Return "C:\" + WebServiceType.FullName + ".log"
    End Function

    ' Receive the file name stored by GetInitializer and store it in a
    ' member variable for this specific instance.
    Public Overrides Sub Initialize(ByVal initializer As Object)
        m_filename = CStr(initializer)
    End Sub

    ' If the SoapMessageStage is such that the SoapRequest or SoapResponse
    ' is still in the SOAP format to be sent or received over the network,
    ' save it out to file.
    Public Overrides Sub ProcessMessage(ByVal message As SoapMessage)
        Select Case message.Stage
            Case SoapMessageStage.BeforeSerialize
            Case SoapMessageStage.AfterSerialize
                WriteOutput(message)
            Case SoapMessageStage.BeforeDeserialize
                WriteInput(message)
            Case SoapMessageStage.AfterDeserialize
        End Select
    End Sub

    ' Write the SOAP message out to a file.
    Public Sub WriteOutput(ByVal message As SoapMessage)
        newStream.Position = 0
        Dim fs As New FileStream(m_filename, FileMode.Append, _
                                 FileAccess.Write)
        Dim w As New StreamWriter(fs)
        w.WriteLine("-----Response at " + DateTime.Now.ToString())
        w.Flush()
        Copy(newStream, fs)
        w.Close()
        newStream.Position = 0
        Copy(newStream, oldStream)
    End Sub

    ' Write the SOAP message out to a file.
    Public Sub WriteInput(ByVal message As SoapMessage)
        Copy(oldStream, newStream)
        Dim fs As New FileStream(m_filename, FileMode.Append, _
                                 FileAccess.Write)
        Dim w As New StreamWriter(fs)

        w.WriteLine("----- Request at " + DateTime.Now.ToString())
        w.Flush()
        newStream.Position = 0
        Copy(newStream, fs)
        w.Close()
        newStream.Position = 0
    End Sub

    Sub Copy(ByVal fromStream As Stream, ByVal toStream As Stream)
        Dim reader As New StreamReader(fromStream)
        Dim writer As New StreamWriter(toStream)
        writer.WriteLine(reader.ReadToEnd())
        writer.Flush()
    End Sub
End Class

' Create a SoapExtensionAttribute for our SOAP Extension that can be
' applied to an XML Web service method.
<AttributeUsage(AttributeTargets.Method)> _
Public Class TraceExtensionAttribute
    Inherits SoapExtensionAttribute

    Private m_filename As String = "c:\log.txt"
    Private m_priority As Integer

    Public Overrides ReadOnly Property ExtensionType() As Type
        Get
            Return GetType(TraceExtension)
        End Get
    End Property

    Public Overrides Property Priority() As Integer
        Get
            Return m_priority
        End Get
        Set(ByVal Value As Integer)
            m_priority = value
        End Set
    End Property

    Public Property Filename() As String
        Get
            Return m_filename
        End Get
        Set(ByVal Value As String)
            m_filename = value
        End Set
    End Property
End Class

using System;
using System.Web.Services;
using System.Web.Services.Protocols;
using System.IO;
using System.Net;

	// Define a SOAP Extension that traces the SOAP request and SOAP
	// response for the XML Web service method the SOAP extension is
	// applied to.

	public class TraceExtension : SoapExtension 
	{
		Stream oldStream;
		Stream newStream;
		string filename;

		// Save the Stream representing the SOAP request or SOAP response into
		// a local memory buffer.
		public override Stream ChainStream( Stream stream )
		{
			oldStream = stream;
			newStream = new MemoryStream();
			return newStream;
		}

		// When the SOAP extension is accessed for the first time, the XML Web
		// service method it is applied to is accessed to store the file
		// name passed in, using the corresponding SoapExtensionAttribute.	
		public override object GetInitializer(LogicalMethodInfo methodInfo, SoapExtensionAttribute attribute) 
		{
			return ((TraceExtensionAttribute) attribute).Filename;
		}

		// The SOAP extension was configured to run using a configuration file
		// instead of an attribute applied to a specific XML Web service
		// method.
		public override object GetInitializer(Type WebServiceType) 
		{
			// Return a file name to log the trace information to, based on the
			// type.
			return "C:\\" + WebServiceType.FullName + ".log";    
		}

		// Receive the file name stored by GetInitializer and store it in a
		// member variable for this specific instance.
		public override void Initialize(object initializer) 
		{
			filename = (string) initializer;
		}

		//  If the SoapMessageStage is such that the SoapRequest or
		//  SoapResponse is still in the SOAP format to be sent or received,
		//  save it out to a file.
		public override void ProcessMessage(SoapMessage message) 
		{
			switch (message.Stage) 
			{
				case SoapMessageStage.BeforeSerialize:
					break;
				case SoapMessageStage.AfterSerialize:
					WriteOutput(message);
					break;
				case SoapMessageStage.BeforeDeserialize:
					WriteInput(message);
					break;
				case SoapMessageStage.AfterDeserialize:
					break;
			}
		}

		public void WriteOutput(SoapMessage message)
		{
			newStream.Position = 0;
			FileStream fs = new FileStream(filename, FileMode.Append,
				FileAccess.Write);
			StreamWriter w = new StreamWriter(fs);

			string soapString = (message is SoapServerMessage) ? "SoapResponse" : "SoapRequest";
			w.WriteLine("-----" + soapString + " at " + DateTime.Now);
			w.Flush();
			Copy(newStream, fs);
			w.Close();
			newStream.Position = 0;
			Copy(newStream, oldStream);
		}

		public void WriteInput(SoapMessage message)
		{
			Copy(oldStream, newStream);
			FileStream fs = new FileStream(filename, FileMode.Append,
				FileAccess.Write);
			StreamWriter w = new StreamWriter(fs);

			string soapString = (message is SoapServerMessage) ?
				"SoapRequest" : "SoapResponse";
			w.WriteLine("-----" + soapString + 
				" at " + DateTime.Now);
			w.Flush();
			newStream.Position = 0;
			Copy(newStream, fs);
			w.Close();
			newStream.Position = 0;
		}

		void Copy(Stream from, Stream to) 
		{
			TextReader reader = new StreamReader(from);
			TextWriter writer = new StreamWriter(to);
			writer.WriteLine(reader.ReadToEnd());
			writer.Flush();
		}
	}

	// Create a SoapExtensionAttribute for the SOAP Extension that can be
	// applied to an XML Web service method.
	[AttributeUsage(AttributeTargets.Method)]
	public class TraceExtensionAttribute : SoapExtensionAttribute 
	{

		private string filename = "c:\\log.txt";
		private int priority;

		public override Type ExtensionType 
		{
			get { return typeof(TraceExtension); }
		}

		public override int Priority 
		{
			get { return priority; }
			set { priority = value; }
		}

		public string Filename 
		{
			get 
			{
				return filename;
			}
			set 
			{
				filename = value;
			}
		}
	}

#using <System.dll>
#using <System.Web.Services.dll>

using namespace System;
using namespace System::Web::Services;
using namespace System::Web::Services::Protocols;
using namespace System::IO;
using namespace System::Net;

ref class TraceExtension;

// Create a SoapExtensionAttribute for the SOAP Extension that can be
// applied to an XML Web service method.
[AttributeUsage(AttributeTargets::Method)]
public ref class TraceExtensionAttribute: public SoapExtensionAttribute
{
private:
   String^ filename;
   int priority;

public:
   TraceExtensionAttribute()
      : filename( "c:\\log.txt" )
   {}

   property Type^ ExtensionType 
   {
      virtual Type^ get() override
      {
         return TraceExtension::typeid;
      }
   }

   property int Priority 
   {
      virtual int get() override
      {
         return priority;
      }
      virtual void set( int value ) override
      {
         priority = value;
      }
   }

   property String^ Filename 
   {
      String^ get()
      {
         return filename;
      }
      void set( String^ value )
      {
         filename = value;
      }
   }
};

// Define a SOAP Extension that traces the SOAP request and SOAP
// response for the XML Web service method the SOAP extension is
// applied to.
public ref class TraceExtension: public SoapExtension
{
private:
   Stream^ oldStream;
   Stream^ newStream;
   String^ filename;

public:
   // Save the Stream representing the SOAP request or SOAP response into
   // a local memory buffer.
   virtual Stream^ ChainStream( Stream^ stream ) override
   {
      oldStream = stream;
      newStream = gcnew MemoryStream;
      return newStream;
   }

   // When the SOAP extension is accessed for the first time, the XML Web
   // service method it is applied to is accessed to store the file
   // name passed in, using the corresponding SoapExtensionAttribute. 
   virtual Object^ GetInitializer( LogicalMethodInfo^ /*methodInfo*/, SoapExtensionAttribute^ attribute ) override
   {
      return (dynamic_cast<TraceExtensionAttribute^>(attribute))->Filename;
   }

   // The SOAP extension was configured to run using a configuration file
   // instead of an attribute applied to a specific XML Web service
   // method.
   virtual Object^ GetInitializer( Type^ WebServiceType ) override
   {
      // Return a file name to log the trace information to, based on the
      // type.
      return String::Format( "C:\\{0}.log", WebServiceType->FullName );
   }

   // Receive the file name stored by GetInitializer and store it in a
   // member variable for this specific instance.
   virtual void Initialize( Object^ initializer ) override
   {
      filename = dynamic_cast<String^>(initializer);
   }

   //  If the SoapMessageStage is such that the SoapRequest or
   //  SoapResponse is still in the SOAP format to be sent or received,
   //  save it out to a file.
   virtual void ProcessMessage( SoapMessage^ message ) override
   {
      switch ( message->Stage )
      {
         case SoapMessageStage::BeforeSerialize:
            break;
         case SoapMessageStage::AfterSerialize:
            WriteOutput( message );
            break;
         case SoapMessageStage::BeforeDeserialize:
            WriteInput( message );
            break;
         case SoapMessageStage::AfterDeserialize:
            break;
      }
   }

   void WriteOutput( SoapMessage^ message )
   {
      newStream->Position = 0;
      FileStream^ fs = gcnew FileStream( filename, FileMode::Append,
         FileAccess::Write );
      StreamWriter^ w = gcnew StreamWriter( fs );

      String^ soapString = ( (SoapServerMessage^)( message ) ) ?
         (String^)"SoapResponse" : "SoapRequest";
      w->WriteLine( "-----{0} at {1}", soapString, DateTime::Now );
      w->Flush();
      Copy( newStream, fs );
      w->Close();
      newStream->Position = 0;
      Copy( newStream, oldStream );
   }

   void WriteInput( SoapMessage^ message )
   {
      Copy( oldStream, newStream );
      FileStream^ fs = gcnew FileStream( filename,FileMode::Append,FileAccess::Write );
      StreamWriter^ w = gcnew StreamWriter( fs );
      String^ soapString = (dynamic_cast<SoapServerMessage^>(message)) ? (String^)"SoapRequest" : "SoapResponse";
      w->WriteLine( "-----{0} at {1}", soapString, DateTime::Now );
      w->Flush();
      newStream->Position = 0;
      Copy( newStream, fs );
      w->Close();
      newStream->Position = 0;
   }

   void Copy( Stream^ from, Stream^ to )
   {
      TextReader^ reader = gcnew StreamReader( from );
      TextWriter^ writer = gcnew StreamWriter( to );
      writer->WriteLine( reader->ReadToEnd() );
      writer->Flush();
   }
};