Typo fixed

Author: npodbielski

README.md

@@ -38,27 +38,27 @@ delegate for default constructor can be obtained with DelegateFactory in followi
 
 1. If you are have access to type in compile time:
 
- `var cd = DelegateFactory.DefaultContructor<TestClass>();`
+ `var cd = DelegateFactory.DefaultConstructor<TestClass>();`
 
  Created delegate in such case is `Func<TestClass>`
- The same delegate can be created with Contructor method:
+ The same delegate can be created with Constructor method:
 
- `var cd = DelegateFactory.Contructor<Func<TestClass>>();`
+ `var cd = DelegateFactory.Constructor<Func<TestClass>>();`
 
 2. If you do not have access to type in compile time (private type, dynamic or otherwise inaccessible)
 
- `var cd = TestClassType.DefaultContructor();`
+ `var cd = TestClassType.DefaultConstructor();`
 
  Created delegate in such case is `Func<object>`
- The same delegate can be created with Contructor method:
+ The same delegate can be created with Constructor method:
 
- `var cd = TestClassType.Contructor<Func<object>>();`
+ `var cd = TestClassType.Constructor<Func<object>>();`
 
  Return value is of object type, so we cannot access its members directly, without casting or if it is not possible, members can be accessed via delegates.
 
-3. If for some reason you want to create delegate to different constructor depending on some arbitrary, runtime conditions or you do not have access to parameter types in compile time, Contructor(params Type[]) method overload can be used:
+3. If for some reason you want to create delegate to different constructor depending on some arbitrary, runtime conditions or you do not have access to parameter types in compile time, Constructor(params Type[]) method overload can be used:
 
- `var cd = TestClassType.Contructor();`
+ `var cd = TestClassType.Constructor();`
 
  Created delegate in such case is `Func<object[]. object>`
  You can call it in following way:
@@ -80,25 +80,25 @@ delegate can be created in following ways:
 
 1. If you are have access to type in compile time:
 
- `var c = DelegateFactory.Contructor<Func<int, TestClass>>();`
+ `var c = DelegateFactory.Constructor<Func<int, TestClass>>();`
 
  Created delegate can be called as any other method that accepts single parameter of Int type:
 
  `var instance = c(0);`
 
 2. If you do not have access to type in compile time:
 
- `var c = TestClassType.Contructor<Func<int, object>>();`
+ `var c = TestClassType.Constructor<Func<int, object>>();`
 
  Created delegate can be called as any other method that accepts single parameter of Int type:
 
  `var instance = c(0);`
 
  Return value is type of object, so we cannot access its members directly, without casting or if it is not possible, members can be accessed via delegates.
 
-3. If for some reason you want to create delegate to different constructor depending on some arbitrary, runtime conditions or you do not have access to parameter types in compile time, Contructor(params Type[]) method overload can be used:
+3. If for some reason you want to create delegate to different constructor depending on some arbitrary, runtime conditions or you do not have access to parameter types in compile time, Constructor(params Type[]) method overload can be used:
 
- `var c = TestClassType.Contructor(typeof(int));`
+ `var c = TestClassType.Constructor(typeof(int));`
 
  Created delegate in such case is `Func<object[]. object>`
  You can call it in following way:
@@ -109,7 +109,7 @@ delegate can be created in following ways:
 
 Delegates can be created for any constructor (visibility do not matter) with any combination of parameters. There is no limitation for number of parameters of constructor. All of above methods works for both classes and structures.
 
-If you have access to all neccessary types and can create compatible delegate type, `Contructor<TDelegate>` method can be used. TDelegate type must follow these rules:
+If you have access to all neccessary types and can create compatible delegate type, `Constructor<TDelegate>` method can be used. TDelegate type must follow these rules:
 - parameters of delegate *must be* exactly of the same types and order as constructor
 - return type of delegate *must be* type with constructor
 
@@ -119,26 +119,26 @@ I.e. if you constructor have 3 parameters:
 
 TDelegate *must be* `Func<string,int,bool,TestClass>`. It is because collection of constructor parameters are taked from TDelegate definition and constructor is searched in return type of defined TDelegate.
 
-`var c = DelegateFactory.Contructor<Func<string, int, bool, TestClass>>();`
+`var c = DelegateFactory.Constructor<Func<string, int, bool, TestClass>>();`
 
 There is no limitation for type of delegate that can be accepted. For example, it can be `Func<>`, but do not have to. You can create your own delegate type, but it is must follow above restrictions.
 
 `public delegate TestClass CustomCtrSingleParam(int i);
-var cd = DelegateFactory.Contructor<CustomCtrSingleParam>();
+var cd = DelegateFactory.Constructor<CustomCtrSingleParam>();
 var instance = cd(0);`
 
 
-If you do not have access to type with constructor in compile time and still have access to constructor parameters types, `Contructor<TDelegate>(this Type)` extension method can be used. In this case return type of delegate can be any type that can be casted from source type (i.e. interface of TestClass, base type or object).
+If you do not have access to type with constructor in compile time and still have access to constructor parameters types, `Constructor<TDelegate>(this Type)` extension method can be used. In this case return type of delegate can be any type that can be casted from source type (i.e. interface of TestClass, base type or object).
 
-`var c = TestClassType.Contructor<Func<string, string, DateTime, object>>();`
+`var c = TestClassType.Constructor<Func<string, string, DateTime, object>>();`
 
 Restriction for parameters types and order still applies. 
 
 
