diff --git a/CommandLineParser.Tests/Command/MultipleCommandTests.cs b/CommandLineParser.Tests/Command/MultipleCommandTests.cs
index bc8842e..61a1782 100644
--- a/CommandLineParser.Tests/Command/MultipleCommandTests.cs
+++ b/CommandLineParser.Tests/Command/MultipleCommandTests.cs
@@ -14,12 +14,12 @@ public void NonRequiredCommandShouldNotSetResultInErrorStateWhenRequiredOptionsA
         {
             var parser = new CommandLineParser();
 
-            parser.AddCommand<MultipleCOmmandTestsOptions>()
+            parser.AddCommand<MultipleCommandTestsOptions>()
                 .Name("cmd1")
                 .Required(false)
                 .Description("cmd1");
 
-            parser.AddCommand<MultipleCOmmandTestsOptions>()
+            parser.AddCommand<MultipleCommandTestsOptions>()
                 .Name("cmd2")
                 .Required(false)
                 .Description("cmd2");
@@ -29,7 +29,7 @@ public void NonRequiredCommandShouldNotSetResultInErrorStateWhenRequiredOptionsA
             result.AssertNoErrors();
         }
 
-        private class MultipleCOmmandTestsOptions
+        private class MultipleCommandTestsOptions
         {
             [Required, Name("x", "bla"), Description("some description")]
             public int Option { get; set; }
diff --git a/CommandLineParser.Tests/Command/SubCommandTests.cs b/CommandLineParser.Tests/Command/SubCommandTests.cs
index fc9b034..8cfa571 100644
--- a/CommandLineParser.Tests/Command/SubCommandTests.cs
+++ b/CommandLineParser.Tests/Command/SubCommandTests.cs
@@ -6,6 +6,7 @@
 using System;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace MatthiWare.CommandLine.Tests.Command
@@ -42,6 +43,36 @@ public void TestSubCommandWorksCorrectlyInModel(bool autoExecute, string bla, in
             Assert.All(result.CommandResults.Select(r => r.Executed), Assert.True);
         }
 
+        [Theory]
+        [InlineData(true, "something", 15, -1)]
+        [InlineData(false, "something", 15, -1)]
+        [InlineData(true, "", 15, -1)]
+        public async Task TestSubCommandWorksCorrectlyInModelAsync(bool autoExecute, string bla, int i, int n)
+        {
+            var lock1 = new ManualResetEventSlim();
+            var lock2 = new ManualResetEventSlim();
+
+            var containerResolver = new CustomInstantiator(lock1, lock2, autoExecute, bla, i, n);
+
+            var parser = new CommandLineParser<MainModel>(containerResolver);
+
+            var result = await parser.ParseAsync(new[] { "main", "-b", bla, "sub", "-i", i.ToString(), "-n", n.ToString() });
+
+            result.AssertNoErrors();
+
+            if (!autoExecute)
+            {
+                Assert.All(result.CommandResults.Select(r => r.Executed), Assert.False);
+
+                result.ExecuteCommands();
+            }
+
+            Assert.True(lock1.Wait(1000), "MainCommand didn't execute in time.");
+            Assert.True(lock2.Wait(1000), "SubCommand didn't execute in time.");
+
+            Assert.All(result.CommandResults.Select(r => r.Executed), Assert.True);
+        }
+
         private class CustomInstantiator : DefaultContainerResolver
         {
             private readonly ManualResetEventSlim lock1;
@@ -108,6 +139,18 @@ public override void OnExecute(MainModel options, SubModel commandOptions)
 
                 locker.Set();
             }
+
+            public override Task OnExecuteAsync(MainModel options, SubModel commandOptions, CancellationToken cancellationToken)
+            {
+                base.OnExecuteAsync(options, commandOptions, cancellationToken);
+
+                Assert.Equal(bla, options.Bla);
+                Assert.Equal(i, commandOptions.Item);
+
+                locker.Set();
+
+                return Task.CompletedTask;
+            }
         }
 
         public class SubCommand : Command<MainModel, SubSubModel>
@@ -144,6 +187,18 @@ public override void OnExecute(MainModel options, SubSubModel commandOptions)
 
                 locker.Set();
             }
+
+            public override Task OnExecuteAsync(MainModel options, SubSubModel commandOptions, CancellationToken cancellationToken)
+            {
+                base.OnExecuteAsync(options, commandOptions, cancellationToken);
+
+                Assert.Equal(bla, options.Bla);
+                Assert.Equal(n, commandOptions.Nothing);
+
+                locker.Set();
+
+                return Task.CompletedTask;
+            }
         }
 
         public class MainModel
diff --git a/CommandLineParser.Tests/CommandLineParserTests.cs b/CommandLineParser.Tests/CommandLineParserTests.cs
index f91bce3..343a275 100644
--- a/CommandLineParser.Tests/CommandLineParserTests.cs
+++ b/CommandLineParser.Tests/CommandLineParserTests.cs
@@ -7,6 +7,7 @@
 using System;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace MatthiWare.CommandLine.Tests
@@ -84,6 +85,36 @@ public void CommandLineParserUsesContainerCorrectly(bool generic)
             containerMock.VerifyAll();
         }
 
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public async Task CommandLineParserUsesContainerCorrectlyAsync(bool generic)
+        {
+            var commandMock = new Mock<MyCommand>();
+            commandMock.Setup(
+                c => c.OnConfigure(It.IsAny<ICommandConfigurationBuilder<object>>()))
+                .CallBase().Verifiable("OnConfigure not called");
+
+            commandMock.Setup(c => c.OnExecuteAsync(It.IsAny<object>(), It.IsAny<object>(), It.IsAny<CancellationToken>())).Verifiable("OnExecute not called");
+
+            var containerMock = new Mock<IContainerResolver>();
+            containerMock.Setup(c => c.Resolve<MyCommand>()).Returns(commandMock.Object).Verifiable();
+
+            var parser = new CommandLineParser<object>(containerMock.Object);
+
+            if (generic)
+                parser.RegisterCommand<MyCommand, object>();
+            else
+                parser.RegisterCommand(typeof(MyCommand), typeof(object));
+
+            var result = await parser.ParseAsync(new[] { "app.exe", "my" });
+
+            result.AssertNoErrors();
+
+            commandMock.VerifyAll();
+            containerMock.VerifyAll();
+        }
+
         [Fact]
         public void CommandLinerParserPassesContainerCorreclty()
         {
@@ -150,6 +181,30 @@ public void AutoExecuteCommandsWithExceptionDoesntCrashTheParser()
             Assert.Equal(ex, result.Errors.First());
         }
 
+        [Fact]
+        public async Task AutoExecuteCommandsWithExceptionDoesntCrashTheParserAsync()
+        {
+            var parser = new CommandLineParser();
+
+            var ex = new Exception("uh-oh");
+
+            parser.AddCommand()
+                .Name("test")
+                .InvokeCommand(true)
+                .Required(true)
+                .OnExecutingAsync(async (_, __) =>
+                {
+                    await Task.Delay(1);
+                    throw ex;
+                });
+
+            var result = await parser.ParseAsync(new[] { "test" });
+
+            Assert.True(result.HasErrors);
+
+            Assert.Equal(ex, result.Errors.First());
+        }
+
         [Fact]
         public void CommandLineParserUsesArgumentFactoryCorrectly()
         {
@@ -347,6 +402,49 @@ public void ParseWithCommandTests()
             Assert.True(wait.WaitOne(2000));
         }
 
+        [Fact]
+        public async Task ParseWithCommandTestsAsync()
+        {
+            var wait = new ManualResetEvent(false);
+
+            var parser = new CommandLineParser<Options>();
+
+            parser.Configure(opt => opt.Option1)
+                .Name("o")
+                .Default("Default message")
+                .Required();
+
+            var addCmd = parser.AddCommand<AddOption>()
+                .Name("add")
+                .OnExecutingAsync(async (opt, cmdOpt, ctx) =>
+                {
+                    await Task.Delay(100);
+
+                    Assert.Equal("test", opt.Option1);
+                    Assert.Equal("my message", cmdOpt.Message);
+
+                    await Task.Delay(100);
+
+                    wait.Set();
+
+                    await Task.Delay(100);
+                });
+
+            addCmd.Configure(opt => opt.Message)
+                .Name("m", "message")
+                .Required();
+
+            var parsed = await parser.ParseAsync(new string[] { "app.exe", "-o", "test", "add", "-m=my message" });
+
+            parsed.AssertNoErrors();
+
+            Assert.Equal("test", parsed.Result.Option1);
+
+            parsed.ExecuteCommands();
+
+            Assert.True(wait.WaitOne(2000));
+        }
+
         [Theory]
         [InlineData(new[] { "app.exe", "add", "-m", "message2", "-m", "message1" }, "message1", "message2")]
         [InlineData(new[] { "app.exe", "-m", "message1", "add", "-m", "message2" }, "message1", "message2")]
@@ -383,6 +481,44 @@ public void ParseCommandTests(string[] args, string result1, string result2)
             Assert.True(wait.WaitOne(2000));
         }
 
+        [Theory]
+        [InlineData(new[] { "app.exe", "add", "-m", "message2", "-m", "message1" }, "message1", "message2")]
+        [InlineData(new[] { "app.exe", "-m", "message1", "add", "-m", "message2" }, "message1", "message2")]
+        [InlineData(new[] { "add", "-m", "message2", "-m", "message1" }, "message1", "message2")]
+        [InlineData(new[] { "-m", "message1", "add", "-m", "message2" }, "message1", "message2")]
+        public async Task ParseCommandTestsAsync(string[] args, string result1, string result2)
+        {
+            var parser = new CommandLineParser<AddOption>();
+            var wait = new ManualResetEvent(false);
+
+            parser.AddCommand<AddOption>()
+                .Name("add")
+                .Required()
+                .OnExecutingAsync(async (opt1, opt2, ctx) =>
+                {
+                    await Task.Delay(100);
+
+                    wait.Set();
+
+                    Assert.Equal(result2, opt2.Message);
+                })
+                .Configure(c => c.Message)
+                    .Name("m", "message")
+                    .Required();
+
+            parser.Configure(opt => opt.Message)
+                .Name("m", "message")
+                .Required();
+
+            var result = await parser.ParseAsync(args);
+
+            result.AssertNoErrors();
+
+            Assert.Equal(result1, result.Result.Message);
+
+            Assert.True(wait.WaitOne(2000));
+        }
+
         [Theory]
         [InlineData(new string[] { "-x", "" }, true)]
         [InlineData(new string[] { "-x" }, true)]
