/// <summary>  
    /// 缓存起来，类型的对象实例  
    /// </summary>  
    private Dictionary<Type, object> TypeObjectDictionary = new Dictionary<Type, object>();

    public void RegisterType<TFrom, TTo>(LifeTimeType lifeTimeType = LifeTimeType.Transient)  
    {  
        ContainerDictionary.Add(typeof(TFrom).FullName, new RegisterInfo()  
        {  
            TargetType = typeof(TTo),  
            LifeTime = lifeTimeType  
        });  
    }

    public T Resolve<T>()  
    {  
        RegisterInfo info = ContainerDictionary\[typeof(T).FullName\];  
        Type type = ContainerDictionary\[typeof(T).FullName\].TargetType;  
        T result = default(T);  
        result = (T)CreateTypeByRegisterType(info, type);  
        return result;  
    }

    private object CreateObject(Type type)  
    {  
        ConstructorInfo\[\] ctorArray = type.GetConstructors();  
        ConstructorInfo ctor = null;  
        if (ctorArray.Count(c => c.IsDefined(typeof(InjectionConstructorAttribute), true)) > )  
        {  
            ctor = ctorArray.FirstOrDefault(c => c.IsDefined(typeof(InjectionConstructorAttribute), true));  
        }  
        else  
        {  
            ctor = ctorArray.OrderByDescending(c => c.GetParameters().Length).FirstOrDefault();  
        }  
        List<object> paraList = new List<object>();  
        foreach (var parameter in ctor.GetParameters())  
        {  
            Type paraType = parameter.ParameterType;  
            RegisterInfo info = ContainerDictionary\[paraType.FullName\];  
            Type targetType = info.TargetType;  
            object para = null;  
            para = CreateTypeByRegisterType(info, targetType);  
            //递归：隐形的跳出条件，就是GetParameters结果为空，targetType拥有无参数构造函数  
            paraList.Add(para);  
        }  
        object objType = Activator.CreateInstance(type, paraList.ToArray());  
        //属性注入  
        var properties = type.GetProperties()  
                             .Where(p => p.IsDefined(typeof(DependencyAttribute), false)).ToList();  
        foreach (var item in properties)  
        {  
            var customAttributes =  
                item.GetCustomAttributes(typeof(DependencyAttribute), false) as DependencyAttribute\[\];  
            if (customAttributes != null)  
            {  
                Type t = item.PropertyType;  
                RegisterInfo info = ContainerDictionary\[t.FullName\];  
                info.LifeTime = customAttributes.FirstOrDefault().\_lifeTimeType;  
                var value = CreateObject(info.TargetType);  
                item.SetValue(objType, value);  
            }  
        }  
        //字段注入  
        var filds = type.GetFields().Where(f => f.IsDefined(typeof(DependencyAttribute), false)).ToList();  
        foreach (var fild in filds)  
        {  
            var attribute = fild.GetCustomAttribute(typeof(DependencyAttribute)) as DependencyAttribute;  
            if (attribute != null)  
            {  
                Type t = fild.DeclaringType;  
                RegisterInfo info = ContainerDictionary\[t.FullName\];  
                info.LifeTime = attribute.\_lifeTimeType;  
                var value = CreateObject(info.TargetType);  
                fild.SetValue(objType, value);  
            }  
        }

        //方法注入  
        var methods = type.GetMethods().Where(m => m.IsDefined(typeof(InjectionMethodAttribute), false)).ToList();  
        List<object> paramrterList = new List<object>();  
        foreach (var item in methods)  
        {  
            var attribute = item.GetCustomAttribute(typeof(InjectionMethodAttribute)) as InjectionMethodAttribute;  
            if (attribute != null)  
            {  
                var parameters = item.GetParameters();  
                foreach (var parameter in parameters)  
                {  
                    var paraType = parameter.ParameterType;  
                    RegisterInfo info = ContainerDictionary\[paraType.FullName\];  
                    Type targetType = info.TargetType;  
                    object para = CreateTypeByRegisterType(info, targetType);  
                    //递归：隐形的跳出条件，就是GetParameters结果为空，targetType拥有无参数构造函数  
                    paramrterList.Add(para);  
                }  
                item.Invoke(objType, paramrterList.ToArray());  
            }  
        }  
        return objType;  
    }

    private static readonly object obj = new object();

    /// <summary>  
    /// 根据注入类别创建对象  
    /// </summary>  
    /// <param name="info"></param>  
    /// <param name="targetType"></param>  
    /// <returns></returns>  
    private object CreateTypeByRegisterType(RegisterInfo info, Type targetType)  
    {  
        object para = null;  
        switch (info.LifeTime)  
        {  
            case LifeTimeType.Transient:  
                para = this.CreateObject(targetType);  
                break;  
            case LifeTimeType.Singleton:  
                //需要线程安全 双if+lock  
                if (para == null)  
                {  
                    lock (obj)  
                    {  
                        if (this.TypeObjectDictionary.ContainsKey(targetType))  
                        {  
                            para = this.TypeObjectDictionary\[targetType\];  
                        }  
                        else  
                        {  
                            if (para == null)  
                            {  
                                para = this.CreateObject(targetType);  
                                this.TypeObjectDictionary\[targetType\] = para;  
                            }  
                        }

                    }  
                }  
                break;  
            case LifeTimeType.PerThread:  
                //线程单例：线程槽，把数据存在这里  
                {  
                    string key = targetType.FullName;  
                    object oValue = CallContext.GetData(key);  
                    if (oValue == null)  
                    {  
                        para = this.CreateObject(targetType);  
                        CallContext.SetData(key, para);  
                    }  
                    else  
                    {  
                        para = oValue;  
                    }  
                }  
                break;  
            default:  
                throw new Exception("wrong LifeTime");  
        }  
        return para;  
    }

}

以上代码经过测试，可以使用。

public interface IImitateScene
{
void DoSomeThing();
}

public class ImitateScene: IImitateScene  
{  
    private IUserService userService;

    public ImitateScene(IUserService \_userService)  
    {  
        this.userService = \_userService;  
    }

    \[Dependency(LifeTimeType.Transient)\]  
    public IShopService ShopService { get; set; }

    public IStoreService StoreService { get; set; }

    \[InjectionMethod(LifeTimeType.Transient)\]  
    public void SetStoreService(IStoreService \_storeService)  
    {  
        this.StoreService = \_storeService;  
    }

    public void DoSomeThing()  
    {  
        this.userService.DoSomeThing();  
        this.StoreService.DoSomeThing();  
        this.ShopService.DoSomeThing();  
    }  
}

附上项目图，项目结构只为了测试，未做过设计，嘿嘿

测试结果：

基本代码就在这里了，还有很多功能未完善，后续有时间会努力研究完善它，造造轮子。