Rename methods.

hypercodeplace · hypercodeplace · commit 4bdee607dbd1 · 2018-11-28T17:17:53.000+05:00
diff --git a/LazyProxy.Sample/Program.cs b/LazyProxy.Sample/Program.cs
@@ -6,7 +6,7 @@ internal class Program
     {
         public static void Main(string[] args)
         {
-            var proxy = LazyProxyBuilder.CreateLazyProxyInstance<IMyService>(() =>
+            var proxy = LazyProxyBuilder.CreateInstance<IMyService>(() =>
             {
                 Console.WriteLine("The real instance creation...");
                 return new MyService();
diff --git a/LazyProxy.Tests/LazyProxyBuilderTests.cs b/LazyProxy.Tests/LazyProxyBuilderTests.cs
@@ -67,7 +67,7 @@ public abstract class AbstractTestService { }
         [Fact]
         public void ProxyMustImplementInterface()
         {
-            var proxyType = LazyProxyBuilder.BuildLazyProxyType<ITestService>();
+            var proxyType = LazyProxyBuilder.GetType<ITestService>();
 
             Assert.Contains(typeof(ITestService), proxyType.GetInterfaces());
         }
@@ -76,14 +76,14 @@ public void ProxyMustImplementInterface()
         public void ExceptionMustBeThrownForBuildingProxyByClass()
         {
             Assert.Throws<NotSupportedException>(
-                () => LazyProxyBuilder.BuildLazyProxyType<AbstractTestService>());
+                () => LazyProxyBuilder.GetType<AbstractTestService>());
         }
 
         [Fact]
         public void SameTypeMustBeReturnedInCaseDoubleRegistration()
         {
-            var proxyType1 = LazyProxyBuilder.BuildLazyProxyType<ITestService>();
-            var proxyType2 = LazyProxyBuilder.BuildLazyProxyType<ITestService>();
+            var proxyType1 = LazyProxyBuilder.GetType<ITestService>();
+            var proxyType2 = LazyProxyBuilder.GetType<ITestService>();
 
             Assert.Equal(proxyType1, proxyType2);
         }
@@ -92,7 +92,7 @@ public void SameTypeMustBeReturnedInCaseDoubleRegistration()
         public void ServiceCtorMustBeExecutedAfterMethodIsCalledAndOnlyOnce()
         {
             var constructorCounter = 0;
-            var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>
+            var proxy = LazyProxyBuilder.CreateInstance(() =>
             {
                 constructorCounter++;
                 return Mock.Of<ITestService>();
@@ -119,7 +119,7 @@ public void MethodsMustBeProxied()
             const string result1 = "result1";
             const string result2 = "result2";
 
-            var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>
+            var proxy = LazyProxyBuilder.CreateInstance(() =>
             {
                 var mock = new Mock<ITestService>(MockBehavior.Strict);
 
@@ -139,7 +139,7 @@ public async Task AsyncMethodsMustBeProxied()
             const string arg = "arg";
             const string result = "result";
 
-            var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>
+            var proxy = LazyProxyBuilder.CreateInstance(() =>
             {
                 var mock = new Mock<ITestService>(MockBehavior.Strict);
 
@@ -159,7 +159,7 @@ public void MethodsWithDefaultValuesMustBeProxied()
             const string defaultArg = "arg";
             const string result = "result";
 
-            var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>
+            var proxy = LazyProxyBuilder.CreateInstance(() =>
             {
                 var mock = new Mock<ITestService>(MockBehavior.Strict);
 
@@ -179,7 +179,7 @@ public void MethodsWithOutValuesMustBeProxied()
             var expectedOutArg = "arg";
             const string expectedResult = "result";
 
-            var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>
+            var proxy = LazyProxyBuilder.CreateInstance(() =>
             {
                 var mock = new Mock<ITestService>(MockBehavior.Strict);
 
@@ -200,7 +200,7 @@ public void MethodsWithRefValuesMustBeProxied()
             var refArg = new TestArgument();
             const string expectedResult = "result";
 
-            var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>
+            var proxy = LazyProxyBuilder.CreateInstance(() =>
             {
                 var mock = new Mock<ITestService>(MockBehavior.Strict);
 
@@ -221,7 +221,7 @@ public void GenericMethodsMustBeProxied()
             const string arg = "arg";
             const string expectedResult = "result";
 
-            var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>
+            var proxy = LazyProxyBuilder.CreateInstance(() =>
             {
                 var mock = new Mock<ITestService>(MockBehavior.Strict);
 
@@ -243,7 +243,7 @@ public void PropertyGettersMustBeProxied()
             var result1 = new TestArgument();
             const int result2 = 3;
 
-            var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>
+            var proxy = LazyProxyBuilder.CreateInstance(() =>
             {
                 var mock = new Mock<ITestService>(MockBehavior.Strict);
 
@@ -265,7 +265,7 @@ public void PropertySettersMustBeProxied()
 
             Mock<ITestService> mock = null;
 
-            var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>
+            var proxy = LazyProxyBuilder.CreateInstance(() =>
             {
                 mock = new Mock<ITestService>(MockBehavior.Strict);
 
@@ -288,7 +288,7 @@ public void IndexerGettersMustBeProxied()
             const int arg = 3;
             const string result = "result";
 
-            var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>
+            var proxy = LazyProxyBuilder.CreateInstance(() =>
             {
                 var mock = new Mock<ITestService>(MockBehavior.Strict);
 
@@ -307,7 +307,7 @@ public void IndexerSettersMustBeProxied()
             const string result = "result";
             Mock<ITestService> mock = null;
 
-            var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>
+            var proxy = LazyProxyBuilder.CreateInstance(() =>
             {
                 mock = new Mock<ITestService>(MockBehavior.Strict);
 
@@ -326,7 +326,7 @@ public void ExceptionsFromServiceMustBeThrown()
         {
             const bool arg = true;
 
-            var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>
+            var proxy = LazyProxyBuilder.CreateInstance(() =>
             {
                 var mock = new Mock<ITestService>(MockBehavior.Strict);
 
@@ -346,7 +346,7 @@ public void GenericInterfacesMustBeProxied()
             var expectedResult1 = new TestArgument4();
             var expectedResult2 = new TestArgument2();
 
-            var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>
+            var proxy = LazyProxyBuilder.CreateInstance(() =>
             {
                 var mock = new Mock<IGenericTestService<TestArgument2, TestArgument, TestArgument4>>(MockBehavior.Strict);
 
@@ -368,9 +368,9 @@ public void GenericInterfaceWithDifferentTypeParametersMustBeCreatedWithoutExcep
         {
             var exception = Record.Exception(() =>
             {
-                LazyProxyBuilder.BuildLazyProxyType(typeof(IGenericTestService<,,>));
-                LazyProxyBuilder.BuildLazyProxyType<IGenericTestService<TestArgument2, TestArgument, TestArgument4>>();
-                LazyProxyBuilder.BuildLazyProxyType<IGenericTestService<TestArgument3, TestArgument, TestArgument4>>();
+                LazyProxyBuilder.GetType(typeof(IGenericTestService<,,>));
+                LazyProxyBuilder.GetType<IGenericTestService<TestArgument2, TestArgument, TestArgument4>>();
+                LazyProxyBuilder.GetType<IGenericTestService<TestArgument3, TestArgument, TestArgument4>>();
 
             });
 
diff --git a/LazyProxy/LazyProxyBuilder.cs b/LazyProxy/LazyProxyBuilder.cs
@@ -31,9 +31,9 @@ public static class LazyProxyBuilder
         /// </summary>
         /// <typeparam name="T">The interface proxy type implements.</typeparam>
         /// <returns>The lazy proxy type.</returns>
-        public static Type BuildLazyProxyType<T>()
+        public static Type GetType<T>()
         {
-            return BuildLazyProxyType(typeof(T));
+            return GetType(typeof(T));
         }
 
         /// <summary>
@@ -42,7 +42,7 @@ public static Type BuildLazyProxyType<T>()
         /// </summary>
         /// <param name="type">The interface proxy type implements.</param>
         /// <returns>The lazy proxy type.</returns>
-        public static Type BuildLazyProxyType(Type type)
+        public static Type GetType(Type type)
         {
             // There is no way to constraint it on the compilation step.
             if (!type.IsInterface)
@@ -62,10 +62,10 @@ public static Type BuildLazyProxyType(Type type)
         /// <param name="valueFactory">The function real value returns.</param>
         /// <typeparam name="T">The interface proxy type implements.</typeparam>
         /// <returns>The lazy proxy type instance.</returns>
-        public static T CreateLazyProxyInstance<T>(Func<T> valueFactory)
+        public static T CreateInstance<T>(Func<T> valueFactory)
         {
             var lazy = new Lazy<T>(valueFactory);
-            var proxyType = BuildLazyProxyType<T>();
+            var proxyType = GetType<T>();
             return (T) Activator.CreateInstance(proxyType, lazy);
         }
 

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ internal class Program`
`6`	`6`	`{`
`7`	`7`	`public static void Main(string[] args)`
`8`	`8`	`{`
`9`		`- var proxy = LazyProxyBuilder.CreateLazyProxyInstance<IMyService>(() =>`
	`9`	`+ var proxy = LazyProxyBuilder.CreateInstance<IMyService>(() =>`
`10`	`10`	`{`
`11`	`11`	`Console.WriteLine("The real instance creation...");`
`12`	`12`	`return new MyService();`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ public abstract class AbstractTestService { }`
`67`	`67`	`[Fact]`
`68`	`68`	`public void ProxyMustImplementInterface()`
`69`	`69`	`{`
`70`		`- var proxyType = LazyProxyBuilder.BuildLazyProxyType<ITestService>();`
	`70`	`+ var proxyType = LazyProxyBuilder.GetType<ITestService>();`
`71`	`71`
`72`	`72`	`Assert.Contains(typeof(ITestService), proxyType.GetInterfaces());`
`73`	`73`	`}`
`@@ -76,14 +76,14 @@ public void ProxyMustImplementInterface()`
`76`	`76`	`public void ExceptionMustBeThrownForBuildingProxyByClass()`
`77`	`77`	`{`
`78`	`78`	`Assert.Throws<NotSupportedException>(`
`79`		`- () => LazyProxyBuilder.BuildLazyProxyType<AbstractTestService>());`
	`79`	`+ () => LazyProxyBuilder.GetType<AbstractTestService>());`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`[Fact]`
`83`	`83`	`public void SameTypeMustBeReturnedInCaseDoubleRegistration()`
`84`	`84`	`{`
`85`		`- var proxyType1 = LazyProxyBuilder.BuildLazyProxyType<ITestService>();`
`86`		`- var proxyType2 = LazyProxyBuilder.BuildLazyProxyType<ITestService>();`
	`85`	`+ var proxyType1 = LazyProxyBuilder.GetType<ITestService>();`
	`86`	`+ var proxyType2 = LazyProxyBuilder.GetType<ITestService>();`
`87`	`87`
`88`	`88`	`Assert.Equal(proxyType1, proxyType2);`
`89`	`89`	`}`
`@@ -92,7 +92,7 @@ public void SameTypeMustBeReturnedInCaseDoubleRegistration()`
`92`	`92`	`public void ServiceCtorMustBeExecutedAfterMethodIsCalledAndOnlyOnce()`
`93`	`93`	`{`
`94`	`94`	`var constructorCounter = 0;`
`95`		`- var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>`
	`95`	`+ var proxy = LazyProxyBuilder.CreateInstance(() =>`
`96`	`96`	`{`
`97`	`97`	`constructorCounter++;`
`98`	`98`	`return Mock.Of<ITestService>();`
`@@ -119,7 +119,7 @@ public void MethodsMustBeProxied()`
`119`	`119`	`const string result1 = "result1";`
`120`	`120`	`const string result2 = "result2";`
`121`	`121`
`122`		`- var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>`
	`122`	`+ var proxy = LazyProxyBuilder.CreateInstance(() =>`
`123`	`123`	`{`
`124`	`124`	`var mock = new Mock<ITestService>(MockBehavior.Strict);`
`125`	`125`
`@@ -139,7 +139,7 @@ public async Task AsyncMethodsMustBeProxied()`
`139`	`139`	`const string arg = "arg";`
`140`	`140`	`const string result = "result";`
`141`	`141`
`142`		`- var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>`
	`142`	`+ var proxy = LazyProxyBuilder.CreateInstance(() =>`
`143`	`143`	`{`
`144`	`144`	`var mock = new Mock<ITestService>(MockBehavior.Strict);`
`145`	`145`
`@@ -159,7 +159,7 @@ public void MethodsWithDefaultValuesMustBeProxied()`
`159`	`159`	`const string defaultArg = "arg";`
`160`	`160`	`const string result = "result";`
`161`	`161`
`162`		`- var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>`
	`162`	`+ var proxy = LazyProxyBuilder.CreateInstance(() =>`
`163`	`163`	`{`
`164`	`164`	`var mock = new Mock<ITestService>(MockBehavior.Strict);`
`165`	`165`
`@@ -179,7 +179,7 @@ public void MethodsWithOutValuesMustBeProxied()`
`179`	`179`	`var expectedOutArg = "arg";`
`180`	`180`	`const string expectedResult = "result";`
`181`	`181`
`182`		`- var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>`
	`182`	`+ var proxy = LazyProxyBuilder.CreateInstance(() =>`
`183`	`183`	`{`
`184`	`184`	`var mock = new Mock<ITestService>(MockBehavior.Strict);`
`185`	`185`
`@@ -200,7 +200,7 @@ public void MethodsWithRefValuesMustBeProxied()`
`200`	`200`	`var refArg = new TestArgument();`
`201`	`201`	`const string expectedResult = "result";`
`202`	`202`
`203`		`- var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>`
	`203`	`+ var proxy = LazyProxyBuilder.CreateInstance(() =>`
`204`	`204`	`{`
`205`	`205`	`var mock = new Mock<ITestService>(MockBehavior.Strict);`
`206`	`206`
`@@ -221,7 +221,7 @@ public void GenericMethodsMustBeProxied()`
`221`	`221`	`const string arg = "arg";`
`222`	`222`	`const string expectedResult = "result";`
`223`	`223`
`224`		`- var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>`
	`224`	`+ var proxy = LazyProxyBuilder.CreateInstance(() =>`
`225`	`225`	`{`
`226`	`226`	`var mock = new Mock<ITestService>(MockBehavior.Strict);`
`227`	`227`
`@@ -243,7 +243,7 @@ public void PropertyGettersMustBeProxied()`
`243`	`243`	`var result1 = new TestArgument();`
`244`	`244`	`const int result2 = 3;`
`245`	`245`
`246`		`- var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>`
	`246`	`+ var proxy = LazyProxyBuilder.CreateInstance(() =>`
`247`	`247`	`{`
`248`	`248`	`var mock = new Mock<ITestService>(MockBehavior.Strict);`
`249`	`249`
`@@ -265,7 +265,7 @@ public void PropertySettersMustBeProxied()`
`265`	`265`
`266`	`266`	`Mock<ITestService> mock = null;`
`267`	`267`
`268`		`- var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>`
	`268`	`+ var proxy = LazyProxyBuilder.CreateInstance(() =>`
`269`	`269`	`{`
`270`	`270`	`mock = new Mock<ITestService>(MockBehavior.Strict);`
`271`	`271`
`@@ -288,7 +288,7 @@ public void IndexerGettersMustBeProxied()`
`288`	`288`	`const int arg = 3;`
`289`	`289`	`const string result = "result";`
`290`	`290`
`291`		`- var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>`
	`291`	`+ var proxy = LazyProxyBuilder.CreateInstance(() =>`
`292`	`292`	`{`
`293`	`293`	`var mock = new Mock<ITestService>(MockBehavior.Strict);`
`294`	`294`
`@@ -307,7 +307,7 @@ public void IndexerSettersMustBeProxied()`
`307`	`307`	`const string result = "result";`
`308`	`308`	`Mock<ITestService> mock = null;`
`309`	`309`
`310`		`- var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>`
	`310`	`+ var proxy = LazyProxyBuilder.CreateInstance(() =>`
`311`	`311`	`{`
`312`	`312`	`mock = new Mock<ITestService>(MockBehavior.Strict);`
`313`	`313`
`@@ -326,7 +326,7 @@ public void ExceptionsFromServiceMustBeThrown()`
`326`	`326`	`{`
`327`	`327`	`const bool arg = true;`
`328`	`328`
`329`		`- var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>`
	`329`	`+ var proxy = LazyProxyBuilder.CreateInstance(() =>`
`330`	`330`	`{`
`331`	`331`	`var mock = new Mock<ITestService>(MockBehavior.Strict);`
`332`	`332`
`@@ -346,7 +346,7 @@ public void GenericInterfacesMustBeProxied()`
`346`	`346`	`var expectedResult1 = new TestArgument4();`
`347`	`347`	`var expectedResult2 = new TestArgument2();`
`348`	`348`
`349`		`- var proxy = LazyProxyBuilder.CreateLazyProxyInstance(() =>`
	`349`	`+ var proxy = LazyProxyBuilder.CreateInstance(() =>`
`350`	`350`	`{`
`351`	`351`	`var mock = new Mock<IGenericTestService<TestArgument2, TestArgument, TestArgument4>>(MockBehavior.Strict);`
`352`	`352`
`@@ -368,9 +368,9 @@ public void GenericInterfaceWithDifferentTypeParametersMustBeCreatedWithoutExcep`
`368`	`368`	`{`
`369`	`369`	`var exception = Record.Exception(() =>`
`370`	`370`	`{`
`371`		`- LazyProxyBuilder.BuildLazyProxyType(typeof(IGenericTestService<,,>));`
`372`		`- LazyProxyBuilder.BuildLazyProxyType<IGenericTestService<TestArgument2, TestArgument, TestArgument4>>();`
`373`		`- LazyProxyBuilder.BuildLazyProxyType<IGenericTestService<TestArgument3, TestArgument, TestArgument4>>();`
	`371`	`+ LazyProxyBuilder.GetType(typeof(IGenericTestService<,,>));`
	`372`	`+ LazyProxyBuilder.GetType<IGenericTestService<TestArgument2, TestArgument, TestArgument4>>();`
	`373`	`+ LazyProxyBuilder.GetType<IGenericTestService<TestArgument3, TestArgument, TestArgument4>>();`
`374`	`374`
`375`	`375`	`});`
`376`	`376`