Facilities/Wcf/Castle.Facilities.WcfIntegration/WcfEndpoint.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Facilities.WcfIntegration
  16 {
  17     using System;
  18     using System.ServiceModel;
  19     using System.ServiceModel.Channels;
  20         using System.ServiceModel.Description;
  21
  22         public static class WcfEndpoint
  23         {
  24                 public static ServiceEndpointModel FromEndpoint(ServiceEndpoint endpoint)
  25                 {
  26                         return new ContractEndpointModel().FromEndpoint(endpoint);
  27                 }
  28
  29                 public static ConfigurationEndpointModel FromConfiguration(string endpointName)
  30                 {
  31                         return new ContractEndpointModel().FromConfiguration(endpointName);
  32                 }
  33
  34                 public static BindingEndpointModel BoundTo(Binding binding)
  35                 {
  36                         return new ContractEndpointModel().BoundTo(binding);
  37                 }
  38
  39                 public static BindingAddressEndpointModel At(string address)
  40                 {
  41                         return new ContractEndpointModel().At(address);
  42                 }
  43
  44                 public static BindingAddressEndpointModel At(Uri address)
  45                 {
  46                         return new ContractEndpointModel().At(address);
  47                 }
  48
  49                 public static ContractEndpointModel ForContract(Type contract)
  50                 {
  51                         return new ContractEndpointModel(contract);
  52                 }
  53
  54                 public static ContractEndpointModel ForContract<Contract>()
  55                         where Contract : class
  56                 {
  57                         return ForContract(typeof(Contract));
  58                 }
  59         }
  60
  61         #region Nested Class: WcfEndpointBase
  62
  63         public abstract class WcfEndpointBase : IWcfEndpoint
  64         {
  65                 private Type contract;
  66
  67                 protected WcfEndpointBase(Type contract)
  68                 {
  69                         this.contract = contract;
  70                 }
  71
  72                 #region IWcfEndpoint Members
  73
  74                 public Type Contract
  75                 {
  76                         get { return contract; }
  77                 }
  78
  79                 Type IWcfEndpoint.Contract
  80                 {
  81                         get { return contract; }
  82                         set { contract = value; }
  83                 }
  84
  85                 void IWcfEndpoint.Accept(IWcfEndpointVisitor visitor)
  86                 {
  87                         Accept(visitor);
  88                 }
  89
  90                 protected abstract void Accept(IWcfEndpointVisitor visitor);
  91
  92                 #endregion
  93         }
  94
  95         #endregion
  96
  97         #region Nested Class: ContractModel
  98
  99         public class ContractEndpointModel
 100         {
 101                 private readonly Type contract;
 102
 103                 internal ContractEndpointModel()
 104                 {
 105                 }
 106
 107                 internal ContractEndpointModel(Type contract)
 108                 {
 109                         this.contract = contract;
 110                 }
 111
 112                 public ServiceEndpointModel FromEndpoint(ServiceEndpoint endpoint)
 113                 {
 114                         if (endpoint == null)
 115                         {
 116                                 throw new ArgumentNullException("endpoint");
 117                         }
 118
 119                         return new ServiceEndpointModel(contract, endpoint);
 120                 }
 121
 122                 public ConfigurationEndpointModel FromConfiguration(string endpointName)
 123                 {
 124                         if (string.IsNullOrEmpty(endpointName))
 125                         {
 126                                 throw new ArgumentException("endpointName cannot be nul or empty");
 127                         }
 128                         return new ConfigurationEndpointModel(contract, endpointName);
 129                 }
 130
 131                 public BindingEndpointModel BoundTo(Binding binding)
 132                 {
 133                         if (binding == null)
 134                         {
 135                                 throw new ArgumentNullException("binding");
 136                         }
 137                         return new BindingEndpointModel(contract, binding);
 138                 }
 139
 140                 public BindingAddressEndpointModel At(string address)
 141                 {
 142                         return new BindingEndpointModel(contract, null).At(address);
 143                 }
 144
 145                 public BindingAddressEndpointModel At(Uri address)
 146                 {
 147                         return new BindingEndpointModel(contract, null).At(address);
 148                 }
 149         }
 150
 151         #endregion
 152
 153         #region Nested Class: ServiceEndpointModel
 154
 155         public class ServiceEndpointModel : WcfEndpointBase
 156         {
 157                 private readonly ServiceEndpoint endpoint;
 158
 159                 internal ServiceEndpointModel(Type contract, ServiceEndpoint endpoint)
 160                         : base(contract)
 161                 {
 162                         this.endpoint = endpoint;
 163                 }
 164
 165                 public ServiceEndpoint ServiceEndpoint
 166                 {
 167                         get { return endpoint; }
 168                 }
 169
 170                 protected override void Accept(IWcfEndpointVisitor visitor)
 171                 {
 172                         visitor.VisitServiceEndpoint(this);
 173                 }
 174         }
 175
 176         #endregion
 177
 178         #region Nested Class: ConfigurationEndpointModel
 179
 180         public class ConfigurationEndpointModel : WcfEndpointBase
 181         {
 182                 private readonly string endpointName;
 183
 184                 internal ConfigurationEndpointModel(Type contract, string endpointName)
 185                         : base(contract)
 186                 {
 187                         this.endpointName = endpointName;
 188                 }
 189
 190                 public string EndpointName
 191                 {
 192                         get { return endpointName; }
 193                 }
 194
 195                 protected override void Accept(IWcfEndpointVisitor visitor)
 196                 {
 197                         visitor.VisitConfigurationEndpoint(this);
 198                 }
 199         }
 200
 201         #endregion
 202
 203         #region Nested Class: BindingEndpointModel
 204
 205         public class BindingEndpointModel : WcfEndpointBase
 206         {
 207                 private readonly Binding binding;
 208
 209                 internal BindingEndpointModel(Type contract, Binding binding)
 210                         : base(contract)
 211                 {
 212                         this.binding = binding;
 213                 }
 214
 215                 public Binding Binding
 216                 {
 217                         get { return binding; }
 218                 }
 219
 220                 public BindingAddressEndpointModel At(string address)
 221                 {
 222                         if (string.IsNullOrEmpty(address))
 223                         {
 224                                 throw new ArgumentException("address cannot be null or empty");
 225                         }
 226                         return new BindingAddressEndpointModel(Contract, Binding, address);
 227                 }
 228
 229                 public BindingAddressEndpointModel At(Uri address)
 230                 {
 231                         if (address == null)
 232                         {
 233                                 throw new ArgumentNullException("address");
 234                         }
 235                         return new BindingAddressEndpointModel(Contract, Binding, address.AbsoluteUri);
 236                 }
 237
 238                 public BindingAddressEndpointModel At(EndpointAddress address)
 239                 {
 240                         if (address == null)
 241                         {
 242                                 throw new ArgumentNullException("address");
 243                         }
 244                         return new BindingAddressEndpointModel(Contract, Binding, address);
 245                 }
 246
 247                 protected override void Accept(IWcfEndpointVisitor visitor)
 248                 {
 249                         visitor.VisitBindingEndpoint(this);
 250                 }
 251         }
 252
 253         #endregion
 254
 255         #region Nested Class: BindingAddressEndpointModel
 256
 257         public class BindingAddressEndpointModel : WcfEndpointBase
 258         {
 259                 private readonly Binding binding;
 260                 private readonly string address;
 261                 private readonly EndpointAddress endpointAddress;
 262                 private string via;
 263
 264                 internal BindingAddressEndpointModel(Type contract, Binding binding,
 265                                                                                          string address)
 266                         : base(contract)
 267                 {
 268                         this.binding = binding;
 269                         this.address = address;
 270                 }
 271
 272                 internal BindingAddressEndpointModel(Type contract, Binding binding,
 273                                                                                          EndpointAddress address)
 274                         : base(contract)
 275                 {
 276                         this.binding = binding;
 277                         this.endpointAddress = address;
 278                 }
 279
 280                 public Binding Binding
 281                 {
 282                         get { return binding; }
 283                 }
 284
 285                 public string Address
 286                 {
 287                         get { return address ?? endpointAddress.Uri.AbsoluteUri; }
 288                 }
 289
 290                 public EndpointAddress EndpointAddress
 291                 {
 292                         get { return endpointAddress; }
 293                 }
 294
 295                 public Uri ViaAddress
 296                 {
 297                         get { return new Uri(via, UriKind.Absolute); }
 298                 }
 299
 300                 public bool HasViaAddress
 301                 {
 302                         get { return !string.IsNullOrEmpty(via); }
 303                 }
 304
 305                 public BindingAddressEndpointModel Via(string physicalAddress)
 306                 {
 307                         via = physicalAddress;
 308                         return this;
 309                 }
 310
 311                 protected override void Accept(IWcfEndpointVisitor visitor)
 312                 {
 313                         visitor.VisitBindingAddressEndpoint(this);
 314                 }
 315         }
 316
 317         #endregion
 318 }
 319