@@ -531,6 +667,47 @@ public void TransformationWorksAsExpectedForCommandOptions(string[] args, int ex
             Assert.Equal(expected, outcome);
         }
 
+        [Theory]
+        [InlineData(new string[] { "cmd" }, "", true)]
+        [InlineData(new string[] { "cmd", "-s", "-s2" }, "", true)]
+        [InlineData(new string[] { "cmd", "-s", "test", "-s2", "test" }, "test", false)]
+        [InlineData(new string[] { "cmd", "--string", "test", "-s2", "test" }, "test", false)]
+        public void CustomTypeWithStringTryParseGetsParsedCorrectly(string[] args, string expected, bool errors)
+        {
+            var parser = new CommandLineParser<StringTryParseTypeOptions>();
+
+            var result = parser.Parse(args);
+
+            Assert.Equal(errors, result.AssertNoErrors(!errors));
+
+            if (!result.HasErrors)
+            {
+                Assert.Equal(expected, result.Result.String.Result);
+                Assert.Equal(expected, result.Result.String2.Result);
+            }
+        }
+
+        [Theory]
+        [InlineData(new string[] { "cmd" }, "", true)]
+        [InlineData(new string[] { "cmd", "-s", "-s2", "-s3" }, "", true)]
+        [InlineData(new string[] { "cmd", "-s", "test", "-s2", "test", "-s3", "test" }, "test", false)]
+        [InlineData(new string[] { "cmd", "--string", "test", "-s2", "test", "-s3", "test" }, "test", false)]
+        public void CustomTypeWithStringConstructorGetsParsedCorrectly(string[] args, string expected, bool errors)
+        {
+            var parser = new CommandLineParser<StringTypeOptions>();
+
+            var result = parser.Parse(args);
+
+            Assert.Equal(errors, result.AssertNoErrors(!errors));
+
+            if (!result.HasErrors)
+            {
+                Assert.Equal(expected, result.Result.String.Result);
+                Assert.Equal(expected, result.Result.String2.Result);
+                Assert.Equal(expected, result.Result.String3.Result);
+            }
+        }
+
         private class ObjOption
         {
             [Name("p"), Required]
@@ -570,5 +747,126 @@ private class IntOptions
         {
             public int SomeInt { get; set; }
         }
+
+        private class StringTypeOptions
+        {
+            [Name("s", "string"), Required]
+            public StringType String { get; set; }
+
+            [Name("s2"), Required]
+            public StringType4 String2 { get; set; }
+
+            [Name("s3"), Required]
+            public StringType5 String3 { get; set; }
+        }
+
+        private class StringTryParseTypeOptions
+        {
+            [Name("s", "string"), Required]
+            public StringType2 String { get; set; }
+
+            [Name("s2"), Required]
+            public StringType3 String2 { get; set; }
+        }
+
+        private class StringType
+        {
+            public StringType(string input)
+            {
+                Result = input;
+            }
+
+            public StringType(string input, string input2)
+            {
+                Result = input;
+            }
+
+            public string Result { get; }
+        }
+
+        private class StringType2
+        {
+            private StringType2(string input)
+            {
+                Result = input;
+            }
+
+            public string Result { get; }
+
+            public static bool TryParse(string input, IFormatProvider format, out StringType2 result)
+            {
+                result = new StringType2(input);
+                return true;
+            }
+
+            public static bool TryParse() => false;
+
+            public static void Tryparse(string input, IFormatProvider format, out StringType2 result)
+            {
+                result = default;
+            }
+
+            public static bool TryParse(string input, StringType2 xd, out StringType2 stringType2)
+            {
+                stringType2 = default;
+                return false;
+            }
+        }
+
+        private class StringType3
+        {
+            private StringType3(string input)
+            {
+                Result = input;
+            }
+
+            public string Result { get; }
+
+            public static bool TryParse(string input, out StringType3 result)
+            {
+                result = new StringType3(input);
+                return true;
+            }
+        }
+
+        private class StringType4
+        {
+            private StringType4(string input)
+            {
+                Result = input;
+            }
+
+            public string Result { get; }
+
+            public static StringType4 Parse(string input)
+            {
+                return new StringType4(input);
+            }
+        }
+
+        private class StringType5
+        {
+            private StringType5(string input)
+            {
+                Result = input;
+            }
+
+            public string Result { get; }
+
+            public static StringType5 Parse(string input, IFormatProvider provider)
+            {
+                return new StringType5(input);
+            }
+
+            public static StringType4 Parse(string input)
+            {
+                return null;
+            }
+
+            public static StringType5 Parse(string input, IFormatProvider provider, IFormatProvider xd)
+            {
+                return null;
+            }
+        }
     }
 }
diff --git a/CommandLineParser.Tests/Core/TypedInstanceCacheTests.cs b/CommandLineParser.Tests/Core/TypedInstanceCacheTests.cs
new file mode 100644
index 0000000..6e12512
--- /dev/null
+++ b/CommandLineParser.Tests/Core/TypedInstanceCacheTests.cs
@@ -0,0 +1,70 @@
+using MatthiWare.CommandLine.Abstractions;
+using MatthiWare.CommandLine.Core;
+using Moq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Xunit;
+
+namespace MatthiWare.CommandLine.Tests.Core
+{
+    public class TypedInstanceCacheTests
+    {
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void AddingItemsDoesNotTriggerResolve(bool doubleAdd)
+        {
+            var containerMock = new Mock<IContainerResolver>();
+
+            var cache = new TypedInstanceCache<MyType>(containerMock.Object);
+
+            var type1 = new MyType();
+            var type2 = new MyType();
+
+            cache.Add(type1);
+
+            var result = cache.Get();
+
+            Assert.Equal(type1, result.First());
+
+            if (doubleAdd)
+            {
+                cache.Add(type2);
+
+                result = cache.Get();
+
+                Assert.Equal(type2, result.First());
+            }
+
+            Assert.True(result.Count == 1);
+
+            containerMock.Verify(c => c.Resolve(It.Is<Type>(t => t == typeof(MyType))), Times.Never());
+        }
+
+        [Fact]
+        public void AddingItemTypeDoesTriggerResolve()
+        {
+            var containerMock = new Mock<IContainerResolver>();
+
+            var cache = new TypedInstanceCache<MyType>(containerMock.Object);
+
+            var type1 = new MyType();
+
+            containerMock.Setup(c => c.Resolve(It.Is<Type>(t => t == typeof(MyType)))).Returns(type1);
+
+            cache.Add(typeof(MyType));
+
+            var result = cache.Get();
+
+            Assert.Equal(type1, result.First());
+
+            Assert.True(result.Count == 1);
+
+            containerMock.Verify(c => c.Resolve(It.Is<Type>(t => t == typeof(MyType))), Times.Once());
+        }
+
+        private class MyType { }
+    }
+}
diff --git a/CommandLineParser.Tests/Exceptions/ExceptionsTest.cs b/CommandLineParser.Tests/Exceptions/ExceptionsTest.cs
index 48bcf07..c7d4880 100644
--- a/CommandLineParser.Tests/Exceptions/ExceptionsTest.cs
+++ b/CommandLineParser.Tests/Exceptions/ExceptionsTest.cs
@@ -1,16 +1,46 @@
-using System;
+using MatthiWare.CommandLine;
+using MatthiWare.CommandLine.Abstractions.Command;
+using MatthiWare.CommandLine.Core.Attributes;
+using MatthiWare.CommandLine.Core.Exceptions;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
-using MatthiWare.CommandLine;
-using MatthiWare.CommandLine.Core.Attributes;
-using MatthiWare.CommandLine.Core.Exceptions;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace MatthiWare.CommandLine.Tests.Exceptions
 {
     public class ExceptionsTest
     {
+        [Fact]
+        public void SubCommandNotFoundTest()
+        {
+            var parser = new CommandLineParser<Options2>();
+
+            var result = parser.Parse(new string[] { "cmd" });
+
+            Assert.True(result.HasErrors);
+
+            Assert.IsType<CommandNotFoundException>(result.Errors.First());
+
+            Assert.Same(parser.Commands.First(), result.Errors.Cast<CommandNotFoundException>().First().Command);
+        }
+
+        [Fact]
+        public async Task SubCommandNotFoundTestAsync()
+        {
+            var parser = new CommandLineParser<Options2>();
+
+            var result = await parser.ParseAsync(new string[] { "cmd" });
+
+            Assert.True(result.HasErrors);
+
+            Assert.IsType<CommandNotFoundException>(result.Errors.First());
+
+            Assert.Same(parser.Commands.First(), result.Errors.Cast<CommandNotFoundException>().First().Command);
+        }
+
         [Fact]
         public void CommandNotFoundTest()
         {
@@ -28,11 +58,27 @@ public void CommandNotFoundTest()
         }
 
         [Fact]
-        public void OptionNotFoundTest()
+        public async Task CommandNotFoundTestAsync()
+        {
+            var parser = new CommandLineParser();
+
+            parser.AddCommand().Name("missing").Required();
+
+            var result = await parser.ParseAsync(new string[] { });
+
+            Assert.True(result.HasErrors);
+
+            Assert.IsType<CommandNotFoundException>(result.Errors.First());
+
+            Assert.Same(parser.Commands.First(), result.Errors.Cast<CommandNotFoundException>().First().Command);
+        }
+
+        [Fact]
+        public async Task OptionNotFoundTestAsync()
         {
             var parser = new CommandLineParser<Options>();
 
-            var result = parser.Parse(new string[] { });
+            var result = await parser.ParseAsync(new string[] { });
 
             Assert.True(result.HasErrors);
 
@@ -62,6 +108,27 @@ public void CommandParseExceptionTest()
             Assert.Same(parser.Commands.First(), result.Errors.Cast<CommandParseException>().First().Command);
         }
 
+        [Fact]
+        public async Task CommandParseExceptionTestAsync()
+        {
+            var parser = new CommandLineParser();
+
+            parser.AddCommand<Options>()
+                .Name("missing")
+                .Required()
+                .Configure(opt => opt.MissingOption)
+                .Name("o")
+                .Required();
+
+            var result = await parser.ParseAsync(new string[] { "missing", "-o", "bla" });
+
+            Assert.True(result.HasErrors);
+
+            Assert.IsType<CommandParseException>(result.Errors.First());
+
+            Assert.Same(parser.Commands.First(), result.Errors.Cast<CommandParseException>().First().Command);
+        }
+
         [Fact]
         public void OptionParseExceptionTest()
         {
@@ -76,10 +143,49 @@ public void OptionParseExceptionTest()
             Assert.Same(parser.Options.First(), result.Errors.Cast<OptionParseException>().First().Option);
         }
 
+        [Fact]
+        public async Task OptionParseExceptionTestAsync()
+        {
+            var parser = new CommandLineParser<Options>();
+
+            var result = await parser.ParseAsync(new string[] { "-m", "bla" });
+
+            Assert.True(result.HasErrors);
+
+            Assert.IsType<OptionParseException>(result.Errors.First());
+
+            Assert.Same(parser.Options.First(), result.Errors.Cast<OptionParseException>().First().Option);
+        }
+
         private class Options
         {
             [Required, Name("m", "missing")]
             public int MissingOption { get; set; }
         }
+
+        private class Options2
+        {
+            public SubCmd SubCmd { get; set; }
+        }
+
+        private class Cmd : Command<Options2>
+        {
+            public override void OnConfigure(ICommandConfigurationBuilder builder)
+            {
+                base.OnConfigure(builder);
+
+                builder.Name("cmd").Required();
+            }
+        }
+
+        private class SubCmd : Command<Options2>
+        {
+            public override void OnConfigure(ICommandConfigurationBuilder builder)
+            {
+                base.OnConfigure(builder);
+
+                builder.Name("sub").Required();
+            }
+        }
     }
 }
