sdk/samples/WCFSamples/TechnologySamples/Extensibility/Instancing/Durable/CS/extensions/DurableInstanceContextBindingElement.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Text;
   4 using System.ServiceModel;
   5 using System.ServiceModel.Channels;
   6 using System.IO;
   7 using System.ServiceModel.Security;
   8
   9 namespace Microsoft.ServiceModel.Samples
  10 {
  11     public class DurableInstanceContextBindingElement : BindingElement
  12     {
  13         string contextStoreLocation;
  14         ContextType contextType;
  15
  16
  17         public DurableInstanceContextBindingElement()
  18         {
  19             InitializeContextStoreLocation();
  20         }
  21
  22         public DurableInstanceContextBindingElement(BindingElement other)
  23             : base(other)
  24         {
  25             DurableInstanceContextBindingElement otherBindingElement = other as DurableInstanceContextBindingElement;
  26
  27             if (otherBindingElement != null)
  28             {
  29                 this.contextStoreLocation = otherBindingElement.contextStoreLocation;
  30                 this.contextType = otherBindingElement.contextType;
  31
  32                 if ((contextStoreLocation == null) ||
  33                     (contextStoreLocation.Trim().Length == 0))
  34                 {
  35                     InitializeContextStoreLocation();
  36                 }
  37                 else
  38                 {
  39                     // Throw if the specified contextStoreLocation is
  40                     // invalid.
  41                     if (!Directory.Exists(contextStoreLocation))
  42                     {
  43                         throw new InvalidOperationException(
  44                             ResourceHelper.GetString(@"ExInvalidContextStorePath"));
  45                     }
  46
  47                 }
  48             }
  49             else
  50             {
  51                 this.contextType = ContextType.MessageHeader;
  52                 InitializeContextStoreLocation();
  53             }
  54         }
  55
  56         public override bool CanBuildChannelFactory<TChannel>(
  57             BindingContext context)
  58         {
  59             ValidateTransport(context.Binding);
  60             return context.CanBuildInnerChannelFactory<TChannel>();
  61         }
  62
  63         public override bool CanBuildChannelListener<TChannel>(
  64             BindingContext context)
  65         {
  66             ValidateTransport(context.Binding);
  67             return context.CanBuildInnerChannelListener<TChannel>();
  68         }
  69
  70         public override IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingContext context)
  71         {
  72             ValidateTransport(context.Binding);
  73             IChannelFactory<TChannel> innerChannelFactory = context.BuildInnerChannelFactory<TChannel>();
  74
  75             IChannelFactory<TChannel> channelFactory =
  76                 new DurableInstanceChannelFactory<TChannel>(contextStoreLocation,
  77                     contextType, innerChannelFactory);
  78
  79             return channelFactory;
  80         }
  81
  82         public override IChannelListener<TChannel>
  83             BuildChannelListener<TChannel>(BindingContext context)
  84         {
  85             ValidateTransport(context.Binding);
  86
  87             return new DurableInstanceChannelListener<TChannel>(contextType, contextStoreLocation, context);
  88         }
  89
  90         public override BindingElement Clone()
  91         {
  92             return new DurableInstanceContextBindingElement(this);
  93         }
  94
  95         public override T GetProperty<T>(BindingContext context)
  96         {
  97             if (typeof(T) == typeof(ContextType))
  98             {
  99                 return (T)(object)this.ContextType;
 100             }
 101
 102             return context.GetInnerProperty<T>();
 103         }
 104
 105         public ContextType ContextType
 106         {
 107             get { return this.contextType; }
 108             set { this.contextType = value; }
 109         }
 110
 111         public string ContextStoreLocation
 112         {
 113             get { return this.contextStoreLocation; }
 114             set { this.contextStoreLocation = value; }
 115         }
 116
 117         //If the context type is set to HttpCookie this
 118         //function verifies that the current binding
 119         //is using the HTTP transport.
 120         void ValidateTransport(CustomBinding binding)
 121         {
 122             if (this.contextType == ContextType.HttpCookie)
 123             {
 124                 HttpTransportBindingElement httpTransport =
 125                     binding.Elements.Find<HttpTransportBindingElement>();
 126
 127                 if (httpTransport == null)
 128                 {
 129                     throw new InvalidOperationException(
 130                         ResourceHelper.GetString("ExInvalidTransport"));
 131                 }
 132             }
 133         }
 134
 135         //Initializes contextStoreLocation.
 136         //This method checks whether the directory that is used as the
 137         //context store location exists and creates it if it is not
 138         //available.
 139         void InitializeContextStoreLocation()
 140         {
 141             // Get the path of the temp directory of the current user.
 142             string temp = Path.GetTempPath();
 143
 144             // Build the required directory path in the Local Settings
 145             // directory.
 146             temp += DurableInstanceContextUtility.ContextStoreDirectory;
 147
 148             // Create the directory if it does not exist.
 149             if (!Directory.Exists(temp))
 150             {
 151                 Directory.CreateDirectory(temp);
 152             }
 153
 154             this.contextStoreLocation = temp;
 155         }
 156
 157     }
 158 }