Facilities/Wcf/Castle.Facilities.WcfIntegration/Internal/WcfUtils.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.Internal
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Generic;
  20         using System.ServiceModel;
  21         using Castle.Core;
  22         using Castle.MicroKernel;
  23
  24         internal static class WcfUtils
  25         {
  26                 public static bool IsHosted(IWcfServiceModel serviceModel)
  27                 {
  28                         return serviceModel.IsHosted;
  29                 }
  30
  31                 public static IEnumerable<T> FindDependencies<T>(IDictionary dependencies)
  32                 {
  33                         return FindDependencies<T>(dependencies, null);
  34                 }
  35
  36                 public static IEnumerable<T> FindDependencies<T>(IDictionary dependencies,
  37                                                                      Predicate<T> test)
  38                 {
  39                         foreach (object dependency in dependencies.Values)
  40                         {
  41                                 if (dependency is T)
  42                                 {
  43                                         T candidate = (T)dependency;
  44
  45                                         if (test == null || test(candidate))
  46                                         {
  47                                                 yield return candidate;
  48                                         }
  49                                 }
  50                         }
  51                 }
  52
  53                 public static IEnumerable<T> FindDependencies<T>(ICollection<T> dependencies)
  54                 {
  55                         return FindDependencies<T>(dependencies, null);
  56                 }
  57
  58                 public static IEnumerable<T> FindDependencies<T>(ICollection<T> dependencies,
  59                                                                                                      Predicate<T> test)
  60                 {
  61                         foreach (object dependency in dependencies)
  62                         {
  63                                 if (dependency is T)
  64                                 {
  65                                         T candidate = (T)dependency;
  66
  67                                         if (test == null || test(candidate))
  68                                         {
  69                                                 yield return candidate;
  70                                         }
  71                                 }
  72                         }
  73                 }
  74
  75                 public static ICollection<IHandler> FindBehaviors<T>(IKernel kernel, WcfBehaviorScope scope)
  76                 {
  77                         List<IHandler> handlers = new List<IHandler>();
  78                         foreach (IHandler handler in kernel.GetAssignableHandlers(typeof(T)))
  79                         {
  80                                 ComponentModel model = handler.ComponentModel;
  81                                 if (model.Configuration != null)
  82                                 {
  83                                         string scopeAttrib = model.Configuration.Attributes[WcfConstants.BehaviorScopeKey];
  84                                         if (string.IsNullOrEmpty(scopeAttrib) ||
  85                                                 scopeAttrib.Equals(scope.ToString(), StringComparison.InvariantCultureIgnoreCase))
  86                                         {
  87                                                 handlers.Add(handler);
  88                                         }
  89                                 }
  90                         }
  91                         return handlers;
  92                 }
  93
  94                 public static bool IsCommunicationObjectReady(ICommunicationObject comm)
  95                 {
  96                         switch (comm.State)
  97                         {
  98                                 case CommunicationState.Closed:
  99                                 case CommunicationState.Closing:
 100                                 case CommunicationState.Faulted:
 101                                         return false;
 102                         }
 103                         return true;
 104                 }
 105
 106                 public static void ReleaseCommunicationObject(ICommunicationObject comm)
 107                 {
 108                         if (comm != null)
 109                         {
 110                                 if (comm.State != CommunicationState.Faulted)
 111                                 {
 112                                         try
 113                                         {
 114                                                 comm.Close();
 115                                         }
 116                                         catch (CommunicationException)
 117                                         {
 118                                                 comm.Abort();
 119                                         }
 120                                         catch (TimeoutException)
 121                                         {
 122                                                 comm.Abort();
 123                                         }
 124                                         catch
 125                                         {
 126                                                 comm.Abort();
 127                                                 throw;
 128                                         }
 129                                 }
 130                                 else
 131                                 {
 132                                         comm.Abort();
 133                                 }
 134                         }
 135                 }
 136         }
 137 }