diff --git a/CommandLineParser.Tests/OptionBuilderTest.cs b/CommandLineParser.Tests/OptionBuilderTest.cs
index d1a7c88..12b6ee2 100644
--- a/CommandLineParser.Tests/OptionBuilderTest.cs
+++ b/CommandLineParser.Tests/OptionBuilderTest.cs
@@ -1,11 +1,9 @@
-using System;
-using MatthiWare.CommandLine;
+using MatthiWare.CommandLine;
 using MatthiWare.CommandLine.Abstractions;
 using MatthiWare.CommandLine.Abstractions.Parsing;
 using MatthiWare.CommandLine.Core;
-
 using Moq;
-
+using System;
 using Xunit;
 
 namespace MatthiWare.CommandLine.Tests
diff --git a/CommandLineParser.Tests/Parsing/ResolverFactoryTest.cs b/CommandLineParser.Tests/Parsing/ResolverFactoryTest.cs
index 5a0cde4..f638538 100644
--- a/CommandLineParser.Tests/Parsing/ResolverFactoryTest.cs
+++ b/CommandLineParser.Tests/Parsing/ResolverFactoryTest.cs
@@ -1,13 +1,10 @@
-using System;
-
-using MatthiWare.CommandLine.Abstractions.Models;
+using MatthiWare.CommandLine.Abstractions.Models;
 using MatthiWare.CommandLine.Abstractions.Parsing;
 using MatthiWare.CommandLine.Core;
 using MatthiWare.CommandLine.Core.Parsing;
 using MatthiWare.CommandLine.Core.Parsing.Resolvers;
-
 using Moq;
-
+using System;
 using Xunit;
 
 namespace MatthiWare.CommandLine.Tests.Parsing
@@ -84,6 +81,7 @@ public void RegisterOverrideWorks()
 
             factory.Register(typeof(string), mockResolver.Object.GetType(), true);
             factory.Register<string, StringResolver>(true);
+            factory.Register<string, StringResolver>(true);
         }
 
         [Fact]
@@ -96,6 +94,14 @@ public void RegisterThrowsException()
             Assert.Throws<ArgumentException>(() => factory.Register<string, StringResolver>());
         }
 
+        [Fact]
+        public void NonAssignableTypeThrowsException()
+        {
+            var factory = new DefaultArgumentResolverFactory(new DefaultContainerResolver());
+
+            Assert.Throws<InvalidCastException>(() => factory.Register(typeof(string), typeof(Mock), true));
+        }
+
         [Fact]
         public void RegisterObjectResolver()
         {
diff --git a/CommandLineParser.Tests/Parsing/Resolvers/DefaultResolverTests.cs b/CommandLineParser.Tests/Parsing/Resolvers/DefaultResolverTests.cs
new file mode 100644
index 0000000..934dde5
--- /dev/null
+++ b/CommandLineParser.Tests/Parsing/Resolvers/DefaultResolverTests.cs
@@ -0,0 +1,59 @@
+using MatthiWare.CommandLine.Abstractions.Models;
+using MatthiWare.CommandLine.Core.Parsing.Resolvers;
+using Xunit;
+
+namespace MatthiWare.CommandLine.Tests.Parsing.Resolvers
+{
+    public class DefaultResolverTests
+    {
+        [Theory]
+        [InlineData(true, "-m", "test")]
+        [InlineData(true, "-m", "my string")]
+        public void TestCanResolve(bool expected, string key, string value)
+        {
+            var resolver = new DefaultResolver<MyTestType>();
+            var model = new ArgumentModel(key, value);
+
+            Assert.Equal(expected, resolver.CanResolve(model));
+        }
+
+        [Theory]
+        [InlineData(false, "-m", "test")]
+        [InlineData(false, "-m", "my string")]
+        public void TestCanResolveWithWrongCtor(bool expected, string key, string value)
+        {
+            var resolver = new DefaultResolver<MyTestType2>();
+            var model = new ArgumentModel(key, value);
+
+            Assert.Equal(expected, resolver.CanResolve(model));
+        }
+
+        [Theory]
+        [InlineData("test", "-m", "test")]
+        [InlineData("my string", "-m", "my string")]
+        public void TestResolve(string expected, string key, string value)
+        {
+            var resolver = new DefaultResolver<MyTestType>();
+            var model = new ArgumentModel(key, value);
+
+            Assert.Equal(expected, resolver.Resolve(model).Result);
+        }
+
+        public class MyTestType
+        {
+            public MyTestType(string ctor)
+            {
+                Result = ctor;
+            }
+
+            public string Result { get; }
+        }
+
+        public class MyTestType2
+        {
+            public MyTestType2(int someInt)
+            {
+            }
+        }
+    }
+}
diff --git a/CommandLineParser.Tests/Parsing/Resolvers/EnumResolverTests.cs b/CommandLineParser.Tests/Parsing/Resolvers/EnumResolverTests.cs
index d3adba8..25d93b8 100644
--- a/CommandLineParser.Tests/Parsing/Resolvers/EnumResolverTests.cs
+++ b/CommandLineParser.Tests/Parsing/Resolvers/EnumResolverTests.cs
@@ -21,7 +21,9 @@ public void TestCanResolve(bool expected, string key, string value)
 
         [Theory]
         [InlineData(TestEnum.Error, "-m", "Error")]
+        [InlineData(TestEnum.Error, "-m", "error")]
         [InlineData(TestEnum.Verbose, "-m", "Verbose")]
+        [InlineData(TestEnum.Verbose, "-m", "verbose")]
         public void TestResolve(TestEnum expected, string key, string value)
         {
             var resolver = new EnumResolver<TestEnum>();
diff --git a/CommandLineParser.Tests/Parsing/Validation/ValidationAbstractionTests.cs b/CommandLineParser.Tests/Parsing/Validation/ValidationAbstractionTests.cs
new file mode 100644
index 0000000..a5c81af
--- /dev/null
+++ b/CommandLineParser.Tests/Parsing/Validation/ValidationAbstractionTests.cs
@@ -0,0 +1,109 @@
+using MatthiWare.CommandLine.Abstractions.Command;
+using MatthiWare.CommandLine.Abstractions.Validations;
+using MatthiWare.CommandLine.Core.Attributes;
+using Moq;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace MatthiWare.CommandLine.Tests.Parsing.Validation
+{
+    public class ValidationAbstractionTests
+    {
+        [Fact]
+        public void ParsingCallsValidation()
+        {
+            var parser = new CommandLineParser<OptionWithCommand>();
+
+            var validValidationResultMock = new Mock<IValidationResult>();
+            validValidationResultMock.SetupGet(v => v.IsValid).Returns(true);
+
+            var optionWithCommandMockValidator = new Mock<IValidator<OptionWithCommand>>();
+            optionWithCommandMockValidator
+                .Setup(v => v.Validate(It.IsAny<object>()))
+                .Returns(validValidationResultMock.Object)
+                .Verifiable();
+
+            var optionMockValidator = new Mock<IValidator<Option>>();
+            optionMockValidator
+                .Setup(v => v.Validate(It.IsAny<object>()))
+                .Returns(validValidationResultMock.Object)
+                .Verifiable();
+
+            parser.Validators.AddValidator(optionWithCommandMockValidator.Object);
+            parser.Validators.AddValidator(optionMockValidator.Object);
+
+            var result = parser.Parse(new[] { "-x", "true", "cmd", "-y", "true" });
+
+            result.AssertNoErrors();
+
+            optionMockValidator.Verify();
+            optionWithCommandMockValidator.Verify();
+        }
+
+        [Fact]
+        public async Task ParsingCallsValidationAsync()
+        {
+            var parser = new CommandLineParser<OptionWithCommand>();
+
+            var validValidationResultMock = new Mock<IValidationResult>();
+            validValidationResultMock.SetupGet(v => v.IsValid).Returns(true);
+
+            var optionWithCommandMockValidator = new Mock<IValidator<OptionWithCommand>>();
+            optionWithCommandMockValidator
+                .Setup(v => v.ValidateAsync(It.IsAny<OptionWithCommand>(), It.IsAny<CancellationToken>()))
+                .Returns(Task.FromResult(validValidationResultMock.Object))
+                .Verifiable();
+
+            var optionMockValidator = new Mock<IValidator<Option>>();
+            optionMockValidator
+                .Setup(v => v.ValidateAsync(It.IsAny<Option>(), It.IsAny<CancellationToken>()))
+                .Returns(Task.FromResult(validValidationResultMock.Object))
+                .Verifiable();
+
+            parser.Validators.AddValidator(optionWithCommandMockValidator.Object);
+            parser.Validators.AddValidator(optionMockValidator.Object);
+
+            var result = await parser.ParseAsync(new[] { "-x", "true", "cmd", "-y", "true" });
+
+            result.AssertNoErrors();
+
+            optionMockValidator.Verify();
+            optionWithCommandMockValidator.Verify();
+        }
+
+        public class OptionWithCommand
+        {
+            [Name("x")]
+            public bool Prop { get; set; }
+
+            public Cmd Cmd { get; set; }
+        }
+
+        public class Option
+        {
+            [Name("y")]
+            public bool Prop { get; set; }
+        }
+
+        public class Cmd : Command<OptionWithCommand, Option>
+        {
+            public override void OnConfigure(ICommandConfigurationBuilder<Option> builder)
+            {
+                base.OnConfigure(builder);
+
+                builder.Name("cmd");
+            }
+
+            public override void OnConfigure(ICommandConfigurationBuilder builder)
+            {
+                base.OnConfigure(builder);
+
+                builder.Name("cmd");
+            }
+        }
+    }
+}
diff --git a/CommandLineParser.Tests/Usage/HelpDisplayCommandTests.cs b/CommandLineParser.Tests/Usage/HelpDisplayCommandTests.cs
index dd557c8..d30d298 100644
--- a/CommandLineParser.Tests/Usage/HelpDisplayCommandTests.cs
+++ b/CommandLineParser.Tests/Usage/HelpDisplayCommandTests.cs
@@ -3,6 +3,7 @@
 using MatthiWare.CommandLine.Abstractions.Usage;
 using MatthiWare.CommandLine.Core.Attributes;
 using Moq;
+using System.Threading.Tasks;
 using Xunit;
 
 namespace MatthiWare.CommandLine.Tests.Usage
@@ -43,6 +44,40 @@ public void TestHelpDisplayFiresCorrectly(string[] args, bool fires)
             Assert.Equal<bool>(fires, calledFlag);
         }
 
+        [Theory]
+        [InlineData(new string[] { "db", "--help" }, true)]
+        [InlineData(new string[] { "db" }, true)]
+        [InlineData(new string[] { "db", "-o", "--help" }, true)]
+        [InlineData(new string[] { "db", "-o", "help" }, false)]
+        [InlineData(new string[] { "-x", "blabla", "--help" }, true)]
+        [InlineData(new string[] { }, true)]
+        [InlineData(new string[] { "-x", "--help" }, true)]
+        [InlineData(new string[] { "--help" }, true)]
+        public async Task TestHelpDisplayFiresCorrectlyAsync(string[] args, bool fires)
+        {
+            bool calledFlag = false;
+
+            var usagePrinterMock = new Mock<IUsagePrinter>();
+
+            usagePrinterMock.Setup(mock => mock.PrintUsage()).Callback(() => calledFlag = true);
+            usagePrinterMock.Setup(mock => mock.PrintUsage(It.IsAny<IArgument>())).Callback(() => calledFlag = true);
+            usagePrinterMock.Setup(mock => mock.PrintUsage(It.IsAny<ICommandLineCommand>())).Callback(() => calledFlag = true);
+            usagePrinterMock.Setup(mock => mock.PrintUsage(It.IsAny<ICommandLineOption>())).Callback(() => calledFlag = true);
+
+            var parser = new CommandLineParser<Options>
+            {
+                Printer = usagePrinterMock.Object
+            };
+
+            var cmd = parser.AddCommand<CommandOptions>()
+                .Name("db")
+                .Description("Database commands");
+
+            await parser.ParseAsync(args);
+
+            Assert.Equal<bool>(fires, calledFlag);
+        }
+
         public class Options
         {
             [Name("x"), Description("Some description")]
diff --git a/CommandLineParser/Abstractions/Command/Command.cs b/CommandLineParser/Abstractions/Command/Command.cs
index c5ce2b8..7124b37 100644
--- a/CommandLineParser/Abstractions/Command/Command.cs
+++ b/CommandLineParser/Abstractions/Command/Command.cs
@@ -1,4 +1,7 @@
-namespace MatthiWare.CommandLine.Abstractions.Command
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MatthiWare.CommandLine.Abstractions.Command
 {
     /// <summary>
     /// Defines a command
@@ -15,7 +18,11 @@ public virtual void OnConfigure(ICommandConfigurationBuilder builder) { }
         /// <summary>
         /// Executes the command
         /// </summary>
-        /// <param name="options">Parsed options</param>
         public virtual void OnExecute() { }
+
+        /// <summary>
+        /// Executes the command async
+        /// </summary>
+        public virtual Task OnExecuteAsync(CancellationToken cancellationToken) => Task.CompletedTask;
     }
 }
diff --git a/CommandLineParser/Abstractions/Command/Command`TOptions.cs b/CommandLineParser/Abstractions/Command/Command`TOptions.cs
index 942d36f..3e28a54 100644
--- a/CommandLineParser/Abstractions/Command/Command`TOptions.cs
+++ b/CommandLineParser/Abstractions/Command/Command`TOptions.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace MatthiWare.CommandLine.Abstractions.Command
 {
@@ -20,5 +22,14 @@ public virtual void OnExecute(TOptions options)
         {
             OnExecute();
         }
+
+        /// <summary>
+        /// Executes the command
+        /// </summary>
+        /// <param name="options">Parsed options</param>
+        public virtual Task OnExecuteAsync(TOptions options, CancellationToken cancellationToken)
+        {
+            return OnExecuteAsync(cancellationToken);
+        }
     }
 }