-However if you do not have access to parameters types `Contructor(this Type, params Type[])` extension method ca be used. Array of parameters types must be *exactly the same* order and length as type of parameters of constructor. Overload do not require any delegate type. Instead have fixed delegate to `Func<object[], object>`. First parameter of created delegate is array of all constructor parameters values. It can be larger than required collection. Returned object is created instance. There is no limitation of number of parameters of constructor.
+However if you do not have access to parameters types `Constructor(this Type, params Type[])` extension method ca be used. Array of parameters types must be *exactly the same* order and length as type of parameters of constructor. Overload do not require any delegate type. Instead have fixed delegate to `Func<object[], object>`. First parameter of created delegate is array of all constructor parameters values. It can be larger than required collection. Returned object is created instance. There is no limitation of number of parameters of constructor.
 
-`var c = TestClassType.Contructor(typeof(bool));`
-`var c = TestClassType.Contructor(typeof(string), typeof(bool), typeof(IDisposable));`
+`var c = TestClassType.Constructor(typeof(bool));`
+`var c = TestClassType.Constructor(typeof(string), typeof(bool), typeof(IDisposable));`
 
 
 ###Static Properties

src/DelegatesApp/ConsoleApplication.cs

@@ -38,22 +38,22 @@ private static void Main(string[] args)
 
         private static void TestConstructors()
         {
-            var cd = DelegateFactory.DefaultContructor<TestClass>();
-            var cd1 = Type.DefaultContructor();
-            var cd2 = Type.Contructor<Func<object>>();
+            var cd = DelegateFactory.DefaultConstructor<TestClass>();
+            var cd1 = Type.DefaultConstructor();
+            var cd2 = Type.Constructor<Func<object>>();
 
             var t_ = cd();
             var t1 = cd1();
             var t2 = cd2();
 
-            var c1 = DelegateFactory.Contructor<Func<TestClass>>();
-            var c2 = DelegateFactory.Contructor<Func<int, TestClass>>();
-            var c3 = DelegateFactory.Contructor<Func<bool, TestClass>>();
-            var c4 = DelegateFactory.Contructor<Func<string, TestClass>>();
-            var c5 = DelegateFactory.Contructor<Func<int, TestClass>>();
-            var c6 = Type.Contructor(typeof(int));
-            var c7 = typeof(TestStruct).Contructor<Func<int, object>>();
-            var c8 = typeof(TestStruct).Contructor(typeof(int));
+            var c1 = DelegateFactory.Constructor<Func<TestClass>>();
+            var c2 = DelegateFactory.Constructor<Func<int, TestClass>>();
+            var c3 = DelegateFactory.Constructor<Func<bool, TestClass>>();
+            var c4 = DelegateFactory.Constructor<Func<string, TestClass>>();
+            var c5 = DelegateFactory.Constructor<Func<int, TestClass>>();
+            var c6 = Type.Constructor(typeof(int));
+            var c7 = typeof(TestStruct).Constructor<Func<int, object>>();
+            var c8 = typeof(TestStruct).Constructor(typeof(int));
 
             var t3 = c1();
             var t4 = c2(0);

src/DelegatesFactory/DelegateFactory_Constructor.cs

@@ -16,7 +16,7 @@ public static partial class DelegateFactory
         /// <typeparam name="TDelegate">Constructor delegate type. It should have parameters of searched constructor 
         /// and return constructed type.</typeparam>
         /// <returns>Requested constructor delegate</returns>
-        public static TDelegate Contructor<TDelegate>() where TDelegate : class
+        public static TDelegate Constructor<TDelegate>() where TDelegate : class
         {
             var source = GetDelegateReturnType<TDelegate>();
             var ctrArgs = GetDelegateArguments<TDelegate>();
@@ -39,7 +39,7 @@ public static TDelegate Contructor<TDelegate>() where TDelegate : class
         /// <param name="source">Type to be constructed</param>
         /// <param name="ctrArgs">Array of types of constructor parameters</param>
         /// <returns>Constructor delegate</returns>
-        public static Func<object[], object> Contructor(this Type source, params Type[] ctrArgs)
+        public static Func<object[], object> Constructor(this Type source, params Type[] ctrArgs)
         {
             var constructorInfo = source.GetConstructorInfo(ctrArgs);
             if (constructorInfo == null)
@@ -69,7 +69,7 @@ public static Func<object[], object> Contructor(this Type source, params Type[]
         /// constructor and return constructed type.</typeparam>
         /// <param name="source">Type to be constructed</param>
         /// <returns>Constructor delegate</returns>
-        public static TDelegate Contructor<TDelegate>(this Type source)
+        public static TDelegate Constructor<TDelegate>(this Type source)
             where TDelegate : class
         {
             var ctrArgs = GetDelegateArguments<TDelegate>();
@@ -94,19 +94,19 @@ public static TDelegate Contructor<TDelegate>(this Type source)
         /// </summary>
         /// <typeparam name="TSource">Type of instance to be created by delegate.</typeparam>
         /// <returns>Default constructor delegate</returns>
-        public static Func<TSource> DefaultContructor<TSource>()
+        public static Func<TSource> DefaultConstructor<TSource>()
         {
-            return Contructor<Func<TSource>>();
+            return Constructor<Func<TSource>>();
         }
 
         /// <summary>
         /// Creates delegate for type default constructor.
         /// </summary>
         /// <param name="type">Type to be constructed</param>
         /// <returns>Default constructor delegate</returns>
-        public static Func<object> DefaultContructor(this Type type)
+        public static Func<object> DefaultConstructor(this Type type)
         {
-            return type.Contructor<Func<object>>();
+            return type.Constructor<Func<object>>();
         }
     }
 }