# HG changeset patch
# User srobbins <>
# Date 1270145060 -3600
# Node ID 9758b42893214968c3267a8a34383d124f1ba008
# Parent  e7e0d1b655098e631ea8d808b297e8361136a118
Finished tryresolve

diff -r e7e0d1b655098e631ea8d808b297e8361136a118 -r 9758b42893214968c3267a8a34383d124f1ba008 TinyIoC.Tests/TinyIoCTests.cs
--- a/TinyIoC.Tests/TinyIoCTests.cs	Wed Mar 31 22:08:12 2010 +0100
+++ b/TinyIoC.Tests/TinyIoCTests.cs	Thu Apr 01 19:04:20 2010 +0100
@@ -2178,5 +2178,109 @@
             Assert.IsFalse(result);
         }
 
+        [TestMethod]
+        public void TryResolve_ValidResolveWithNameAndParameters_ReturnsTrue()
+        {
+            var container = UtilityMethods.GetContainer();
+            container.Register<TestClassWithParameters>("Testing");
+
+            TestClassWithParameters output;
+            var result = container.TryResolve<TestClassWithParameters>("Testing", new NamedParameterOverloads() { { "stringProperty", "test" }, { "intProperty", 2 } }, out output);
+
+            Assert.IsTrue(result);
+        }
+
+        [TestMethod]
+        public void TryResolve_ValidResolveWithNameAndParameters_ReturnsType()
+        {
+            var container = UtilityMethods.GetContainer();
+            container.Register<TestClassWithParameters>("Testing");
+
+            TestClassWithParameters output;
+            var result = container.TryResolve<TestClassWithParameters>("Testing", new NamedParameterOverloads() { { "stringProperty", "test" }, { "intProperty", 2 } }, out output);
+
+            Assert.IsInstanceOfType(output, typeof(TestClassWithParameters));
+        }
+
+        [TestMethod]
+        public void TryResolve_InvalidResolveWithNameAndParameters_ReturnsFalse()
+        {
+            var container = UtilityMethods.GetContainer();
+
+            TestClassWithParameters output;
+            var result = container.TryResolve<TestClassWithParameters>("Testing", new NamedParameterOverloads() { { "intProperty", 2 } }, out output);
+
+            Assert.IsFalse(result);
+        }
+
+        [TestMethod]
+        public void TryResolve_ValidResolveWithParametersAndOptions_ReturnsTrue()
+        {
+            var container = UtilityMethods.GetContainer();
+            container.Register<TestClassWithParameters>();
+
+            TestClassWithParameters output;
+            var result = container.TryResolve<TestClassWithParameters>(new NamedParameterOverloads() { { "stringProperty", "test" }, { "intProperty", 2 } }, new TinyIoC.ResolveOptions(), out output);
+
+            Assert.IsTrue(result);
+        }
+
+        [TestMethod]
+        public void TryResolve_ValidResolveWithParametersAndOptions_ReturnsType()
+        {
+            var container = UtilityMethods.GetContainer();
+            container.Register<TestClassWithParameters>();
+
+            TestClassWithParameters output;
+            var result = container.TryResolve<TestClassWithParameters>(new NamedParameterOverloads() { { "stringProperty", "test" }, { "intProperty", 2 } }, new TinyIoC.ResolveOptions(), out output);
+
+            Assert.IsInstanceOfType(output, typeof(TestClassWithParameters));
+        }
+
+        [TestMethod]
+        public void TryResolve_InvalidResolveWithParametersAndOptions_ReturnsFalse()
+        {
+            var container = UtilityMethods.GetContainer();
+
+            TestClassWithParameters output;
+            var result = container.TryResolve<TestClassWithParameters>(new NamedParameterOverloads() { { "intProperty", 2 } }, new TinyIoC.ResolveOptions(), out output);
+
+            Assert.IsFalse(result);
+        }
+
+        [TestMethod]
+        public void TryResolve_ValidResolveWithNameParametersAndOptions_ReturnsTrue()
+        {
+            var container = UtilityMethods.GetContainer();
+            container.Register<TestClassWithParameters>("Testing");
+
+            TestClassWithParameters output;
+            var result = container.TryResolve<TestClassWithParameters>("Testing", new NamedParameterOverloads() { { "stringProperty", "test" }, { "intProperty", 2 } }, new TinyIoC.ResolveOptions(), out output);
+
+            Assert.IsTrue(result);
+        }
+
+        [TestMethod]
+        public void TryResolve_ValidResolveWithNameParametersAndOptions_ReturnsType()
+        {
+            var container = UtilityMethods.GetContainer();
+            container.Register<TestClassWithParameters>("Testing");
+
+            TestClassWithParameters output;
+            var result = container.TryResolve<TestClassWithParameters>("Testing", new NamedParameterOverloads() { { "stringProperty", "test" }, { "intProperty", 2 } }, new TinyIoC.ResolveOptions(), out output);
+
+            Assert.IsInstanceOfType(output, typeof(TestClassWithParameters));
+        }
+
+        [TestMethod]
+        public void TryResolve_InvalidResolveWithNameParametersAndOptions_ReturnsFalse()
+        {
+            var container = UtilityMethods.GetContainer();
+
+            TestClassWithParameters output;
+            var result = container.TryResolve<TestClassWithParameters>("Testing", new NamedParameterOverloads() { { "intProperty", 2 } }, new TinyIoC.ResolveOptions(), out output);
+
+            Assert.IsFalse(result);
+        }
     }
 }
