How to have only some constructor parameters injected with A

using System;
using System.IO;
using Autofac;
using Daedalus.Channel;
using Daedalus.Common;
using Daedalus.Contracts.Common;
using Daedalus.Contracts.Services;
using Daedalus.Hosting.Interfaces;
using Daedalus.Logic;
using RabbitMQ.Client;
using Topshelf.Configuration.Dsl;
using log4net;
using log4net.Config;

namespace Daedalus.Hosting.Hosts
{
    public class ProductServiceHost : IHost
    {
        //This instance of manager is only for debugging
        private IManager<IProductService, ISerializer> _manager;

        private readonly ILog _log = LogManager.GetLogger(typeof(ProductServiceHost));
        private IContainer _container;
        private String ExchangeName { get; set; }

        public ProductServiceHost()
        {
            _log.InfoFormat("Enter Host Constructor");
            ExchangeName = "test.workqueue.product";
            SetupAutofac();
        }

        public void InitializeHostedService(IServiceConfigurator<IManager<IProductService, ISerializer>> cfg)
        {
            cfg.HowToBuildService(n => _container.Resolve<IManager<IProductService, ISerializer>>());
            cfg.WhenStarted(s =>
                                {
                                    XmlConfigurator.Configure(
                                        new FileInfo(
                                            Path.Combine(
                                                AppDomain.CurrentDomain.BaseDirectory,
                                                String.Format("{0}.log4net.config", GetType().Name))));

                                    s.Start();
                                });
            cfg.WhenStopped(s =>
                                {
                                    s.Stop();
                                    LogManager.Shutdown();
                                });
        }

        public void OverrideStart()
        {
            _manager = _container.Resolve<IManager<IProductService, ISerializer>>();
            _manager.Start();
        }

        /// <summary>
        /// Composition Root for Daedalus
        /// </summary>
        public void SetupAutofac()
        {
            _log.InfoFormat("SetupAutofac() on {0} @ {1}", GetType().Name, DateTime.Now);
            var builder = new ContainerBuilder();

            SetupRegistrations(builder);

            _container = builder.Build();

            var e = _container.Resolve<IEndpoint<IProductService, ISerializer>>();
            var b = e.IsRunning;
        }


        private void SetupRegistrations(ContainerBuilder builder)
        {
            _log.InfoFormat("SetupRegistrations()");

            builder.RegisterModule<LogInjectionModule>();

            builder.RegisterType<DaedalusRpcClient<IProductService>>().As<IDaedalusRpcClient<IProductService>>();

            builder.Register(c => new FakeDal()).As<IDal>();

            builder.Register(c => new ProductEngine(c.Resolve<IDal>()))
                .As<IProductService>();


            builder.Register(c => new AllSerializeMethods())
                .As<ISerializer>();

            builder.Register(
                c => new ConnectionFactory {Address = "127.0.0.1"}.CreateConnection()
                ).As<IConnection>();

            builder.Register(
                c =>
                    {
                        var model = c.Resolve<IConnection>().CreateModel();
                        model.ExchangeDeclare(ExchangeName, ExchangeType.Direct);
                        return model;
                    }
                ).As<IModel>();

            builder.Register(
                c =>
                    {
                        var ch = c.Resolve<IModel>();
                        var queueName = ch.EnsureQueue(ExchangeName);
                        var sub = new DaedalusSubscription(ch, queueName);
                        return sub;
                    }
                ).As<ISubscription>();

            builder.RegisterType<DaedalusRpcServer<ProductEngine, AllSerializeMethods>>()
                                      /*c.Resolve<ISubscription>(),
                                      c.Resolve<IProductService>() as ProductEngine,
                                      c.Resolve<ISerializer>() as AllSerializeMethods,
                                      c.Resolve<ILog>())*/
                .As<IDaedalusRpcServer<IProductService, ISerializer>>();

            builder.RegisterType<DaedalusServiceEndpoint<IProductService, ISerializer>>(
                    /*c.Resolve<IDaedalusRpcServer<IProductService, ISerializer>>(),
                    c.Resolve<ILog>())*/
                ).As<IEndpoint<IProductService, ISerializer>>();

            builder.Register(
                c =>
                new Manager<IProductService, ISerializer>(
                    c.Resolve<IEndpoint<IProductService, ISerializer>>())
                )
                .As<IManager<IProductService, ISerializer>>();
        }
    }
}