Added Options.EnableAutoVerification with a value set to false by def…

…ault. Fixes #555.

src/SimpleInjector/Container.Common.cs

@@ -477,6 +477,28 @@ private void FlagContainerAsLocked()
 
                 this.locked = true;
             }
+
+            if (this.Options.EnableAutoVerification && !this.IsVerifying && !this.SuccesfullyVerified)
+            {
+                try
+                {
+                    this.Verify();
+                }
+                catch (InvalidOperationException ex)
+                {
+                    // Verify throws an invalid operation exception. Here, we instead want to throw an
+                    // ActivationException, as that would allow the same exception type to be thrown in that
+                    // case, which is often what the user would expect.
+                    throw new ActivationException(
+                        StringResources.EnableAutoVerificationIsEnabled(ex.Message), ex);
+                }
+                catch (DiagnosticVerificationException ex)
+                {
+                    // Same for DiagnosticVerificationExceptions.
+                    throw new ActivationException(
+                        StringResources.EnableAutoVerificationIsEnabled(ex.Message), ex);
+                }
+            }
         }
 
         private void ThrowContainerDisposedException()

src/SimpleInjector/Container.Verification.cs

@@ -110,9 +110,13 @@ private void VerifyInternal(bool suppressLifestyleMismatchVerification)
             // the first thread could dispose the verification scope, while the other thread is still using it.
             lock (this.isVerifying)
             {
+                // Flag verifying before locking the container, because LockContainer otherwise triggers
+                // verification again causing a stack overflow.
+                this.IsVerifying = true;
+
                 this.LockContainer();
                 bool original = this.Options.SuppressLifestyleMismatchVerification;
-                this.IsVerifying = true;
+
                 this.VerificationScope = new ContainerVerificationScope(this);
 
                 try

src/SimpleInjector/ContainerOptions.cs

@@ -88,12 +88,21 @@ internal ContainerOptions(Container container)
         /// <summary>
         /// Gets or sets a value indicating whether the container should suppress checking for lifestyle
         /// mismatches (see: https://simpleinjector.org/dialm) when a component is resolved. The default
-        /// is false.
+        /// is false. This setting will have no effect when <see cref="EnableAutoVerification"/> is true.
         /// </summary>
         /// <value>The value indicating whether the container should suppress checking for lifestyle
         /// mismatches.</value>
         public bool SuppressLifestyleMismatchVerification { get; set; }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether the container should automatically trigger verification
+        /// and diagnostics of its configuration when the first service is resolved (e.g. the first call to
+        /// GetInstance). The behavior is identical to calling <see cref="Container.Verify()">Verify()</see>
+        /// manually. The default is false.
+        /// </summary>
+        /// <value>The value indicating whether the container should automatically trigger verification.</value>
+        public bool EnableAutoVerification { get; set; }
+
         /// <summary>Gets or sets a value indicating whether.
         /// This method is deprecated. Changing its value will have no effect.</summary>
         /// <value>The value indicating whether the container will return an empty collection.</value>

src/SimpleInjector/InstanceProducer.cs

@@ -234,6 +234,9 @@ public static InstanceProducer FromExpression(
             "A property is not appropriate, because get instance could possibly be a heavy operation.")]
         public object GetInstance()
         {
+            // We must lock the container, because not locking could lead to race conditions.
+            this.Container.LockContainer();
+
             this.CheckForCyclicDependencies();
 
             object instance;
@@ -275,6 +278,9 @@ public object GetInstance()
         /// <returns>An Expression.</returns>
         public Expression BuildExpression()
         {
+            // We must lock the container, because not locking could lead to race conditions.
+            this.Container.LockContainer();
+
             this.CheckForCyclicDependencies();
 
             try
@@ -524,9 +530,6 @@ private void Analyze()
 
         private Expression BuildExpressionInternal()
         {
-            // We must lock the container, because not locking could lead to race conditions.
-            this.Container.LockContainer();
-
             var expression = this.Registration.BuildExpression();
 
             if (expression == null)

src/SimpleInjector/StringResources.cs

@@ -18,6 +18,9 @@ internal static class StringResources
         private const string CollectionsRegisterMethodName =
             nameof(Container) + "." + nameof(Container.Collection) + "." + nameof(ContainerCollectionRegistrator.Register);
 
+        private const string EnableAutoVerificationPropertyName =
+            nameof(Container) + "." + nameof(Container.Options) + "." + nameof(ContainerOptions.EnableAutoVerification);
+
         // Assembly.Location only exists in .NETStandard1.5 and up, .NET4.0 and PCL, but we only compile
         // against .NETStandard1.0 and .NETStandard1.3. We don't want to add an extra build directly, solely
         // for the Location property.
@@ -165,6 +168,11 @@ from error in errors
                 Environment.NewLine);
         }
 
+        internal static string EnableAutoVerificationIsEnabled(string innerMessage) =>
+            innerMessage + $" Verification was triggered because {EnableAutoVerificationPropertyName} was " +
+            "enabled. To prevent the container from being verified on first resolve, set " +
+            $"{EnableAutoVerificationPropertyName} to false.";
+
         internal static string ConfigurationInvalidCreatingInstanceFailed(
             Type serviceType, Exception exception) =>
             Format(