Use interface instead of base class

dahlbyk · dahlbyk · commit 034dd8cf18c4 · 2012-10-28T22:47:56.000-05:00
diff --git a/LibGit2Sharp/Core/LazyProperty.cs b/LibGit2Sharp/Core/LazyProperty.cs
@@ -4,33 +4,21 @@
 
 namespace LibGit2Sharp.Core
 {
-    internal class LazyProperty<TType> : LazyPropertyBase
+    internal class LazyProperty<TType> : IEvaluator<GitObjectSafeHandle>
     {
-        public LazyProperty(Func<GitObjectSafeHandle, object> evaluator, LazyGroup lazyGroup)
-            : base(evaluator, lazyGroup)
-        { }
-
-        public TType Value
-        {
-            get { return (TType)base.Value; }
-        }
-    }
-
-    internal class LazyPropertyBase
-    {
-        private readonly Func<GitObjectSafeHandle, object> evaluator;
+        private readonly Func<GitObjectSafeHandle, TType> evaluator;
         private readonly LazyGroup lazyGroup;
 
-        private object value;
+        private TType value;
         private bool hasBeenEvaluated;
 
-        public LazyPropertyBase(Func<GitObjectSafeHandle, object> evaluator, LazyGroup lazyGroup)
+        public LazyProperty(Func<GitObjectSafeHandle, TType> evaluator, LazyGroup lazyGroup)
         {
             this.evaluator = evaluator;
             this.lazyGroup = lazyGroup;
         }
 
-        public object Value
+        public TType Value
         {
             get { return Evaluate(); }
         }
@@ -40,7 +28,7 @@ internal LazyGroup Group
             get { return lazyGroup; }
         }
 
-        private object Evaluate()
+        private TType Evaluate()
         {
             if (!hasBeenEvaluated)
             {
@@ -56,27 +44,32 @@ private object Evaluate()
             return value;
         }
 
-        internal void InternalEvaluate(GitObjectSafeHandle objectPtr)
+        void IEvaluator<GitObjectSafeHandle>.Evaluate(GitObjectSafeHandle objectPtr)
         {
             hasBeenEvaluated = true;
             value = evaluator(objectPtr);
         }
     }
 
+    internal interface IEvaluator<T>
+    {
+        void Evaluate(T input);
+    }
+
     internal class LazyGroup
     {
         private readonly Repository repo;
         private readonly ObjectId id;
 
-        private readonly IList<LazyPropertyBase> lazies = new List<LazyPropertyBase>();
+        private readonly IList<IEvaluator<GitObjectSafeHandle>> lazies = new List<IEvaluator<GitObjectSafeHandle>>();
 
         public LazyGroup(Repository repo, ObjectId id)
         {
             this.repo = repo;
             this.id = id;
         }
 
-        public LazyProperty<TType> AddLazy<TType>(Func<GitObjectSafeHandle, object> evaluator)
+        public LazyProperty<TType> AddLazy<TType>(Func<GitObjectSafeHandle, TType> evaluator)
         {
             var lazy = new LazyProperty<TType>(evaluator, this);
             lazies.Add(lazy);
@@ -89,7 +82,7 @@ public void TriggerEvaluation()
             {
                 foreach (var lazy in lazies)
                 {
-                    lazy.InternalEvaluate(osw.ObjectPtr);
+                    lazy.Evaluate(osw.ObjectPtr);
                 }
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -4,33 +4,21 @@`
`4`	`4`
`5`	`5`	`namespace LibGit2Sharp.Core`
`6`	`6`	`{`
`7`		`- internal class LazyProperty<TType> : LazyPropertyBase`
	`7`	`+ internal class LazyProperty<TType> : IEvaluator<GitObjectSafeHandle>`
`8`	`8`	`{`
`9`		`- public LazyProperty(Func<GitObjectSafeHandle, object> evaluator, LazyGroup lazyGroup)`
`10`		`- : base(evaluator, lazyGroup)`
`11`		`- { }`
`12`		`-`
`13`		`- public TType Value`
`14`		`- {`
`15`		`- get { return (TType)base.Value; }`
`16`		`- }`
`17`		`- }`
`18`		`-`
`19`		`- internal class LazyPropertyBase`
`20`		`- {`
`21`		`- private readonly Func<GitObjectSafeHandle, object> evaluator;`
	`9`	`+ private readonly Func<GitObjectSafeHandle, TType> evaluator;`
`22`	`10`	`private readonly LazyGroup lazyGroup;`
`23`	`11`
`24`		`- private object value;`
	`12`	`+ private TType value;`
`25`	`13`	`private bool hasBeenEvaluated;`
`26`	`14`
`27`		`- public LazyPropertyBase(Func<GitObjectSafeHandle, object> evaluator, LazyGroup lazyGroup)`
	`15`	`+ public LazyProperty(Func<GitObjectSafeHandle, TType> evaluator, LazyGroup lazyGroup)`
`28`	`16`	`{`
`29`	`17`	`this.evaluator = evaluator;`
`30`	`18`	`this.lazyGroup = lazyGroup;`
`31`	`19`	`}`
`32`	`20`
`33`		`- public object Value`
	`21`	`+ public TType Value`
`34`	`22`	`{`
`35`	`23`	`get { return Evaluate(); }`
`36`	`24`	`}`
`@@ -40,7 +28,7 @@ internal LazyGroup Group`
`40`	`28`	`get { return lazyGroup; }`
`41`	`29`	`}`
`42`	`30`
`43`		`- private object Evaluate()`
	`31`	`+ private TType Evaluate()`
`44`	`32`	`{`
`45`	`33`	`if (!hasBeenEvaluated)`
`46`	`34`	`{`
`@@ -56,27 +44,32 @@ private object Evaluate()`
`56`	`44`	`return value;`
`57`	`45`	`}`
`58`	`46`
`59`		`- internal void InternalEvaluate(GitObjectSafeHandle objectPtr)`
	`47`	`+ void IEvaluator<GitObjectSafeHandle>.Evaluate(GitObjectSafeHandle objectPtr)`
`60`	`48`	`{`
`61`	`49`	`hasBeenEvaluated = true;`
`62`	`50`	`value = evaluator(objectPtr);`
`63`	`51`	`}`
`64`	`52`	`}`
`65`	`53`
	`54`	`+ internal interface IEvaluator<T>`
	`55`	`+ {`
	`56`	`+ void Evaluate(T input);`
	`57`	`+ }`
	`58`	`+`
`66`	`59`	`internal class LazyGroup`
`67`	`60`	`{`
`68`	`61`	`private readonly Repository repo;`
`69`	`62`	`private readonly ObjectId id;`
`70`	`63`
`71`		`- private readonly IList<LazyPropertyBase> lazies = new List<LazyPropertyBase>();`
	`64`	`+ private readonly IList<IEvaluator<GitObjectSafeHandle>> lazies = new List<IEvaluator<GitObjectSafeHandle>>();`
`72`	`65`
`73`	`66`	`public LazyGroup(Repository repo, ObjectId id)`
`74`	`67`	`{`
`75`	`68`	`this.repo = repo;`
`76`	`69`	`this.id = id;`
`77`	`70`	`}`
`78`	`71`
`79`		`- public LazyProperty<TType> AddLazy<TType>(Func<GitObjectSafeHandle, object> evaluator)`
	`72`	`+ public LazyProperty<TType> AddLazy<TType>(Func<GitObjectSafeHandle, TType> evaluator)`
`80`	`73`	`{`
`81`	`74`	`var lazy = new LazyProperty<TType>(evaluator, this);`
`82`	`75`	`lazies.Add(lazy);`
`@@ -89,7 +82,7 @@ public void TriggerEvaluation()`
`89`	`82`	`{`
`90`	`83`	`foreach (var lazy in lazies)`
`91`	`84`	`{`
`92`		`- lazy.InternalEvaluate(osw.ObjectPtr);`
	`85`	`+ lazy.Evaluate(osw.ObjectPtr);`
`93`	`86`	`}`
`94`	`87`	`}`
`95`	`88`	`}`