How to have only some PropertiesAutowired with Autofac while

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Autofac;
using Autofac.Core;
using log4net;

namespace AutoFacLog4NetDemo
{

    class Program
    {
        static void Main(string[] args)
        {
            //setup
            Console.WriteLine("Attempt to use a Module to configure ILog dependency");
            var builder = new ContainerBuilder();

            builder.RegisterModule<LogInjectionModule>();
            // that or ...
            //builder.RegisterModule(new LogInjectionModule());
            //neither worked...

            //TODO: is this registration correct?
            /*builder.Register(c => new SomeClassWithILogDependency(c.Resolve<ILog>())
                ).As<IUseILog>().PropertiesAutowired();*/


            builder.RegisterType<SomethingElse>().As<ISecond>();

            //NOTE: looks like this works:
            //builder.RegisterType<SomeClassWithILogDependency>().As<IUseILog>().PropertiesAutowired();


            builder.Register(c => new SomeClassWithILogDependency(c.ResolveOptional<ILog>(), c.Resolve<ISecond>()))
                .As<IUseILog>().PropertiesAutowired();


            var container = builder.Build();

            //attempt to create instance

            var sc = container.Resolve<IUseILog>();

            try
            {
                //attempt to use
                sc.UseILog();
            }
            catch (Exception ex)
            {
                Console.WriteLine("It didn't work{0}exception: {1}", Environment.NewLine, ex.Message);
            }

            Console.ReadKey();
        }
    }

    //NOTE: as per - http://code.google.com/p/autofac/wiki/Log4NetIntegration
    public class LogInjectionModule : Module
    {
        protected override void AttachToComponentRegistration(IComponentRegistry registry, IComponentRegistration registration)
        {
            registration.Preparing += OnComponentPreparing;
        }

        private static void OnComponentPreparing(object sender, PreparingEventArgs e)
        {
            var t = e.Component.Activator.LimitType;

            e.Parameters = e.Parameters.Union(new[]
                                                  {
                                                      new ResolvedParameter(
                                                          (p, i) => p.ParameterType == typeof (ILog),
                                                          (p, i) => LogManager.GetLogger(t))
                                                  });
        }

    }

    public interface IUseILog
    {
        void UseILog();
    }

    public class SomeClassWithILogDependency : IUseILog
    {
        private readonly ILog _log;
        private readonly ISecond _second;

        public SomeClassWithILogDependency(ILog log, ISecond second)
        {
            _log = log;
            _second = second;

        }
        public void UseILog()
        {
            try
            {
                _second.ConfirmRunning();
                _log.InfoFormat("it possibly worked {0}", DateTime.Now);
                Console.WriteLine("it possibly worked...");
            }
            catch(Exception ex)
            {
                Console.WriteLine("Error inside SomeClassWithILogDependency{0}exception:{1}",Environment.NewLine, ex.Message);
            }
        }
    }

    public interface ISecond
    {
        void ConfirmRunning();
    }

    public class SomethingElse : ISecond
    {
        public SomethingElse()
        {

        }

        public void ConfirmRunning()
        {
            Console.WriteLine("inside SomethingElse");
        }
    }
}