This documentation is archived and is not being maintained.

BaseChannelObjectWithProperties Class

Provides a base implementation of a channel object that exposes a dictionary interface to its properties.

Namespace:  System.Runtime.Remoting.Channels
Assembly:  mscorlib (in mscorlib.dll)

'Declaration
<ComVisibleAttribute(True)> _
<SecurityPermissionAttribute(SecurityAction.InheritanceDemand, Flags := SecurityPermissionFlag.Infrastructure)> _
<SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags := SecurityPermissionFlag.Infrastructure)> _
Public MustInherit Class BaseChannelObjectWithProperties _
	Implements IDictionary, ICollection, IEnumerable
'Usage
Dim instance As BaseChannelObjectWithProperties

BaseChannelObjectWithProperties is the base class for BaseChannelWithProperties and BaseChannelSinkWithProperties.

BaseChannelWithProperties and BaseChannelSinkWithProperties can be used as the base classes for channels and channel sinks that provide named properties.

BaseChannelObjectWithProperties handles the complex task of asking a channel object for its properties.

This class makes a link demand and an inheritance demand at the class level. A SecurityException is thrown when either the immediate caller or the derived class does not have infrastructure permission. For details about security demands, see Link Demands and Inheritance Demands.

Notes to Inheritors:

When you inherit from BaseChannelObjectWithProperties, you must override the Keys property and the Item property.

   <PermissionSet(SecurityAction.Demand, Name:="FullTrust")> _
   Public Class LoggingServerChannelSinkProvider
      Implements IServerChannelSinkProvider 
      Private next2 As IServerChannelSinkProvider = Nothing 

      Public Sub New(properties As IDictionary, providerData As ICollection)
      End Sub 'New 

      Public Sub GetChannelData(channelData As IChannelDataStore) _ 
                                  Implements IServerChannelSinkProvider.GetChannelData
      End Sub 'GetChannelData

      Public Function CreateSink(channel1 As IChannelReceiver) As IServerChannelSink _ 
                                        Implements IServerChannelSinkProvider.CreateSink
         Dim localNextSink As IServerChannelSink = Nothing 
         If Not (next2 Is Nothing) Then
            localNextSink = next2.CreateSink(channel1)
         End If 
         Return New LoggingServerChannelSink(localNextSink)
      End Function 'CreateSink

      Public Property [Next]() As IServerChannelSinkProvider Implements _ 
                                                        IServerChannelSinkProvider.Next 
         Get 
            Return next2
         End Get 
         Set
            next2 = value
         End Set 
      End Property 
   End Class 'LoggingServerChannelSinkProvider

   <PermissionSet(SecurityAction.Demand, Name:="FullTrust")> _ 
   Friend Class LoggingServerChannelSink
      Inherits BaseChannelObjectWithProperties
      Implements IServerChannelSink 
      Private nextSink2 As IServerChannelSink = Nothing 
      Private bEnabled2 As Boolean = True 

      Public Sub New(localNextSink As IServerChannelSink)
         MyBase.new()
         nextSink2 = localNextSink
      End Sub 'New 

     Public Function ProcessMessage(   ByVal sinkStack As IServerChannelSinkStack, _
         ByVal requestMsg As IMessage, _
         ByVal requestHeaders As ITransportHeaders, _
         ByVal requestStream As Stream, _
         <Out> ByRef responseMsg As IMessage, _
         <Out> ByRef responseHeaders As ITransportHeaders, _
         <Out> ByRef responseStream As Stream _
      ) As ServerProcessing _ 
         Implements IServerChannelSink.ProcessMessage
         If bEnabled2 Then
            Console.WriteLine("----------Request Headers-----------")
            Console.WriteLine(CommonTransportKeys.IPAddress.ToString() + ":" + _ 
                                 requestHeaders(CommonTransportKeys.IPAddress).ToString())
         Console.WriteLine(CommonTransportKeys.ConnectionId.ToString() + ":" + _ 
                                 requestHeaders(CommonTransportKeys.ConnectionId).ToString())
         Console.WriteLine(CommonTransportKeys.RequestUri.ToString() + ":" + _ 
                                 requestHeaders(CommonTransportKeys.RequestUri).ToString())
         End If
         sinkStack.Push(Me, Nothing)
         Dim processing As ServerProcessing = _ 
                                      nextSink2.ProcessMessage _ 
                  (sinkStack, requestMsg, requestHeaders, requestStream, responseMsg, responseHeaders, responseStream)

         Select Case processing
            Case ServerProcessing.Complete
                  sinkStack.Pop(Me)
            Case ServerProcessing.OneWay
                  sinkStack.Pop(Me)
            Case ServerProcessing.Async
                  sinkStack.Store(Me, Nothing)
         End Select 
         Return processing
      End Function 'ProcessMessage

      Public Sub AsyncProcessResponse(sinkStack As IServerResponseChannelSinkStack, _ 
              state As Object, msg As IMessage, headers As ITransportHeaders, stream1 As Stream) _ 
                                       Implements IServerChannelSink.AsyncProcessResponse
         sinkStack.AsyncProcessResponse(msg, headers, stream1)
      End Sub 'AsyncProcessResponse

      Public Function GetResponseStream(sinkStack As IServerResponseChannelSinkStack, _ 
                  state As Object, msg As IMessage, headers As ITransportHeaders) As Stream _ 
                                       Implements IServerChannelSink.GetResponseStream
         Return Nothing 
      End Function 'GetResponseStream

      Public ReadOnly Property NextChannelSink() As IServerChannelSink _ 
                                          Implements IServerChannelSink.NextChannelSink
         Get 
            Return nextSink2
         End Get 
      End Property 

      Public Overrides ReadOnly Property Properties() As Collections.IDictionary _ 
                  Implements IServerChannelSink.Properties
         Get
		return nothing		
         End Get 
      End Property 
   End Class 'LoggingServerChannelSink