diff --git a/CommandLineParser/Abstractions/Command/Command`TOptions`TCmdOptions.cs b/CommandLineParser/Abstractions/Command/Command`TOptions`TCmdOptions.cs
index 81df1fb..022edeb 100644
--- a/CommandLineParser/Abstractions/Command/Command`TOptions`TCmdOptions.cs
+++ b/CommandLineParser/Abstractions/Command/Command`TOptions`TCmdOptions.cs
@@ -1,4 +1,7 @@
-namespace MatthiWare.CommandLine.Abstractions.Command
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MatthiWare.CommandLine.Abstractions.Command
 {
     /// <summary>
     /// Defines a command
@@ -17,8 +20,7 @@ public abstract class Command<TOptions, TCommandOptions> :
         /// <param name="builder"></param>
         public virtual void OnConfigure(ICommandConfigurationBuilder<TCommandOptions> builder)
         {
-            base.OnConfigure(builder);
-            // OnConfigure((ICommandConfigurationBuilder)builder);
+            OnConfigure((ICommandConfigurationBuilder)builder);
         }
 
         /// <summary>
@@ -30,5 +32,15 @@ public virtual void OnExecute(TOptions options, TCommandOptions commandOptions)
         {
             OnExecute(options);
         }
+
+        /// <summary>
+        /// Executes the command
+        /// </summary>
+        /// <param name="options"></param>
+        /// <param name="commandOptions"></param>
+        public virtual Task OnExecuteAsync(TOptions options, TCommandOptions commandOptions, CancellationToken cancellationToken)
+        {
+            return OnExecuteAsync(options, cancellationToken);
+        }
     }
 }
diff --git a/CommandLineParser/Abstractions/Command/ICommandBuilder.cs b/CommandLineParser/Abstractions/Command/ICommandBuilder.cs
index 900fa54..11fd136 100644
--- a/CommandLineParser/Abstractions/Command/ICommandBuilder.cs
+++ b/CommandLineParser/Abstractions/Command/ICommandBuilder.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace MatthiWare.CommandLine.Abstractions.Command
 {
@@ -41,8 +43,14 @@ public interface ICommandBuilder<TOption>
         /// Configures the execution of the command
         /// </summary>
         /// <param name="action">The execution action</param>
-        /// <param name="required">True or false</param>
         /// <returns><see cref="ICommandBuilder{TOption}"/></returns>
         ICommandBuilder<TOption> OnExecuting(Action<TOption> action);
+
+        /// <summary>
+        /// Configures the execution of the command async
+        /// </summary>
+        /// <param name="action">The execution action</param>
+        /// <returns><see cref="ICommandBuilder{TOption}"/></returns>
+        ICommandBuilder<TOption> OnExecutingAsync(Func<TOption, CancellationToken, Task> action);
     }
 }
diff --git a/CommandLineParser/Abstractions/Command/ICommandExecutor.cs b/CommandLineParser/Abstractions/Command/ICommandExecutor.cs
index d9becdb..81eaee2 100644
--- a/CommandLineParser/Abstractions/Command/ICommandExecutor.cs
+++ b/CommandLineParser/Abstractions/Command/ICommandExecutor.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace MatthiWare.CommandLine.Abstractions.Command
 {
@@ -39,5 +41,27 @@ public interface ICommandExecutor<TOption, TSource>
         /// <param name="action">Action to execute</param>
         /// <returns><see cref="ICommandBuilder{TOption,TSource}"/></returns>
         ICommandBuilder<TOption, TSource> OnExecuting(Action<TOption, TSource> action);
+
+
+        /// <summary>
+        /// Sets the async command execute action 
+        /// </summary>
+        /// <param name="action">Action to execute</param>
+        /// <returns>A task of <see cref="ICommandBuilder{TOption,TSource}"/></returns>
+        ICommandBuilder<TOption, TSource> OnExecutingAsync(Func<CancellationToken, Task> action);
+
+        /// <summary>
+        /// Sets the async command execute action
+        /// </summary>
+        /// <param name="action">Action to execute</param>
+        /// <returns>A task of <see cref="ICommandBuilder{TOption,TSource}"/></returns>
+        ICommandBuilder<TOption, TSource> OnExecutingAsync(Func<TOption, CancellationToken, Task> action);
+
+        /// <summary>
+        /// Sets the async command execute action
+        /// </summary>
+        /// <param name="action">Action to execute</param>
+        /// <returns>A task of <see cref="ICommandBuilder{TOption,TSource}"/></returns>
+        ICommandBuilder<TOption, TSource> OnExecutingAsync(Func<TOption, TSource, CancellationToken, Task> action);
     }
 }
