autofac 注入中i遇到的泛型传参问题

using Autofac;
using IService;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using TT.Service.Interface;
using TT.Service.Realize;

namespace InjectionServer
{
    public class Dependency
    {

        public static Assembly Assemblys { set; get; } = Assembly.Load("TT.Service");

        static Dependency()
        {
            if (Builder == null)
            {
                Builder = new ContainerBuilder();//初始化容器
                Builder.RegisterAssemblyTypes(Assemblys)
                .Where(o => o != typeof(IRepository<>))
                .AsImplementedInterfaces().PropertiesAutowired().InstancePerDependency();
                InstanceContainer = Builder.Build();
            }
        }

        public Dependency()
        {
            var type = this.GetType();
            foreach (var item in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
            {
                try
                {
                    string key = "TT.Service.Interface." + $"I{item.Name.Replace("Example", "")}";
                    Type t = Assemblys.GetType(key);
                    var method = type.GetMethod("GetInstance", BindingFlags.Static | BindingFlags.NonPublic)
                                                  .MakeGenericMethod(t);
                    item.SetValue(this, method.Invoke(null, null));
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
        }

        /// <summary>
        /// 取出对象管理
        /// </summary>
        internal static IContainer InstanceContainer { get; set; }

        /// <summary>
        /// 注册对象管理
        /// </summary>
        internal static ContainerBuilder Builder { get; set; }

        internal static T GetInstance<T>()
            where T : class
        {
                var instance = InstanceContainer.Resolve<T>();
                return instance;
        }

        internal static void Register<T, K>()
                where T : class
                where K : class
        {
            Builder.RegisterType<T>().As<K>().PropertiesAutowired().InstancePerDependency();
        }

        public IUsers UsersExample { set; get; }

        public ITest TestExample { set; get; }
    }
}

　　

之前的代码

 using Autofac;
 using IService;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Text;
 using System.Threading.Tasks;
 using TT.Service.Interface;
 using TT.Service.Realize;

 namespace InjectionServer
 {
     public class Dependency
     {
          static Dependency()
         {
             if (Builder == null)
             {
                 Builder = new ContainerBuilder();
                 Register();
                 InstanceContainer = Builder.Build();
             }
         }

         #region 容器管理
         /// <summary>
         /// 取出对象管理
         /// </summary>
         internal static IContainer InstanceContainer { get; set; }

         /// <summary>
         /// 注册对象管理
         /// </summary>
         internal static ContainerBuilder Builder { get; set; }

         /// <summary>
         /// 获取指定接口的实例
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <returns></returns>
         internal static T GetInstance<T>()
             where T : class
         {
             var instance = InstanceContainer.Resolve<T>();
             return instance;
         }

         /// <summary>
         /// 注册并且设置为在一个生命周期域中，每一个依赖或调用创建一个单一的共享的实例，且每一个不同的生命周期域，实例是唯一的，不共享的。
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <typeparam name="K"></typeparam>
         /// <param name="t"></param>
         /// <param name="k"></param>
         internal static void Register<T, K>()
              where T : class
              where K : class
         {
             Builder.RegisterType<T>().As<K>().PropertiesAutowired().InstancePerDependency();
         }
         #endregion

         #region 容器注册
         internal static void Register()
         {

             Register<UserService, IUserService>();
             //Register<UserService, IUserService>();
             //Register<UserService, IUserService>();

         }
         #endregion

         public IUsers UsersExample {  get { return GetInstance<IUsersService>(); } }

     }
 }