Org.Lwes/IoCAdapter.cs

   1 //
   2 // This file is part of the LWES .NET Binding (LWES.net)
   3 //
   4 // COPYRIGHT© 2009, Phillip Clark (phillip[at*flitbit[dot*org)
   5 //       original .NET implementation
   6 //
   7 // LWES.net is free software: you can redistribute it and/or modify
   8 // it under the terms of the Lesser GNU General Public License as published by
   9 // the Free Software Foundation, either version 3 of the License, or
  10 // (at your option) any later version.
  11 //
  12 // LWES.net is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // Lesser GNU General Public License for more details.
  16 //
  17 // You should have received a copy of the Lesser GNU General Public License
  18 // along with LWES.net.  If not, see <http://www.gnu.org/licenses/>.
  19 //
  20 namespace Org.Lwes
  21 {
  22         using System;
  23         using System.Diagnostics;
  24
  25         using Org.Lwes.Properties;
  26         using Org.Lwes.Trace;
  27
  28         /// <summary>
  29         /// Utility methods for interacting with IoC containers.
  30         /// </summary>
  31         public abstract class IoCAdapter
  32         {
  33                 #region Fields
  34
  35                 static IoCAdapter __current;
  36                 static Object __creationLock = new Object();
  37                 static bool __hardFailOnAccessingIoC;
  38
  39                 #endregion Fields
  40
  41                 #region Properties
  42
  43                 internal static IoCAdapter Current
  44                 {
  45                         get
  46                         {
  47                                 if (__hardFailOnAccessingIoC) return null;
  48                                 return Util.LazyInitializeWithLock(ref __current, __creationLock, () =>
  49                                         {
  50                                                 return CreateIoCAdapterFromConfiguration();
  51                                         });
  52                         }
  53                 }
  54
  55                 #endregion Properties
  56
  57                 #region Methods
  58
  59                 /// <summary>
  60                 /// Tries to create a named instance of type T using the currently
  61                 /// configured IoC container.
  62                 /// </summary>
  63                 /// <typeparam name="T">instance type T</typeparam>
  64                 /// <param name="instance">reference to a variable where the resulting
  65                 /// instance will be stored</param>
  66                 /// <returns><em>true</em> if a valid instance of type <typeparamref name="T"/> was stored
  67                 /// in <paramref name="instance"/>; otherwise <em>false</em></returns>
  68                 public static bool TryCreateFromIoC<T>(out T instance)
  69                 {
  70                         if (!__hardFailOnAccessingIoC)
  71                         {
  72                                 try
  73                                 {
  74                                         // Try to use the service locator - this is IoC implementation independent
  75                                         IoCAdapter current = IoCAdapter.Current;
  76                                         if (current != null)
  77                                         {
  78                                                 return current.TryCreate(out instance);
  79                                         }
  80                                 }
  81                                 catch (Exception e)
  82                                 {
  83                                         Traceable.TraceData(typeof(IoCAdapter), TraceEventType.Error, Resources.Error_IocAdapterFailure, e);
  84                                         /* IoC failure - remember this and stop trying */
  85                                         __hardFailOnAccessingIoC = true;
  86                                 }
  87                         }
  88                         instance = default(T);
  89                         return false;
  90                 }
  91
  92                 /// <summary>
  93                 /// Tries to create a named instance of type T using the currently
  94                 /// configured IoC container.
  95                 /// </summary>
  96                 /// <typeparam name="T">instance type T</typeparam>
  97                 /// <param name="name">name of the instance</param>
  98                 /// <param name="instance">reference to a variable where the resulting
  99                 /// instance will be stored</param>
 100                 /// <returns><em>true</em> if a valid instance of type T was stored
 101                 /// in <paramref name="instance"/>; otherwise <em>false</em></returns>
 102                 public static bool TryCreateFromIoC<T>(string name, out T instance)
 103                 {
 104                         if (!__hardFailOnAccessingIoC)
 105                         {
 106                                 try
 107                                 {
 108                                         // Try to use the service locator - this is IoC implementation independent
 109                                         IoCAdapter current = IoCAdapter.Current;
 110                                         if (current != null)
 111                                         {
 112                                                 return current.TryCreate(out instance);
 113                                         }
 114                                 }
 115                                 catch (Exception e)
 116                                 {
 117                                         // Set the failure first so we don't recurse inadvertently
 118                                         __hardFailOnAccessingIoC = true;
 119
 120                                         Traceable.TraceData(typeof(IoCAdapter), TraceEventType.Error, Resources.Error_IocAdapterFailure, e);
 121                                         /* IoC failure - remember this and stop trying */
 122                                 }
 123                         }
 124                         instance = default(T);
 125                         return false;
 126                 }
 127
 128                 /// <summary>
 129                 /// Tries to create/access an instance of type T
 130                 /// </summary>
 131                 /// <typeparam name="T">target type T</typeparam>
 132                 /// <param name="instance">reference to a variable that will hold the instance</param>
 133                 /// <returns><em>true</em> if the variable is set to a valid instance of type T
 134                 /// during the call; otherwise <em>false</em></returns>
 135                 public abstract bool TryCreate<T>(out T instance);
 136
 137                 /// <summary>
 138                 /// Tries to create/access a named instance of type T
 139                 /// </summary>
 140                 /// <typeparam name="T">target type T</typeparam>
 141                 /// <param name="name">name of an instance to create</param>
 142                 /// <param name="instance">reference to a variable that will hold the instance</param>
 143                 /// <returns><em>true</em> if the variable is set to a valid instance of type T
 144                 /// during the call; otherwise <em>false</em></returns>
 145                 public abstract bool TryCreate<T>(string name, out T instance);
 146
 147                 private static IoCAdapter CreateIoCAdapterFromConfiguration()
 148                 {
 149                         // TODO: Add config sections for various IoC adapters
 150                         return new DefaultIoCAdapter();
 151                 }
 152
 153                 class DefaultIoCAdapter : IoCAdapter
 154                 {
 155                         public override bool TryCreate<T>(out T instance)
 156                         {
 157                                 instance = Activator.CreateInstance<T>();
 158                                 return true;
 159                         }
 160
 161                         public override bool TryCreate<T>(string name, out T instance)
 162                         {
 163                                 // no support for named instances
 164                                 instance = default(T);
 165                                 return false;
 166                         }
 167                 }
 168
 169                 #endregion Methods
 170         }
 171 }