diff --git a/CommandLineParser/Abstractions/ICommandLineParser'.cs b/CommandLineParser/Abstractions/ICommandLineParser'.cs
index 8e5d275..578134f 100644
--- a/CommandLineParser/Abstractions/ICommandLineParser'.cs
+++ b/CommandLineParser/Abstractions/ICommandLineParser'.cs
@@ -4,6 +4,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq.Expressions;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace MatthiWare.CommandLine.Abstractions
 {
@@ -37,12 +39,20 @@ public interface ICommandLineParser<TOption>
         #region Parsing
 
         /// <summary>
-        /// Parses the current command and returns the result
+        /// Parses the arguments
         /// </summary>
-        /// <param name="args">command arguments</param>
+        /// <param name="args">CLI Arguments</param>
         /// <returns>The <see cref="IParserResult{TOption}"/> result</returns>
         IParserResult<TOption> Parse(string[] args);
 
+        /// <summary>
+        /// Parses the arguments async
+        /// </summary>
+        /// <param name="args">CLI Arguments</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>The task that resolves to the result. <see cref="IParserResult{TOption}"/></returns>
+        Task<IParserResult<TOption>> ParseAsync(string[] args, CancellationToken cancellationToken);
+
         #endregion
 
         #region Configuration
diff --git a/CommandLineParser/Abstractions/Parsing/Command/ICommandParserResult.cs b/CommandLineParser/Abstractions/Parsing/Command/ICommandParserResult.cs
index 1ee6382..57a9300 100644
--- a/CommandLineParser/Abstractions/Parsing/Command/ICommandParserResult.cs
+++ b/CommandLineParser/Abstractions/Parsing/Command/ICommandParserResult.cs
@@ -2,6 +2,8 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace MatthiWare.CommandLine.Abstractions.Parsing.Command
 {
@@ -57,5 +59,14 @@ public interface ICommandParserResult
         /// Result contains exceptions. For more info see <see cref="HasErrors"/> and <see cref="Errors"/> properties.
         /// </exception>
         void ExecuteCommand();
+
+        /// <summary>
+        /// Executes the command async
+        /// </summary>
+        /// <exception cref="InvalidOperationException">
+        /// Result contains exceptions. For more info see <see cref="HasErrors"/> and <see cref="Errors"/> properties.
+        /// </exception>
+        /// <returns>A task</returns>
+        Task ExecuteCommandAsync(CancellationToken cancellationToken);
     }
 }
diff --git a/CommandLineParser/Abstractions/Validations/IValidator.cs b/CommandLineParser/Abstractions/Validations/IValidator.cs
index fb57729..96e620e 100644
--- a/CommandLineParser/Abstractions/Validations/IValidator.cs
+++ b/CommandLineParser/Abstractions/Validations/IValidator.cs
@@ -1,11 +1,12 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace MatthiWare.CommandLine.Abstractions.Validations
 {
     public interface IValidator
     {
         IValidationResult Validate(object @object);
+
+        Task<IValidationResult> ValidateAsync(object @object, CancellationToken cancellationToken);
     }
 }
diff --git a/CommandLineParser/CommandLineParser.xml b/CommandLineParser/CommandLineParser.xml
index 4792cb5..44f9b77 100644
--- a/CommandLineParser/CommandLineParser.xml
+++ b/CommandLineParser/CommandLineParser.xml
@@ -20,7 +20,11 @@
             <summary>
             Executes the command
             </summary>
-            <param name="options">Parsed options</param>
+        </member>
+        <member name="M:MatthiWare.CommandLine.Abstractions.Command.Command.OnExecuteAsync(System.Threading.CancellationToken)">
+            <summary>
+            Executes the command async
+            </summary>
         </member>
         <member name="T:MatthiWare.CommandLine.Abstractions.Command.Command`1">
             <summary>
@@ -34,6 +38,12 @@
             </summary>
             <param name="options">Parsed options</param>
         </member>
+        <member name="M:MatthiWare.CommandLine.Abstractions.Command.Command`1.OnExecuteAsync(`0,System.Threading.CancellationToken)">
+            <summary>
+            Executes the command
+            </summary>
+            <param name="options">Parsed options</param>
+        </member>
         <member name="T:MatthiWare.CommandLine.Abstractions.Command.Command`2">
             <summary>
             Defines a command
@@ -55,6 +65,13 @@
             <param name="options"></param>
             <param name="commandOptions"></param>
         </member>
+        <member name="M:MatthiWare.CommandLine.Abstractions.Command.Command`2.OnExecuteAsync(`0,`1,System.Threading.CancellationToken)">
+            <summary>
+            Executes the command
+            </summary>
+            <param name="options"></param>
+            <param name="commandOptions"></param>
+        </member>
         <member name="T:MatthiWare.CommandLine.Abstractions.Command.ICommandBuilder`2">
             <summary>
             Configures commands using a fluent interface
@@ -131,7 +148,13 @@
             Configures the execution of the command
             </summary>
             <param name="action">The execution action</param>
-            <param name="required">True or false</param>
+            <returns><see cref="T:MatthiWare.CommandLine.Abstractions.Command.ICommandBuilder`1"/></returns>
+        </member>
+        <member name="M:MatthiWare.CommandLine.Abstractions.Command.ICommandBuilder`1.OnExecutingAsync(System.Func{`0,System.Threading.CancellationToken,System.Threading.Tasks.Task})">
+            <summary>
+            Configures the execution of the command async
+            </summary>
+            <param name="action">The execution action</param>
             <returns><see cref="T:MatthiWare.CommandLine.Abstractions.Command.ICommandBuilder`1"/></returns>
         </member>
         <member name="T:MatthiWare.CommandLine.Abstractions.Command.ICommandConfigurationBuilder">
@@ -245,6 +268,27 @@
             <param name="action">Action to execute</param>
             <returns><see cref="T:MatthiWare.CommandLine.Abstractions.Command.ICommandBuilder`2"/></returns>
         </member>
+        <member name="M:MatthiWare.CommandLine.Abstractions.Command.ICommandExecutor`2.OnExecutingAsync(System.Func{System.Threading.CancellationToken,System.Threading.Tasks.Task})">
+            <summary>
+            Sets the async command execute action 
+            </summary>
+            <param name="action">Action to execute</param>
+            <returns>A task of <see cref="T:MatthiWare.CommandLine.Abstractions.Command.ICommandBuilder`2"/></returns>
+        </member>
+        <member name="M:MatthiWare.CommandLine.Abstractions.Command.ICommandExecutor`2.OnExecutingAsync(System.Func{`0,System.Threading.CancellationToken,System.Threading.Tasks.Task})">
+            <summary>
+            Sets the async command execute action
+            </summary>
+            <param name="action">Action to execute</param>
+            <returns>A task of <see cref="T:MatthiWare.CommandLine.Abstractions.Command.ICommandBuilder`2"/></returns>
+        </member>
+        <member name="M:MatthiWare.CommandLine.Abstractions.Command.ICommandExecutor`2.OnExecutingAsync(System.Func{`0,`1,System.Threading.CancellationToken,System.Threading.Tasks.Task})">
+            <summary>
+            Sets the async command execute action
+            </summary>
+            <param name="action">Action to execute</param>
+            <returns>A task of <see cref="T:MatthiWare.CommandLine.Abstractions.Command.ICommandBuilder`2"/></returns>
+        </member>
         <member name="T:MatthiWare.CommandLine.Abstractions.Command.ICommandLineCommand">
             <summary>
             Command configuration options
@@ -369,11 +413,19 @@
         </member>
         <member name="M:MatthiWare.CommandLine.Abstractions.ICommandLineParser`1.Parse(System.String[])">
             <summary>
-            Parses the current command and returns the result
+            Parses the arguments
             </summary>
-            <param name="args">command arguments</param>
+            <param name="args">CLI Arguments</param>
             <returns>The <see cref="T:MatthiWare.CommandLine.Abstractions.Parsing.IParserResult`1"/> result</returns>
         </member>
+        <member name="M:MatthiWare.CommandLine.Abstractions.ICommandLineParser`1.ParseAsync(System.String[],System.Threading.CancellationToken)">
+            <summary>
+            Parses the arguments async
+            </summary>
+            <param name="args">CLI Arguments</param>
+            <param name="cancellationToken"></param>
+            <returns>The task that resolves to the result. <see cref="T:MatthiWare.CommandLine.Abstractions.Parsing.IParserResult`1"/></returns>
+        </member>
         <member name="M:MatthiWare.CommandLine.Abstractions.ICommandLineParser`1.Configure``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})">
             <summary>
             Configures a new or existing option
@@ -625,6 +677,15 @@
             Result contains exceptions. For more info see <see cref="P:MatthiWare.CommandLine.Abstractions.Parsing.Command.ICommandParserResult.HasErrors"/> and <see cref="P:MatthiWare.CommandLine.Abstractions.Parsing.Command.ICommandParserResult.Errors"/> properties.
             </exception>
         </member>
+        <member name="M:MatthiWare.CommandLine.Abstractions.Parsing.Command.ICommandParserResult.ExecuteCommandAsync(System.Threading.CancellationToken)">
+            <summary>
+            Executes the command async
+            </summary>
+            <exception cref="T:System.InvalidOperationException">
+            Result contains exceptions. For more info see <see cref="P:MatthiWare.CommandLine.Abstractions.Parsing.Command.ICommandParserResult.HasErrors"/> and <see cref="P:MatthiWare.CommandLine.Abstractions.Parsing.Command.ICommandParserResult.Errors"/> properties.
+            </exception>
+            <returns>A task</returns>
+        </member>
         <member name="T:MatthiWare.CommandLine.Abstractions.Parsing.IArgumentManager">
             <summary>
             Managers the arguments
@@ -1001,6 +1062,14 @@
             <param name="args">arguments from the commandline</param>
             <returns>The result of the parsing, <see cref="T:MatthiWare.CommandLine.Abstractions.Parsing.IParserResult`1"/></returns>
         </member>
+        <member name="M:MatthiWare.CommandLine.CommandLineParser`1.ParseAsync(System.String[],System.Threading.CancellationToken)">
+            <summary>
+            Parses the commandline arguments async
+            </summary>
+            <param name="args">arguments from the commandline</param>
+            <param name="cancellationToken"></param>
+            <returns>The result of the parsing, <see cref="T:MatthiWare.CommandLine.Abstractions.Parsing.IParserResult`1"/></returns>
+        </member>
         <member name="M:MatthiWare.CommandLine.CommandLineParser`1.AddCommand``1">
             <summary>
             Adds a command to the parser
@@ -1234,6 +1303,44 @@
             <param name="startOffset">Search offset</param>
             <returns></returns>
         </member>
+        <member name="M:MatthiWare.CommandLine.Core.Parsing.Resolvers.DefaultResolver`1.FindTryParse(System.Reflection.MethodInfo)">
+            <summary>
+            Finds the Type.TryParse(String, IFormatProvider, out T result) method
+            </summary>
+            <param name="method"></param>
+            <returns>True or false</returns>
+        </member>
+        <member name="M:MatthiWare.CommandLine.Core.Parsing.Resolvers.DefaultResolver`1.FindParse(System.Reflection.MethodInfo)">
+            <summary>
+            Finds the Type.TryParse(String, IFormatProvider, out T result) method
+            </summary>
+            <param name="method"></param>
+            <returns>True or false</returns>
+        </member>
+        <member name="T:MatthiWare.CommandLine.Core.TypedInstanceCache`1">
+            <summary>
+            A strongly-typed instance cache
+            </summary>
+            <typeparam name="TValue"></typeparam>
+        </member>
+        <member name="M:MatthiWare.CommandLine.Core.TypedInstanceCache`1.Add(`0)">
+            <summary>
+            Adds a new instance to the cache
+            </summary>
+            <param name="value"></param>
+        </member>
+        <member name="M:MatthiWare.CommandLine.Core.TypedInstanceCache`1.Add(System.Type)">
+            <summary>
+            Adds a type to the cache that will be resolved later
+            </summary>
+            <param name="type"></param>
+        </member>
+        <member name="M:MatthiWare.CommandLine.Core.TypedInstanceCache`1.Get">
+            <summary>
+            Gets the values from the cache. This will instantiate unresolved items. 
+            </summary>
+            <returns></returns>
+        </member>
         <member name="M:MatthiWare.CommandLine.Core.Utils.ExtensionMethods.IsAssignableToGenericType(System.Type,System.Type)">
             <summary>
             Checks if an open generic type is assignable to the generic type
