//------------------------------------------Scope------------------------------------------//
 /// <summary>
 /// Formats the message and creates a scope.
 /// </summary>
 /// <param name="logger">The <see cref="ILogger"/> to create the scope in.</param>
 /// <param name="messageFormat">Format string of the scope message.</param>
 /// <param name="args">An object array that contains zero or more objects to format.</param>
 /// <returns>A disposable scope object. Can be null.</returns>
 public static IDisposable BeginScope(
     this ILogger logger,
     string messageFormat,
     params object[] args)
 {
     return logger.BeginScope(new FormattedLogValues(messageFormat, args));
 }
		public static IDisposable RequireScope(this IWindsorContainer container)
		{
			var current = Scope.ObtainCurrentScope();
			if (current == null)
			{
				return container.BeginScope();
			}
			return null;
		}
		public static IDisposable RequireScope(this IKernel kernel)
		{
			var current = Scope.ObtainCurrentScope();
			if (current == null)
			{
				return kernel.BeginScope();
			}
			return null;
		}
        /// <summary>
        /// Formats the message and creates a scope.
        /// </summary>
        /// <param name="logger">The <see cref="ILogger"/> to create the scope in.</param>
        /// <param name="messageFormat">Format string of the scope message.</param>
        /// <param name="args">An object array that contains zero or more objects to format.</param>
        /// <returns>A disposable scope object. Can be null.</returns>
        public static IDisposable BeginScope(this ILogger logger, string messageFormat, params object[] args) {
            if (logger == null)
                throw new ArgumentNullException(nameof(logger));

            if (messageFormat == null)
                throw new ArgumentNullException(nameof(messageFormat));

            return logger.BeginScope(s => s.ToString(), new FormattedLogValues(messageFormat, args));
        }
 public static void ResetTestDataBases(this IWindsorContainer container)
 {
     using(container.BeginScope())
     {
         foreach(var dbResetter in container.ResolveAll<IResetTestDatabases>())
         {
             dbResetter.ResetDatabase();
             container.Release(dbResetter);
         }
     }
 }
        /// <summary>
        /// Creates a scoped log using a builder.
        /// </summary>
        /// <param name="logger">The <see cref="ILogger"/> to create the scope in.</param>
        /// <param name="builder">The scope builder used to build the scope.</param>
        /// <returns>A disposable scope object. Can be null.</returns>
        public static IDisposable BeginScope(this ILogger logger, Action<PropertyBuilder> builder) {
            if (logger == null)
                throw new ArgumentNullException(nameof(logger));

            if (builder == null)
                throw new ArgumentNullException(nameof(builder));

            var propertyBuilder = new PropertyBuilder();
            builder(propertyBuilder);

            return logger.BeginScope(s => s, propertyBuilder.Properties);
        }
        public static void AssertCanResolveAllComponents(this IWindsorContainer container, IEnumerable<Type> ignoredServices = null, IEnumerable<string> ignoredComponents = null)
        {
            var errorsOccured = false;
            ignoredServices = (ignoredServices ?? new Type[] {}).ToList();
            ignoredComponents = (ignoredComponents ?? new string[] {}).ToList();
            using(container.BeginScope())
            {
                foreach(var handler in container.Kernel.GetAssignableHandlers(typeof(object)).Distinct())
                {
                    if(ignoredComponents.Any(ignored => handler.ComponentModel.ComponentName.Name == ignored))
                    {
                        Console.WriteLine(@"Ignoring component: {0}", ignoredComponents.Single(ignored => handler.ComponentModel.ComponentName.Name == ignored));
                        continue;
                    }

                    Console.WriteLine("Resolving services for component: {0}", handler.ComponentModel.Name);

                    foreach(var service in handler.ComponentModel.Services)
                    {
                        if(ignoredServices.Any(ignored => ignored == service))
                        {
                            Console.WriteLine(@"    Ignoring service: {0}", ignoredServices.Single(ignored => ignored == service));
                            continue;
                        }

                        Console.WriteLine(@"    Resolving all {0} ", service.FullName);
                        try
                        {
                            var resolved = container.ResolveAll(service).Cast<Object>().Select(s => s.GetType().FullName).OrderBy(s => s);
                            resolved.ForEach((name, index) => Console.WriteLine(@"	Resolved {0} {1}", index + 1, name));
                        }
                        catch(Exception e)
                        {
                            Console.WriteLine();
                            Console.WriteLine(@"############################## {0} ##########################", @"Failed to resolve component");
                            Console.WriteLine(@"##############################Component Name: {0} ##########################", handler.ComponentModel.Name);
                            Console.WriteLine(@"##############################Service Type: {0} ##########################", service.FullName);
                            Console.WriteLine(CreateStackTrace(e));
                            Console.WriteLine();
                            errorsOccured = true;
                        }
                    }
                }
            }
            if(errorsOccured)
            {
                throw new Exception("There were errors resolving components. Please see the printed call stacks above this one.");
            }
        }
 /// <summary>
 /// Begins a lexical scope.
 /// </summary>
 public static ILGenerator BeginScope(this ILGenerator il)
 {
     il.BeginScope();
     return il;
 }