InversionOfControl/Castle.Windsor.Tests/Components/DotNet2Components.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
  16 namespace Castle.Windsor.Tests
  17 {
  18         using System;
  19         using System.Collections;
  20         using Castle.Windsor.Tests.Components;
  21
  22         public interface IRepository<T>
  23         {
  24                 T Get(int id);
  25         }
  26
  27         public class DemoRepository<T> : IRepository<T>
  28         {
  29                 private string name;
  30                 private ICache<T> cache;
  31
  32                 public ICache<T> Cache
  33                 {
  34                         get { return cache; }
  35                         set { cache = value; }
  36                 }
  37
  38                 public string Name
  39                 {
  40                         get { return name; }
  41                         set { name = value; }
  42                 }
  43
  44                 public T Get(int id)
  45                 {
  46                         return Activator.CreateInstance<T>();
  47                 }
  48         }
  49
  50         public class ReviewerRepository : DemoRepository<IReviewer>
  51         {
  52                 private string name;
  53                 private ICache<IReviewer> cache;
  54
  55                 public new ICache<IReviewer> Cache
  56                 {
  57                         get { return cache; }
  58                         set { cache = value; }
  59                 }
  60
  61                 public new string Name
  62                 {
  63                         get { return name; }
  64                         set { name = value; }
  65                 }
  66
  67                 public new IReviewer Get(int id)
  68                 {
  69                         return null;
  70                 }
  71         }
  72
  73         public interface ICache<T>
  74         {
  75                 void Put(string key, T item);
  76                 T Get(string key);
  77         }
  78
  79         public class HashTableCache<T> : ICache<T>
  80         {
  81                 private Hashtable hash = new Hashtable();
  82
  83                 public void Put(string key, T item)
  84                 {
  85                         hash[key] = item;
  86                 }
  87
  88                 public T Get(string key)
  89                 {
  90                         return (T) hash[key];
  91                 }
  92         }
  93
  94         public class NullCache<T> : ICache<T>
  95         {
  96                 public void Put(string key, T item)
  97                 {
  98                 }
  99
 100                 public T Get(string key)
 101                 {
 102                         return default(T);
 103                 }
 104         }
 105
 106         public class LoggingRepositoryDecorator<T> : IRepository<T>
 107         {
 108                 public IRepository<T> inner;
 109
 110                 public LoggingRepositoryDecorator()
 111                 {
 112                 }
 113
 114                 public LoggingRepositoryDecorator(IRepository<T> inner)
 115                 {
 116                         this.inner = inner;
 117                 }
 118
 119             public T Get(int id)
 120                 {
 121                         Console.WriteLine("Getting {0}", id);
 122                         return inner.Get(id);
 123                 }
 124         }
 125
 126         [Castle.Core.Transient]
 127         public class TransientRepository<T> : IRepository<T> where T : new()
 128         {
 129                 public T Get(int id)
 130                 {
 131                         return new T();
 132                 }
 133         }
 134
 135         public class NeedsGenericType
 136         {
 137                 private ICache<string> cache;
 138
 139                 public NeedsGenericType(ICache<string> cache)
 140                 {
 141                         this.cache = cache;
 142                 }
 143         }
 144 }