diff --git a/CommandLineParser/CommandLineParser`TOption.cs b/CommandLineParser/CommandLineParser`TOption.cs
index 81417fb..2733ab9 100644
--- a/CommandLineParser/CommandLineParser`TOption.cs
+++ b/CommandLineParser/CommandLineParser`TOption.cs
@@ -21,6 +21,8 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
 
 [assembly: InternalsVisibleTo("CommandLineParser.Tests")]
 
@@ -224,6 +226,37 @@ public IParserResult<TOption> Parse(string[] args)
             return result;
         }
 
+        /// <summary>
+        /// Parses the commandline arguments async
+        /// </summary>
+        /// <param name="args">arguments from the commandline</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>The result of the parsing, <see cref="IParserResult{TResult}"/></returns>
+        public async Task<IParserResult<TOption>> ParseAsync(string[] args, CancellationToken cancellationToken = default)
+        {
+            var errors = new List<Exception>();
+
+            var result = new ParseResult<TOption>();
+
+            var argumentManager = new ArgumentManager(args, ParserOptions, m_helpOptionName, m_helpOptionNameLong, m_commands, m_options.Values.Cast<ICommandLineOption>().ToArray());
+
+            await ParseCommandsAsync(errors, result, argumentManager, cancellationToken);
+
+            ParseOptions(errors, result, argumentManager);
+
+            CheckForExtraHelpArguments(result, argumentManager);
+
+            await ValidateAsync(m_option, errors, cancellationToken);
+
+            result.MergeResult(errors);
+
+            await AutoExecuteCommandsAsync(result, cancellationToken);
+
+            AutoPrintUsageAndErrors(result, args.Length == 0);
+
+            return result;
+        }
+
         private void Validate<T>(T @object, List<Exception> errors)
         {
             if (!Validators.HasValidatorFor<T>())
@@ -231,7 +264,24 @@ private void Validate<T>(T @object, List<Exception> errors)
 
             var results = Validators.GetValidators<T>().Select(validator => validator.Validate(@object)).ToArray();
 
-            foreach(var result in results)
+            foreach (var result in results)
+            {
+                if (result.IsValid)
+                    continue;
+
+                errors.Add(result.Error);
+            }
+        }
+
+        private async Task ValidateAsync<T>(T @object, List<Exception> errors, CancellationToken token)
+        {
+            if (!Validators.HasValidatorFor<T>())
+                return;
+
+            var results = (await Task.WhenAll(Validators.GetValidators<T>()
+                .Select(async validator => await validator.ValidateAsync(@object, token)))).ToArray();
+
+            foreach (var result in results)
             {
                 if (result.IsValid)
                     continue;
@@ -289,6 +339,13 @@ private void AutoExecuteCommands(ParseResult<TOption> result)
             ExecuteCommandParserResults(result, result.CommandResults.Where(sub => sub.Command.AutoExecute));
         }
 
+        private async Task AutoExecuteCommandsAsync(ParseResult<TOption> result, CancellationToken cancellationToken)
+        {
+            if (result.HasErrors) return;
+
+            await ExecuteCommandParserResultsAsync(result, result.CommandResults.Where(sub => sub.Command.AutoExecute), cancellationToken);
+        }
+
         private bool HelpRequested(ParseResult<TOption> result, CommandLineOptionBase option, ArgumentModel model)
         {
             if (!ParserOptions.EnableHelpOption) return false;
@@ -328,6 +385,29 @@ private void ExecuteCommandParserResults(ParseResult<TOption> results, IEnumerab
                 ExecuteCommandParserResults(results, cmd.SubCommands.Where(sub => sub.Command.AutoExecute));
         }
 
+        private async Task ExecuteCommandParserResultsAsync(ParseResult<TOption> results, IEnumerable<ICommandParserResult> cmds, CancellationToken cancellationToken)
+        {
+            var errors = new List<Exception>();
+
+            foreach (var cmd in cmds)
+            {
+                try
+                {
+                    await cmd.ExecuteCommandAsync(cancellationToken);
+                }
+                catch (Exception ex)
+                {
+                    errors.Add(ex);
+                }
+            }
+
+            if (errors.Any())
+                results.MergeResult(errors);
+
+            foreach (var cmd in cmds)
+                await ExecuteCommandParserResultsAsync(results, cmd.SubCommands.Where(sub => sub.Command.AutoExecute), cancellationToken);
+        }
+
         private void ParseCommands(IList<Exception> errors, ParseResult<TOption> result, IArgumentManager argumentManager)
         {
             foreach (var cmd in m_commands)
@@ -366,6 +446,44 @@ private void ParseCommand(CommandLineCommandBase cmd, ParseResult<TOption> resul
                 throw new CommandParseException(cmd, cmdParseResult.Errors);
         }
 
+        private async Task ParseCommandsAsync(IList<Exception> errors, ParseResult<TOption> result, IArgumentManager argumentManager, CancellationToken cancellationToken)
+        {
+            foreach (var cmd in m_commands)
+            {
+                try
+                {
+                    await ParseCommandAsync(cmd, result, argumentManager, cancellationToken);
+
+                    if (result.HelpRequested)
+                        break;
+                }
+                catch (Exception ex)
+                {
+                    errors.Add(ex);
+                }
+            }
+        }
+
+        private async Task ParseCommandAsync(CommandLineCommandBase cmd, ParseResult<TOption> result, IArgumentManager argumentManager, CancellationToken cancellationToken)
+        {
+            if (!argumentManager.TryGetValue(cmd, out _))
+            {
+                result.MergeResult(new CommandNotFoundParserResult(cmd));
+
+                if (cmd.IsRequired)
+                    throw new CommandNotFoundException(cmd);
+
+                return;
+            }
+
+            var cmdParseResult = await cmd.ParseAsync(argumentManager, cancellationToken);
+
+            result.MergeResult(cmdParseResult);
+
+            if (cmdParseResult.HasErrors)
+                throw new CommandParseException(cmd, cmdParseResult.Errors);
+        }
+
         private void ParseOptions(IList<Exception> errors, ParseResult<TOption> result, IArgumentManager argumentManager)
         {
             foreach (var o in m_options)
@@ -441,6 +559,7 @@ public void RegisterCommand<TCommand>()
             cmdConfigurator.OnConfigure(command);
 
             command.OnExecuting((Action<TOption>)cmdConfigurator.OnExecute);
+            command.OnExecutingAsync((Func<TOption, CancellationToken, Task>)cmdConfigurator.OnExecuteAsync);
 
             m_commands.Add(command);
         }
@@ -467,6 +586,7 @@ public void RegisterCommand<TCommand, TCommandOption>()
             cmdConfigurator.OnConfigure((ICommandConfigurationBuilder<TCommandOption>)command);
 
             command.OnExecuting((Action<TOption, TCommandOption>)cmdConfigurator.OnExecute);
+            command.OnExecutingAsync((Func<TOption, TCommandOption, CancellationToken, Task>)cmdConfigurator.OnExecuteAsync);
 
             m_commands.Add(command);
         }
diff --git a/CommandLineParser/Core/Command/CommandLineCommandBase.cs b/CommandLineParser/Core/Command/CommandLineCommandBase.cs
index f39850a..57fbaf0 100644
--- a/CommandLineParser/Core/Command/CommandLineCommandBase.cs
+++ b/CommandLineParser/Core/Command/CommandLineCommandBase.cs
@@ -1,9 +1,11 @@
-using System.Collections.Generic;
-using System.Diagnostics;
-using MatthiWare.CommandLine.Abstractions;
+using MatthiWare.CommandLine.Abstractions;
 using MatthiWare.CommandLine.Abstractions.Command;
 using MatthiWare.CommandLine.Abstractions.Parsing;
 using MatthiWare.CommandLine.Abstractions.Parsing.Command;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace MatthiWare.CommandLine.Core.Command
 {
@@ -27,6 +29,9 @@ internal abstract class CommandLineCommandBase :
 
         public abstract void Execute();
 
+        public abstract Task ExecuteAsync(CancellationToken cancellationToken);
+
         public abstract ICommandParserResult Parse(IArgumentManager argumentManager);
+        public abstract Task<ICommandParserResult> ParseAsync(IArgumentManager argumentManager, CancellationToken cancellationToken);
     }
 }
diff --git a/CommandLineParser/Core/Command/CommandLineCommand`TOption`TCommandOption.cs b/CommandLineParser/Core/Command/CommandLineCommand`TOption`TCommandOption.cs
index 1a840e7..a5c97e5 100644
--- a/CommandLineParser/Core/Command/CommandLineCommand`TOption`TCommandOption.cs
+++ b/CommandLineParser/Core/Command/CommandLineCommand`TOption`TCommandOption.cs
@@ -1,9 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Reflection;
-using MatthiWare.CommandLine.Abstractions;
+using MatthiWare.CommandLine.Abstractions;
 using MatthiWare.CommandLine.Abstractions.Command;
 using MatthiWare.CommandLine.Abstractions.Models;
 using MatthiWare.CommandLine.Abstractions.Parsing;
@@ -13,6 +8,13 @@
 using MatthiWare.CommandLine.Core.Exceptions;
 using MatthiWare.CommandLine.Core.Parsing.Command;
 using MatthiWare.CommandLine.Core.Utils;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace MatthiWare.CommandLine.Core.Command
 {
@@ -33,9 +35,13 @@ internal class CommandLineCommand<TOption, TCommandOption> :
         private readonly CommandLineParserOptions m_parserOptions;
         private readonly IValidatorsContainer m_validators;
 
-        private Action m_executor;
-        private Action<TOption> m_executor1;
-        private Action<TOption, TCommandOption> m_executor2;
+        private Action m_executor1;
+        private Action<TOption> m_executor2;
+        private Action<TOption, TCommandOption> m_executor3;
+
+        private Func<CancellationToken, Task> m_executorAsync1;
+        private Func<TOption, CancellationToken, Task> m_executorAsync2;
+        private Func<TOption, TCommandOption, CancellationToken, Task> m_executorAsync3;
 
         private readonly string m_helpOptionName;
         private readonly string m_helpOptionNameLong;
@@ -71,9 +77,34 @@ public CommandLineCommand(CommandLineParserOptions parserOptions, IArgumentResol
 
         public override void Execute()
         {
-            m_executor2?.Invoke(m_baseOption, m_commandOption);
-            m_executor1?.Invoke(m_baseOption);
-            m_executor?.Invoke();
+            ExecuteInternal();
+
+            // Also executes the async stuff.
+            ExecuteInternalAsync(default).Wait();
+        }
+
+        private void ExecuteInternal()
+        {
+            m_executor3?.Invoke(m_baseOption, m_commandOption);
+            m_executor2?.Invoke(m_baseOption);
+            m_executor1?.Invoke();
+        }
+
+        public override async Task ExecuteAsync(CancellationToken cancellationToken)
+        {
+            await ExecuteInternalAsync(cancellationToken);
+
+            // Also executes the sync stuff.
+            ExecuteInternal();
+        }
+
+        private async Task ExecuteInternalAsync(CancellationToken cancellationToken)
+        {
+            // await null-conditional doesn't work see https://github.com/dotnet/csharplang/issues/35
+
+            if (m_executorAsync3 != null) await m_executorAsync3(m_baseOption, m_commandOption, cancellationToken);
+            if (m_executorAsync2 != null) await m_executorAsync2(m_baseOption, cancellationToken);
+            if (m_executorAsync1 != null) await m_executorAsync1(cancellationToken);
         }
 
         public IOptionBuilder<TProperty> Configure<TProperty>(Expression<Func<TCommandOption, TProperty>> selector)
@@ -112,6 +143,22 @@ public override ICommandParserResult Parse(IArgumentManager argumentManager)
             return result;
         }
 
+        public override async Task<ICommandParserResult> ParseAsync(IArgumentManager argumentManager, CancellationToken cancellationToken)
+        {
+            var result = new CommandParserResult(this);
+            var errors = new List<Exception>();
+
+            await ParseCommandsAsync(errors, result, argumentManager, cancellationToken);
+
+            ParseOptions(errors, result, argumentManager);
+
+            await ValidateAsync(m_commandOption, errors, cancellationToken);
+
+            result.MergeResult(errors);
+
+            return result;
+        }
+
         private void ParseOptions(IList<Exception> errors, CommandParserResult result, IArgumentManager argumentManager)
         {
             foreach (var o in m_options)
@@ -183,6 +230,39 @@ private void ParseCommands(IList<Exception> errors, CommandParserResult result,
             }
         }
 
+        private async Task ParseCommandsAsync(IList<Exception> errors, CommandParserResult result, IArgumentManager argumentManager, CancellationToken cancellationToken)
+        {
+            foreach (var cmd in m_commands)
+            {
+                try
+                {
+                    if (!argumentManager.TryGetValue(cmd, out ArgumentModel model))
+                    {
+                        result.MergeResult(new CommandNotFoundParserResult(cmd));
+
+                        if (cmd.IsRequired)
+                            throw new CommandNotFoundException(cmd);
+
+                        continue;
+                    }
+
+                    var cmdParseResult = await cmd.ParseAsync(argumentManager, cancellationToken);
+
+                    if (cmdParseResult.HelpRequested)
+                        break;
+
+                    result.MergeResult(cmdParseResult);
+
+                    if (cmdParseResult.HasErrors)
+                        throw new CommandParseException(cmd, cmdParseResult.Errors);
+                }
+                catch (Exception ex)
+                {
+                    errors.Add(ex);
+                }
+            }
+        }
+
         private bool HelpRequested(CommandParserResult result, CommandLineOptionBase option, ArgumentModel model)
         {
             if (!m_parserOptions.EnableHelpOption) return false;
@@ -222,6 +302,23 @@ private void Validate<T>(T @object, List<Exception> errors)
             }
         }
 
+        private async Task ValidateAsync<T>(T @object, List<Exception> errors, CancellationToken token)
+        {
+            if (!m_validators.HasValidatorFor<T>())
+                return;
+
+            var results = (await Task.WhenAll(m_validators.GetValidators<T>()
+                .Select(async validator => await validator.ValidateAsync(@object, token)))).ToArray();
+
+            foreach (var result in results)
+            {
+                if (result.IsValid)
+                    continue;
+
+                errors.Add(result.Error);
+            }
+        }
+
         public ICommandBuilder<TOption, TCommandOption> Required(bool required = true)
         {
             IsRequired = required;
@@ -231,21 +328,41 @@ public ICommandBuilder<TOption, TCommandOption> Required(bool required = true)
 
         public ICommandBuilder<TOption, TCommandOption> OnExecuting(Action<TOption> action)
         {
-            m_executor1 = action;
+            m_executor2 = action;
 
             return this;
         }
 
         public ICommandBuilder<TOption, TCommandOption> OnExecuting(Action action)
         {
-            m_executor = action;
+            m_executor1 = action;
 
             return this;
         }
 
         public ICommandBuilder<TOption, TCommandOption> OnExecuting(Action<TOption, TCommandOption> action)
         {
-            m_executor2 = action;
+            m_executor3 = action;
+
+            return this;
+        }
+        public ICommandBuilder<TOption, TCommandOption> OnExecutingAsync(Func<CancellationToken, Task> action)
+        {
+            m_executorAsync1 = action;
+
+            return this;
+        }
+
+        public ICommandBuilder<TOption, TCommandOption> OnExecutingAsync(Func<TOption, CancellationToken, Task> action)
+        {
+            m_executorAsync2 = action;
+
+            return this;
+        }
+
+        public ICommandBuilder<TOption, TCommandOption> OnExecutingAsync(Func<TOption, TCommandOption, CancellationToken, Task> action)
+        {
+            m_executorAsync3 = action;
 
             return this;
         }
@@ -273,7 +390,7 @@ ICommandBuilder<TOption> ICommandBuilder<TOption>.Description(string description
 
         ICommandBuilder<TOption> ICommandBuilder<TOption>.OnExecuting(Action<TOption> action)
         {
-            m_executor1 = action;
+            m_executor2 = action;
 
             return this;
         }
@@ -429,6 +546,7 @@ public void RegisterCommand<TCommand>()
             cmdConfigurator.OnConfigure(command);
 
             command.OnExecuting((Action<TCommandOption>)cmdConfigurator.OnExecute);
+            command.OnExecutingAsync((Func<TCommandOption, CancellationToken, Task>)cmdConfigurator.OnExecuteAsync);
 
             m_commands.Add(command);
         }
@@ -449,6 +567,7 @@ public void RegisterCommand<TCommand, V>()
             cmdConfigurator.OnConfigure(command);
 
             command.OnExecuting((Action<TOption, V>)cmdConfigurator.OnExecute);
+            command.OnExecutingAsync((Func<TOption, V, CancellationToken, Task>)cmdConfigurator.OnExecuteAsync);
 
             m_commands.Add(command);
         }
@@ -466,5 +585,12 @@ ICommandConfigurationBuilder ICommandConfigurationBuilder.AutoExecute(bool autoE
 
             return this;
         }
+
+        ICommandBuilder<TOption> ICommandBuilder<TOption>.OnExecutingAsync(Func<TOption, CancellationToken, Task> action)
+        {
+            m_executorAsync2 = action;
+
+            return this;
+        }
     }
 }