private __gc class LoggingServerChannelSink : public BaseChannelObjectWithProperties, public IServerChannelSink
{
private:
   IServerChannelSink* nextSink2;
   bool bEnabled2;
public:
   LoggingServerChannelSink() : nextSink2(0), bEnabled2(true) {}
   LoggingServerChannelSink(IServerChannelSink* localNextSink) : BaseChannelObjectWithProperties()
   {
      nextSink2 = localNextSink;
   }
   ServerProcessing ProcessMessage( 
      IServerChannelSinkStack* sinkStack,
      IMessage* requestMsg,
      ITransportHeaders* requestHeaders,
      Stream* requestStream,
      [Out]IMessage** responseMsg,
      [Out]ITransportHeaders** responseHeaders,
      [Out]Stream** responseStream
      )
   {
      if (bEnabled2)
      {
         Console::WriteLine(S"----------Request Headers-----------");
         Console::WriteLine( S"{0}:{1}", CommonTransportKeys::IPAddress, requestHeaders->Item[CommonTransportKeys::IPAddress]);
         Console::WriteLine( S"{0}:{1}", CommonTransportKeys::ConnectionId, requestHeaders->Item[CommonTransportKeys::ConnectionId]);
         Console::WriteLine( S"{0}:{1}", CommonTransportKeys::RequestUri, requestHeaders->Item[CommonTransportKeys::RequestUri]);

      }
      sinkStack->Push(this, 0);
      ServerProcessing processing =
         nextSink2->ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, responseMsg,
         responseHeaders, responseStream);

      switch (processing)
      {
      case ServerProcessing::Complete :
         {
            sinkStack->Pop(this);
            break;
         }
      case ServerProcessing::OneWay:
         {
            sinkStack->Pop(this);
            break;
         }
      case ServerProcessing::Async:
         {
            sinkStack->Store(this, 0);
            break;
         }
      }
      return processing;
   }

   void AsyncProcessResponse(IServerResponseChannelSinkStack* sinkStack, Object* /*state*/,
      IMessage* msg, ITransportHeaders* headers, Stream* stream1)
   {
      sinkStack->AsyncProcessResponse(msg, headers, stream1);
   }

   Stream* GetResponseStream(IServerResponseChannelSinkStack* /*sinkStack*/, Object* /*state*/,
      IMessage* /*msg*/, ITransportHeaders* /*headers*/)
   {
      return 0;
   }

   __property IServerChannelSink* get_NextChannelSink()
   {
      return nextSink2;
   }

};

public __gc class LoggingServerChannelSinkProvider : public IServerChannelSinkProvider
{
private:
   IServerChannelSinkProvider* next2;
public:
   LoggingServerChannelSinkProvider() : next2(0) {}
   LoggingServerChannelSinkProvider(IDictionary* /*properties*/, ICollection* /*providerData*/)
   {
   }

   void GetChannelData(IChannelDataStore* /*channelData*/)
   {
   }

   IServerChannelSink* CreateSink(IChannelReceiver* channel1)
   {
      IServerChannelSink* localNextSink = 0;
      if (next2 != 0)
         localNextSink = next2->CreateSink(channel1);
      return new LoggingServerChannelSink(localNextSink);
   }

   __property IServerChannelSinkProvider* get_Next()
   {
      return next2;
   }

   __property void set_Next( IServerChannelSinkProvider* value )
   {
      next2 = value;
   }

};

Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

Windows 7, Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2008 R2, Windows Server 2008, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98

The .NET Framework and .NET Compact Framework do not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

.NET Framework

Supported in: 3.5, 3.0, 2.0, 1.1, 1.0
Show: