InversionOfControl/Castle.MicroKernel/Facilities/Remoting/RemotingRegistry.cs

   1 // Copyright 2004-2007 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.Remoting
  16 {
  17         using System;
  18         using System.Collections;
  19         using Castle.Core;
  20         using Castle.MicroKernel;
  21
  22
  23         public class RemotingRegistry : MarshalByRefObject, IDisposable
  24         {
  25                 private readonly IKernel kernel;
  26                 private readonly IDictionary entries = Hashtable.Synchronized(new Hashtable());
  27
  28                 private readonly IDictionary genericEntries = Hashtable.Synchronized(new Hashtable());
  29
  30                 public RemotingRegistry(IKernel kernel)
  31                 {
  32                         this.kernel = kernel;
  33                 }
  34
  35                 public override object InitializeLifetimeService()
  36                 {
  37                         return null;
  38                 }
  39
  40                 public void AddComponentEntry(ComponentModel model)
  41                 {
  42                         if (model.Service.IsGenericType)
  43                         {
  44                                 genericEntries[model.Service] = model;
  45                                 return;
  46                         }
  47
  48                         entries[model.Name] = model;
  49                 }
  50
  51                 public object CreateRemoteInstance(String key)
  52                 {
  53                         GetModel(key);
  54
  55                         return kernel[key];
  56                 }
  57
  58                 private ComponentModel GetModel(string key)
  59                 {
  60                         ComponentModel model = (ComponentModel) entries[key];
  61
  62                         if (model == null)
  63                         {
  64                                 throw new KernelException(
  65                                         String.Format("No remote/available component found for key {0}", key));
  66                         }
  67
  68                         return model;
  69                 }
  70
  71                 public void Publish(string key)
  72                 {
  73                         ComponentModel model = GetModel(key);
  74
  75                         MarshalByRefObject mbr = (MarshalByRefObject) kernel[key];
  76
  77                         RemoteMarshallerActivator.Marshal(mbr, model);
  78                 }
  79
  80                 /// <summary>
  81                 /// Used in case of generics:
  82                 /// </summary>
  83                 /// <param name="serviceType"></param>
  84                 /// <returns></returns>
  85                 private ComponentModel GetModel(Type serviceType)
  86                 {
  87                         ComponentModel model = (ComponentModel) genericEntries[serviceType];
  88
  89                         if (model == null)
  90                         {
  91                                 throw new KernelException(
  92                                         String.Format("No remote/available component found for service type {0}", serviceType));
  93                         }
  94
  95                         return model;
  96                 }
  97
  98                 public object CreateRemoteInstance(Type serviceType)
  99                 {
 100                         return kernel[serviceType];
 101                 }
 102
 103
 104                 public void Publish(Type serviceType)
 105                 {
 106                         ComponentModel model = GetModel(serviceType);
 107
 108                         MarshalByRefObject mbr = (MarshalByRefObject) kernel[serviceType];
 109
 110                         RemoteMarshallerActivator.Marshal(mbr, model);
 111                 }
 112
 113                 #region IDisposable Members
 114
 115                 public void Dispose()
 116                 {
 117                         entries.Clear();
 118
 119                         genericEntries.Clear();
 120                 }
 121
 122                 #endregion
 123         }
 124 }