diff --git a/CommandLineParser/Core/Parsing/Command/CommandNotFoundParserResult.cs b/CommandLineParser/Core/Parsing/Command/CommandNotFoundParserResult.cs
index d9bd5e6..1e0a71b 100644
--- a/CommandLineParser/Core/Parsing/Command/CommandNotFoundParserResult.cs
+++ b/CommandLineParser/Core/Parsing/Command/CommandNotFoundParserResult.cs
@@ -4,6 +4,8 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace MatthiWare.CommandLine.Core.Parsing.Command
 {
@@ -27,6 +29,8 @@ internal class CommandNotFoundParserResult : ICommandParserResult
 
         public void ExecuteCommand() { }
 
+        public Task ExecuteCommandAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+
         public CommandNotFoundParserResult(ICommandLineCommand cmd) => Command = cmd;
     }
 }
diff --git a/CommandLineParser/Core/Parsing/Command/CommandParserResult.cs b/CommandLineParser/Core/Parsing/Command/CommandParserResult.cs
index 7bcae9b..4962724 100644
--- a/CommandLineParser/Core/Parsing/Command/CommandParserResult.cs
+++ b/CommandLineParser/Core/Parsing/Command/CommandParserResult.cs
@@ -5,6 +5,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace MatthiWare.CommandLine.Core.Parsing.Command
 {
@@ -59,5 +61,11 @@ public void ExecuteCommand()
             m_cmd.Execute();
             Executed = true;
         }
+
+        public async Task ExecuteCommandAsync(CancellationToken cancellationToken)
+        {
+            await m_cmd.ExecuteAsync(cancellationToken);
+            Executed = true;
+        }
     }
 }
diff --git a/CommandLineParser/Core/Parsing/DefaultArgumentResolverFactory.cs b/CommandLineParser/Core/Parsing/DefaultArgumentResolverFactory.cs
index 00891aa..162c3bc 100644
--- a/CommandLineParser/Core/Parsing/DefaultArgumentResolverFactory.cs
+++ b/CommandLineParser/Core/Parsing/DefaultArgumentResolverFactory.cs
@@ -1,9 +1,9 @@
-using System;
-using System.Collections.Generic;
-using MatthiWare.CommandLine.Abstractions;
+using MatthiWare.CommandLine.Abstractions;
 using MatthiWare.CommandLine.Abstractions.Parsing;
 using MatthiWare.CommandLine.Core.Parsing.Resolvers;
 using MatthiWare.CommandLine.Core.Utils;