diff -r e7e0d1b655098e631ea8d808b297e8361136a118 -r 9758b42893214968c3267a8a34383d124f1ba008 TinyIoC/TinyIoC.cs
--- a/TinyIoC/TinyIoC.cs	Wed Mar 31 22:08:12 2010 +0100
+++ b/TinyIoC/TinyIoC.cs	Thu Apr 01 19:04:20 2010 +0100
@@ -975,6 +975,78 @@
                 return false;
             }
         }
+
+        /// <summary>
+        /// Attemps to resolve a type using the default options and supplied name and constructor parameters
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <param name="name">Name of registration</param>
+        /// <param name="parameters">User specified constructor parameters</param>
+        /// <param name="resolvedType">Resolved type or default if resolve fails</param>
+        /// <returns>True if resolved sucessfully, false otherwise</returns>
+        public bool TryResolve<ResolveType>(string name, NamedParameterOverloads parameters, out ResolveType resolvedType)
+            where ResolveType : class
+        {
+            try
+            {
+                resolvedType = this.Resolve<ResolveType>(name, parameters);
+                return true;
+            }
+            catch (TinyIoCResolutionException)
+            {
+                resolvedType = default(ResolveType);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Attemps to resolve a type using the supplied options and constructor parameters
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <param name="name">Name of registration</param>
+        /// <param name="parameters">User specified constructor parameters</param>
+        /// <param name="options">Resolution options</param>
+        /// <param name="resolvedType">Resolved type or default if resolve fails</param>
+        /// <returns>True if resolved sucessfully, false otherwise</returns>
+        public bool TryResolve<ResolveType>(NamedParameterOverloads parameters, ResolveOptions options, out ResolveType resolvedType)
+            where ResolveType : class
+        {
+            try
+            {
+                resolvedType = this.Resolve<ResolveType>(parameters, options);
+                return true;
+            }
+            catch (TinyIoCResolutionException)
+            {
+                resolvedType = default(ResolveType);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Attemps to resolve a type using the supplied name, options and constructor parameters
+        /// </summary>
+        /// <typeparam name="ResolveType">Type to resolve</typeparam>
+        /// <param name="name">Name of registration</param>
+        /// <param name="parameters">User specified constructor parameters</param>
+        /// <param name="options">Resolution options</param>
+        /// <param name="resolvedType">Resolved type or default if resolve fails</param>
+        /// <returns>True if resolved sucessfully, false otherwise</returns>
+        public bool TryResolve<ResolveType>(string name, NamedParameterOverloads parameters, ResolveOptions options, out ResolveType resolvedType)
+            where ResolveType : class
+        {
+            try
+            {
+                resolvedType = this.Resolve<ResolveType>(name, parameters, options);
+                return true;
+            }
+            catch (TinyIoCResolutionException)
+            {
+                resolvedType = default(ResolveType);
+                return false;
+            }
+        }
+
         /// <summary>
         /// Attempts to resolve all public property dependencies on the given object.
         /// </summary>