+using System;
+using System.Collections.Generic;
 
 namespace MatthiWare.CommandLine.Core.Parsing
 {
@@ -42,9 +42,17 @@ public ICommandLineArgumentResolver CreateResolver(Type type)
             {
                 bool isEnum = type.IsEnum;
 
-                var instance = isEnum ?
-                    (ICommandLineArgumentResolver)containerResolver.Resolve(m_types[typeof(Enum)].MakeGenericType(type)) :
-                    (ICommandLineArgumentResolver)containerResolver.Resolve(m_types[type]);
+                ICommandLineArgumentResolver instance = null;
+
+                if (!isEnum && !m_types.ContainsKey(type))
+                    instance = (ICommandLineArgumentResolver)containerResolver.Resolve(typeof(DefaultResolver<>).MakeGenericType(type));
+
+                if (instance == null)
+                {
+                    instance = isEnum ?
+                        (ICommandLineArgumentResolver)containerResolver.Resolve(m_types[typeof(Enum)].MakeGenericType(type)) :
+                        (ICommandLineArgumentResolver)containerResolver.Resolve(m_types[type]);
+                }
 
                 m_cache.Add(type, instance);
             }
diff --git a/CommandLineParser/Core/Parsing/Resolvers/DefaultResolver.cs b/CommandLineParser/Core/Parsing/Resolvers/DefaultResolver.cs
new file mode 100644
index 0000000..e0e3eff
--- /dev/null
+++ b/CommandLineParser/Core/Parsing/Resolvers/DefaultResolver.cs
@@ -0,0 +1,177 @@
+using MatthiWare.CommandLine.Abstractions.Models;
+using MatthiWare.CommandLine.Abstractions.Parsing;
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+
+namespace MatthiWare.CommandLine.Core.Parsing.Resolvers
+{
+    internal class DefaultResolver<T> : ArgumentResolver<T>
+    {
+        private static readonly string TryParseName = "TryParse";
+        private static readonly string ParseName = "Parse";
+
+        public override bool CanResolve(ArgumentModel model)
+        {
+            return TryResolve(model, out _);
+        }
+
+        public override T Resolve(ArgumentModel model)
+        {
+            TryResolve(model, out T instance);
+
+            return instance;
+        }
+
+        private bool TryResolve(ArgumentModel model, out T result)
+        {
+            if (!model.HasValue)
+            {
+                result = default;
+                return false;
+            }
+
+            var ctor = typeof(T).GetConstructors()
+                .Where(FindStringCtor)
+                .FirstOrDefault();
+
+            if (ctor != null)
+            {
+                result = (T)Activator.CreateInstance(typeof(T), model.Value);
+                return true;
+            }
+
+            // search for TryParse method and take one with most arguments
+            var tryParseMethod = typeof(T).GetMethods(BindingFlags.Public | BindingFlags.Static)
+                .Where(FindTryParse).OrderByDescending(m => m.GetParameters().Length).FirstOrDefault();
+
+            if (tryParseMethod != null)
+            {
+                int amountOfParams = tryParseMethod.GetParameters().Length;
+
+                if (amountOfParams == 3)
+                {
+                    var tryParse = (CustomTryParseWithFormat)tryParseMethod.CreateDelegate(typeof(CustomTryParseWithFormat));
+
+                    return tryParse(model.Value, CultureInfo.InvariantCulture, out result);
+                }
+                else if (amountOfParams == 2)
+                {
+                    var tryParse = (CustomTryParse)tryParseMethod.CreateDelegate(typeof(CustomTryParse));
+
+                    return tryParse(model.Value, out result);
+                }
+            }
+
+            // search for Parse method and take one with most arguments
+            var parseMethod = typeof(T).GetMethods(BindingFlags.Public | BindingFlags.Static)
+                .Where(FindParse).OrderByDescending(m => m.GetParameters().Length).FirstOrDefault();
+
+            if (parseMethod != null)
+            {
+                int amountOfParams = parseMethod.GetParameters().Length;
+
+                if (amountOfParams == 2)
+                {
+                    var parse = (CustomParseWithFormat)parseMethod.CreateDelegate(typeof(CustomParseWithFormat));
+
+                    result = parse(model.Value, CultureInfo.InvariantCulture);
+                    return true;
+                }
+                else if (amountOfParams == 1)
+                {
+                    var parse = (CustomParse)parseMethod.CreateDelegate(typeof(CustomParse));
+
+                    result = parse(model.Value);
+                    return true;
+                }
+            }
+
+            result = default;
+            return false;
+        }
+
+        private delegate bool CustomTryParseWithFormat(string input, IFormatProvider format, out T result);
+        private delegate bool CustomTryParse(string input, out T result);
+        private delegate T CustomParseWithFormat(string input, IFormatProvider format);
+        private delegate T CustomParse(string input);
+
+        /// <summary>
+        /// Finds the Type.TryParse(String, IFormatProvider, out T result) method
+        /// </summary>
+        /// <param name="method"></param>
+        /// <returns>True or false</returns>
+        private bool FindTryParse(MethodInfo method)
+        {
+            if (method.Name != TryParseName)
+                return false;
+
+            if (method.ReturnType != typeof(bool))
+                return false;
+
+            var args = method.GetParameters();
+
+            if (args.Length < 2 || args.Length > 3)
+                return false;
+
+            // Starts with string
+            if (args[0].ParameterType != typeof(string))
+                return false;
+
+            // Last one should be out param
+            if (!args[args.Length - 1].IsOut || args[args.Length - 1].ParameterType != typeof(T).MakeByRefType())
+                return false;
+
+            // If provided the 2nd param should be an IFormatProvider
+            if (args.Length == 3 && args[1].ParameterType != typeof(IFormatProvider))
+                return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Finds the Type.TryParse(String, IFormatProvider, out T result) method
+        /// </summary>
+        /// <param name="method"></param>
+        /// <returns>True or false</returns>
+        private bool FindParse(MethodInfo method)
+        {
+            if (method.Name != ParseName)
+                return false;
+
+            if (method.ReturnType != typeof(T))
+                return false;
+
+            var args = method.GetParameters();
+
+            if (args.Length < 1 || args.Length > 2)
+                return false;
+
+            // Starts with string
+            if (args[0].ParameterType != typeof(string))
+                return false;
+
+            // If provided the 2nd param should be an IFormatProvider
+            if (args.Length == 2 && args[1].ParameterType != typeof(IFormatProvider))
+                return false;
+
+            return true;
+        }
+
+        private bool FindStringCtor(ConstructorInfo ctor)
+        {
+            var args = ctor.GetParameters();
+
+            // more than 1 ctor argument
+            if (args.Length != 1)
+                return false;
+
+            // Check if it is a string
+            if (args[0].ParameterType != typeof(string))
+                return false;
+
+            return true;
+        }
+    }
+}
diff --git a/CommandLineParser/Core/TypedInstanceCache.cs b/CommandLineParser/Core/TypedInstanceCache.cs
index ff3637f..81e932d 100644
--- a/CommandLineParser/Core/TypedInstanceCache.cs
+++ b/CommandLineParser/Core/TypedInstanceCache.cs
@@ -5,6 +5,10 @@
 
 namespace MatthiWare.CommandLine.Core
 {
+    /// <summary>
+    /// A strongly-typed instance cache
+    /// </summary>
+    /// <typeparam name="TValue"></typeparam>
     public class TypedInstanceCache<TValue>
     {
         private readonly IContainerResolver resolver;
@@ -15,6 +19,10 @@ public TypedInstanceCache(IContainerResolver resolver)
             this.resolver = resolver;
         }
 
+        /// <summary>
+        /// Adds a new instance to the cache
+        /// </summary>
+        /// <param name="value"></param>
         public void Add(TValue value)
         {
             var key = typeof(TValue);
@@ -25,6 +33,10 @@ public void Add(TValue value)
                 instances[key].SetInstance(value);
         }
 
+        /// <summary>
+        /// Adds a type to the cache that will be resolved later
+        /// </summary>
+        /// <param name="type"></param>
         public void Add(Type type)
         {
             if (!instances.ContainsKey(type))
@@ -33,12 +45,10 @@ public void Add(Type type)
                 instances[type].Clear();
         }
 
-        public void Add<T>() 
-            where T : TValue
-        {
-            Add(typeof(T));
-        }
-
+        /// <summary>
+        /// Gets the values from the cache. This will instantiate unresolved items. 
+        /// </summary>
+        /// <returns></returns>
         public IReadOnlyList<TValue> Get()
         {
             var toResolve = instances.Values.Where(meta => !meta.Created).ToArray();
diff --git a/Extensions/FluentValidationsExtensions/CommandLineParser.FluentValidations.xml b/Extensions/FluentValidationsExtensions/CommandLineParser.FluentValidations.xml
index 2d4a83b..5ad6a89 100644
--- a/Extensions/FluentValidationsExtensions/CommandLineParser.FluentValidations.xml
+++ b/Extensions/FluentValidationsExtensions/CommandLineParser.FluentValidations.xml
@@ -44,5 +44,13 @@
             <param name="instance">Validator instance</param>
             <returns>Self</returns>
         </member>
+        <member name="M:MatthiWare.CommandLine.Extensions.FluentValidations.FluentValidationsExtensions.UseFluentValidations``1(MatthiWare.CommandLine.CommandLineParser{``0},System.Action{MatthiWare.CommandLine.Extensions.FluentValidations.Core.FluentValidationConfiguration})">
+            <summary>
+            Extensions to configure FluentValidations for the Parser
+            </summary>
+            <typeparam name="T"></typeparam>
+            <param name="parser"></param>
+            <param name="configAction">Configuration action</param>
+        </member>
     </members>
 </doc>
diff --git a/Extensions/FluentValidationsExtensions/Core/FluentTypeValidatorCollection`1.cs b/Extensions/FluentValidationsExtensions/Core/FluentTypeValidatorCollection`1.cs
index 9fc56c5..519b6dd 100644
--- a/Extensions/FluentValidationsExtensions/Core/FluentTypeValidatorCollection`1.cs
+++ b/Extensions/FluentValidationsExtensions/Core/FluentTypeValidatorCollection`1.cs
@@ -3,6 +3,8 @@
 using MatthiWare.CommandLine.Core;
 using System;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace MatthiWare.CommandLine.Extensions.FluentValidations.Core
 {
@@ -41,5 +43,22 @@ public IValidationResult Validate(object @object)
                 return FluentValidationsResult.Succes();
             }
         }
+
+        public async Task<IValidationResult> ValidateAsync(object @object, CancellationToken cancellationToken = default)
+        {
+            var errors = (await Task.WhenAll(validators.Get()
+                .Select(async v => await v.ValidateAsync(@object, cancellationToken))))
+                .SelectMany(r => r.Errors)
+                .ToList();
+
+            if (errors.Any())
+            {
+                return FluentValidationsResult.Failure(errors);
+            }
+            else
+            {
+                return FluentValidationsResult.Succes();
+            }
+        }
     }
 }