动手造轮子：实现一个简单的依赖注入(一)

最新推荐文章于 2023-03-18 19:07:26 发布
最新推荐文章于 2023-03-18 19:07:26 发布
阅读量106 收藏
点赞数
分类专栏： 技术
原文链接：https://www.colorgg.com
版权

动手造轮子：实现一个简单的依赖注入(一)

Intro

在上一篇文章中主要介绍了一下要做的依赖注入的整体设计和大概编程体验，这篇文章要开始写代码了，开始实现自己的依赖注入框架。

类图

首先来温习一下上次提到的 UML 类图

服务生命周期

服务生命周期定义：

public enum ServiceLifetime : sbyte
{
    /// <summary>
    /// Specifies that a single instance of the service will be created.
    /// </summary>
    Singleton = 0,

    /// <summary>
    /// Specifies that a new instance of the service will be created for each scope.
    /// </summary>
    Scoped = 1,

    /// <summary>
    /// Specifies that a new instance of the service will be created every time it is requested.
    /// </summary>
    Transient = 2,
}

服务定义

服务注册定义：

public class ServiceDefinition
{
    // 服务生命周期
    public ServiceLifetime ServiceLifetime { get; }
    // 实现类型
    public Type ImplementType { get; }
    // 服务类型
    public Type ServiceType { get; }
    // 实现实例
    public object ImplementationInstance { get; }
    // 实现工厂
    public Func<IServiceProvider, object> ImplementationFactory { get; }

    // 获取真实的实现类型
    public Type GetImplementType()
    {
        if (ImplementationInstance != null)
            return ImplementationInstance.GetType();

        if (ImplementationFactory != null)
            return ImplementationFactory.Method.DeclaringType;

        if (ImplementType != null)
            return ImplementType;

        return ServiceType;
    }

    public ServiceDefinition(object instance, Type serviceType)
    {
        ImplementationInstance = instance;
        ServiceType = serviceType;
        ServiceLifetime = ServiceLifetime.Singleton;
    }

    public ServiceDefinition(Type serviceType, ServiceLifetime serviceLifetime) : this(serviceType, serviceType, serviceLifetime)
    {
    }

    public ServiceDefinition(Type serviceType, Type implementType, ServiceLifetime serviceLifetime)
    {
        ServiceType = serviceType;
        ImplementType = implementType ?? serviceType;
        ServiceLifetime = serviceLifetime;
    }

    public ServiceDefinition(Type serviceType, Func<IServiceProvider, object> factory, ServiceLifetime serviceLifetime)
    {
        ServiceType = serviceType;
        ImplementationFactory = factory;
        ServiceLifetime = serviceLifetime;
    }
}

为了使用起来更方便添加了一些静态方法

public static ServiceDefinition Singleton<TService>(Func<IServiceProvider, object> factory)
{
    return new ServiceDefinition(typeof(TService), factory, ServiceLifetime.Singleton);
}

public static ServiceDefinition Scoped<TService>(Func<IServiceProvider, object> factory)
{
    return new ServiceDefinition(typeof(TService), factory, ServiceLifetime.Scoped);
}

public static ServiceDefinition Transient<TService>(Func<IServiceProvider, object> factory)
{
    return new ServiceDefinition(typeof(TService), factory, ServiceLifetime.Transient);
}

public static ServiceDefinition Singleton<TService>()
{
    return new ServiceDefinition(typeof(TService), ServiceLifetime.Singleton);
}

public static ServiceDefinition Scoped<TService>()
{
    return new ServiceDefinition(typeof(TService), ServiceLifetime.Scoped);
}

public static ServiceDefinition Transient<TService>()
{
    return new ServiceDefinition(typeof(TService), ServiceLifetime.Transient);
}

public static ServiceDefinition Singleton<TService, TServiceImplement>() where TServiceImplement : TService
{
    return new ServiceDefinition(typeof(TService), typeof(TServiceImplement), ServiceLifetime.Singleton);
}

public static ServiceDefinition Scoped<TService, TServiceImplement>() where TServiceImplement : TService
{
    return new ServiceDefinition(typeof(TService), typeof(TServiceImplement), ServiceLifetime.Scoped);
}

public static ServiceDefinition Transient<TService, TServiceImplement>() where TServiceImplement : TService
{
    return new ServiceDefinition(typeof(TService), typeof(TServiceImplement), ServiceLifetime.Transient);
}

ServiceContainer

serviceContainer v1

public class ServiceContainer : IServiceContainer
{
    internal readonly List<ServiceDefinition> _services;

    private readonly ConcurrentDictionary<Type, object> _singletonInstances;

    private readonly ConcurrentDictionary<Type, object> _scopedInstances;
    
    private readonly List<object> _transientDisposables = new List<object>();

    private readonly bool _isRootScope;

    public ServiceContainer()
    {
        _isRootScope = true;
        _singletonInstances = new ConcurrentDictionary<Type, object>();
        _services = new List<ServiceDefinition>();
    }

    internal ServiceContainer(ServiceContainer serviceContainer)
    {
        _isRootScope = false;
        _singletonInstances = serviceContainer._singletonInstances;
        _services = serviceContainer._services;
        _scopedInstances = new ConcurrentDictionary<Type, object>();
    }

    public void Add(ServiceDefinition item)
    {
        _services.Add(item);
    }

    public IServiceContainer CreateScope()
    {
        return new ServiceContainer(this);
    }

    private bool _disposed;

    public void Dispose()
    {
        if (_disposed)
        {
            return;
        }

        if (_isRootScope)
        {
            lock (_singletonInstances)
            {
                if (_disposed)
                {
                    return;
                }

                _disposed = true;
                foreach (var instance in _singletonInstances.Values)
                {
                    (instance as IDisposable)?.Dispose();
                }

                foreach (var o in _transientDisposables)
                {
                    (o as IDisposable)?.Dispose();
                }
            }
        }
        else
        {
            lock (_scopedInstances)
            {
                if (_disposed)
                {
                    return;
                }

                _disposed = true;
                foreach (var instance in _scopedInstances.Values)
                {
                    (instance as IDisposable)?.Dispose();
                }

                foreach (var o in _transientDisposables)
                {
                    (o as IDisposable)?.Dispose();
                }
            }
        }
    }

    private object GetServiceInstance(Type serviceType, ServiceDefinition serviceDefinition)
    {
        if (serviceDefinition.ImplementationInstance != null)
            return serviceDefinition.ImplementationInstance;

        if (serviceDefinition.ImplementationFactory != null)
            return serviceDefinition.ImplementationFactory.Invoke(this);

        var implementType = (serviceDefinition.ImplementType ?? serviceType);

        if (implementType.IsInterface || implementType.IsAbstract)
        {
            throw new InvalidOperationException($"invalid service registered, serviceType: {serviceType.FullName}, implementType: {serviceDefinition.ImplementType}");
        }

        var ctorInfos = implementType.GetConstructors(BindingFlags.Instance | BindingFlags.Public);
        if (ctorInfos.Length == 0)
        {
            throw new InvalidOperationException($"service {serviceType.FullName} does not have any public constructors");
        }

        ConstructorInfo ctor;
        if (ctorInfos.Length == 1)
        {
            ctor = ctorInfos[0];
        }
        else
        {
            // try find best ctor
            ctor = ctorInfos
                .OrderBy(_ => _.GetParameters().Length)
                .First();
        }

        var parameters = ctor.GetParameters();
        if (parameters.Length == 0)
        {
            // TODO: cache New Func
            return Expression.Lambda<Func<object>>(Expression.New(ctor)).Compile().Invoke();
        }
        else
        {
            var ctorParams = new object[parameters.Length];
            for (var index = 0; index < parameters.Length; index++)
            {
                var parameter = parameters[index];
                var param = GetService(parameter.ParameterType);
                if (param == null && parameter.HasDefaultValue)
                {
                    param = parameter.DefaultValue;
                }

                ctorParams[index] = param;
            }
            return Expression.Lambda<Func<object>>(Expression.New(ctor, ctorParams.Select(Expression.Constant))).Compile().Invoke();
        }
    }

    public object GetService(Type serviceType)
    {
        var serviceDefinition = _services.LastOrDefault(_ => _.ServiceType == serviceType);
        if (null == serviceDefinition)
        {
            return null;
        }

        if (_isRootScope && serviceDefinition.ServiceLifetime == ServiceLifetime.Scoped)
        {
            throw new InvalidOperationException($"can not get scope service from the root scope, serviceType: {serviceType.FullName}");
        }

        if (serviceDefinition.ServiceLifetime == ServiceLifetime.Singleton)
        {
            var svc = _singletonInstances.GetOrAdd(serviceType, (t) => GetServiceInstance(t, serviceDefinition));
            return svc;
        }
        else if (serviceDefinition.ServiceLifetime == ServiceLifetime.Scoped)
        {
            var svc = _scopedInstances.GetOrAdd(serviceType, (t) => GetServiceInstance(t, serviceDefinition));
            return svc;
        }
        else
        {
            var svc = GetServiceInstance(serviceType, serviceDefinition);
            if (svc is IDisposable)
            {
                _transientDisposables.Add(svc);
            }
            return svc;
        }
    }
}

为了使得服务注册更加方便，可以写一些扩展方法来方便注册：

public static IServiceContainer AddSingleton<TService>([NotNull]this IServiceContainer serviceContainer, [NotNull]TService service)
{
    serviceContainer.Add(new ServiceDefinition(service, typeof(TService)));
    return serviceContainer;
}

public static IServiceContainer AddSingleton([NotNull]this IServiceContainer serviceContainer, [NotNull]Type serviceType)
{
    serviceContainer.Add(new ServiceDefinition(serviceType, ServiceLifetime.Singleton));
    return serviceContainer;
}

public static IServiceContainer AddSingleton([NotNull]this IServiceContainer serviceContainer, [NotNull]Type serviceType, [NotNull]Type implementType)
{
    serviceContainer.Add(new ServiceDefinition(serviceType, implementType, ServiceLifetime.Singleton));
    return serviceContainer;
}

public static IServiceContainer AddSingleton<TService>([NotNull]this IServiceContainer serviceContainer, [NotNull]Func<IServiceProvider, object> func)
{
    serviceContainer.Add(ServiceDefinition.Singleton<TService>(func));
    return serviceContainer;
}


public static IServiceContainer AddSingleton<TService>([NotNull]this IServiceContainer serviceContainer)
{
    serviceContainer.Add(ServiceDefinition.Singleton<TService>());
    return serviceContainer;
}


public static IServiceContainer AddSingleton<TService, TServiceImplement>([NotNull]this IServiceContainer serviceContainer) where TServiceImplement : TService
{
    serviceContainer.Add(ServiceDefinition.Singleton<TService, TServiceImplement>());
    return serviceContainer;
}

public static IServiceContainer AddScoped([NotNull]this IServiceContainer serviceContainer, [NotNull]Type serviceType)
{
    serviceContainer.Add(new ServiceDefinition(serviceType, ServiceLifetime.Scoped));
    return serviceContainer;
}

public static IServiceContainer AddScoped([NotNull]this IServiceContainer serviceContainer, [NotNull]Type serviceType, [NotNull]Type implementType)
{
    serviceContainer.Add(new ServiceDefinition(serviceType, implementType, ServiceLifetime.Scoped));
    return serviceContainer;
}

public static IServiceContainer AddScoped<TService>([NotNull]this IServiceContainer serviceContainer, [NotNull]Func<IServiceProvider, object> func)
{
    serviceContainer.Add(ServiceDefinition.Scoped<TService>(func));
    return serviceContainer;
}


public static IServiceContainer AddScoped<TService>([NotNull]this IServiceContainer serviceContainer)
{
    serviceContainer.Add(ServiceDefinition.Scoped<TService>());
    return serviceContainer;
}


public static IServiceContainer AddScoped<TService, TServiceImplement>([NotNull]this IServiceContainer serviceContainer) where TServiceImplement : TService
{
    serviceContainer.Add(ServiceDefinition.Scoped<TService, TServiceImplement>());
    return serviceContainer;
}

public static IServiceContainer AddTransient([NotNull]this IServiceContainer serviceContainer, [NotNull]Type serviceType)
{
    serviceContainer.Add(new ServiceDefinition(serviceType, ServiceLifetime.Transient));
    return serviceContainer;
}

public static IServiceContainer AddTransient([NotNull]this IServiceContainer serviceContainer, [NotNull]Type serviceType, [NotNull]Type implementType)
{
    serviceContainer.Add(new ServiceDefinition(serviceType, implementType, ServiceLifetime.Transient));
    return serviceContainer;
}

public static IServiceContainer AddTransient<TService>([NotNull]this IServiceContainer serviceContainer, [NotNull]Func<IServiceProvider, object> func)
{
    serviceContainer.Add(ServiceDefinition.Transient<TService>(func));
    return serviceContainer;
}


public static IServiceContainer AddTransient<TService>([NotNull]this IServiceContainer serviceContainer)
{
    serviceContainer.Add(ServiceDefinition.Transient<TService>());
    return serviceContainer;
}


public static IServiceContainer AddTransient<TService, TServiceImplement>([NotNull]this IServiceContainer serviceContainer) where TServiceImplement : TService
{
    serviceContainer.Add(ServiceDefinition.Transient<TService, TServiceImplement>());
    return serviceContainer;
}

通过上面的代码就可以实现基本依赖注入了，但是从功能上来说，上面的代码只支持获取单个服务的实例，不支持注册一个接口的多个实现，获取接口的所有实现，为此对 ServiceContainer 中的 Instance 的 ConcurrentDictionary 的 Key 进行一下改造，使得可以能够以接口类型和实现类型联合作为 key，为此就有了第二版的 ServiceContainer

ServiceContainer v2

为此定义了一个 ServiceKey 的类型，请注意这里一定要重写 GetHashCode 方法：

private class ServiceKey : IEquatable<ServiceKey>
{
    public Type ServiceType { get; }

    public Type ImplementType { get; }

    public ServiceKey(Type serviceType, ServiceDefinition definition)
    {
        ServiceType = serviceType;
        ImplementType = definition.GetImplementType();
    }

    public bool Equals(ServiceKey other)
    {
        return ServiceType == other?.ServiceType && ImplementType == other?.ImplementType;
    }

    public override bool Equals(object obj)
    {
        return Equals((ServiceKey)obj);
    }

    public override int GetHashCode()
    {
        var key = $"{ServiceType.FullName}_{ImplementType.FullName}";
        return key.GetHashCode();
    }
}

第二版的 ServiceContainer :

public class ServiceContainer : IServiceContainer
{
    internal readonly ConcurrentBag<ServiceDefinition> _services;

    private readonly ConcurrentDictionary<ServiceKey, object> _singletonInstances;

    private readonly ConcurrentDictionary<ServiceKey, object> _scopedInstances;
    private ConcurrentBag<object> _transientDisposables = new ConcurrentBag<object>();

    private class ServiceKey : IEquatable<ServiceKey>
    {
        public Type ServiceType { get; }

        public Type ImplementType { get; }

        public ServiceKey(Type serviceType, ServiceDefinition definition)
        {
            ServiceType = serviceType;
            ImplementType = definition.GetImplementType();
        }

        public bool Equals(ServiceKey other)
        {
            return ServiceType == other?.ServiceType && ImplementType == other?.ImplementType;
        }

        public override bool Equals(object obj)
        {
            return Equals((ServiceKey)obj);
        }

        public override int GetHashCode()
        {
            var key = $"{ServiceType.FullName}_{ImplementType.FullName}";
            return key.GetHashCode();
        }
    }

    private readonly bool _isRootScope;

    public ServiceContainer()
    {
        _isRootScope = true;
        _singletonInstances = new ConcurrentDictionary<ServiceKey, object>();
        _services = new ConcurrentBag<ServiceDefinition>();
    }

    private ServiceContainer(ServiceContainer serviceContainer)
    {
        _isRootScope = false;
        _singletonInstances = serviceContainer._singletonInstances;
        _services = serviceContainer._services;
        _scopedInstances = new ConcurrentDictionary<ServiceKey, object>();
    }

    public IServiceContainer Add(ServiceDefinition item)
    {
        if (_disposed)
        {
            throw new InvalidOperationException("the service container had been disposed");
        }
        if (_services.Any(_ => _.ServiceType == item.ServiceType && _.GetImplementType() == item.GetImplementType()))
        {
            return this;
        }

        _services.Add(item);
        return this;
    }

    public IServiceContainer TryAdd(ServiceDefinition item)
    {
        if (_disposed)
        {
            throw new InvalidOperationException("the service container had been disposed");
        }
        if (_services.Any(_ => _.ServiceType == item.ServiceType))
        {
            return this;
        }
        _services.Add(item);
        return this;
    }

    public IServiceContainer CreateScope()
    {
        return new ServiceContainer(this);
    }

    private bool _disposed;

    public void Dispose()
    {
        if (_disposed)
        {
            return;
        }

        if (_isRootScope)
        {
            lock (_singletonInstances)
            {
                if (_disposed)
                {
                    return;
                }

                _disposed = true;
                foreach (var instance in _singletonInstances.Values)
                {
                    (instance as IDisposable)?.Dispose();
                }

                foreach (var o in _transientDisposables)
                {
                    (o as IDisposable)?.Dispose();
                }

                _singletonInstances.Clear();
                _transientDisposables = null;
            }
        }
        else
        {
            lock (_scopedInstances)
            {
                if (_disposed)
                {
                    return;
                }

                _disposed = true;
                foreach (var instance in _scopedInstances.Values)
                {
                    (instance as IDisposable)?.Dispose();
                }

                foreach (var o in _transientDisposables)
                {
                    (o as IDisposable)?.Dispose();
                }

                _scopedInstances.Clear();
                _transientDisposables = null;
            }
        }
    }

    private object GetServiceInstance(Type serviceType, ServiceDefinition serviceDefinition)
    {
        if (serviceDefinition.ImplementationInstance != null)
            return serviceDefinition.ImplementationInstance;

        if (serviceDefinition.ImplementationFactory != null)
            return serviceDefinition.ImplementationFactory.Invoke(this);

        var implementType = (serviceDefinition.ImplementType ?? serviceType);

        if (implementType.IsInterface || implementType.IsAbstract)
        {
            throw new InvalidOperationException($"invalid service registered, serviceType: {serviceType.FullName}, implementType: {serviceDefinition.ImplementType}");
        }

        if (implementType.IsGenericType)
        {
            implementType = implementType.MakeGenericType(serviceType.GetGenericArguments());
        }

        var ctorInfos = implementType.GetConstructors(BindingFlags.Instance | BindingFlags.Public);
        if (ctorInfos.Length == 0)
        {
            throw new InvalidOperationException($"service {serviceType.FullName} does not have any public constructors");
        }

        ConstructorInfo ctor;
        if (ctorInfos.Length == 1)
        {
            ctor = ctorInfos[0];
        }
        else
        {
            // TODO: try find best ctor
            ctor = ctorInfos
                .OrderBy(_ => _.GetParameters().Length)
                .First();
        }

        var parameters = ctor.GetParameters();
        if (parameters.Length == 0)
        {
            // TODO: cache New Func
            return Expression.Lambda<Func<object>>(Expression.New(ctor)).Compile().Invoke();
        }
        else
        {
            var ctorParams = new object[parameters.Length];
            for (var index = 0; index < parameters.Length; index++)
            {
                var parameter = parameters[index];
                var param = GetService(parameter.ParameterType);
                if (param == null && parameter.HasDefaultValue)
                {
                    param = parameter.DefaultValue;
                }

                ctorParams[index] = param;
            }
            return Expression.Lambda<Func<object>>(Expression.New(ctor, ctorParams.Select(Expression.Constant))).Compile().Invoke();
        }
    }

    public object GetService(Type serviceType)
    {
        if (_disposed)
        {
            throw new InvalidOperationException($"can not get scope service from a disposed scope, serviceType: {serviceType.FullName}");
        }

        var serviceDefinition = _services.LastOrDefault(_ => _.ServiceType == serviceType);
        if (null == serviceDefinition)
        {
            if (serviceType.IsGenericType)
            {
                var genericType = serviceType.GetGenericTypeDefinition();
                serviceDefinition = _services.LastOrDefault(_ => _.ServiceType == genericType);
                if (null == serviceDefinition)
                {
                    var innerServiceType = serviceType.GetGenericArguments().First();
                    if (typeof(IEnumerable<>).MakeGenericType(innerServiceType)
                        .IsAssignableFrom(serviceType))
                    {
                        var innerRegType = innerServiceType;
                        if (innerServiceType.IsGenericType)
                        {
                            innerRegType = innerServiceType.GetGenericTypeDefinition();
                        }
                        //
                        var list = new List<object>(4);
                        foreach (var def in _services.Where(_ => _.ServiceType == innerRegType))
                        {
                            object svc;
                            if (def.ServiceLifetime == ServiceLifetime.Singleton)
                            {
                                svc = _singletonInstances.GetOrAdd(new ServiceKey(innerServiceType, def), (t) => GetServiceInstance(innerServiceType, def));
                            }
                            else if (def.ServiceLifetime == ServiceLifetime.Scoped)
                            {
                                svc = _scopedInstances.GetOrAdd(new ServiceKey(innerServiceType, def), (t) => GetServiceInstance(innerServiceType, def));
                            }
                            else
                            {
                                svc = GetServiceInstance(innerServiceType, def);
                                if (svc is IDisposable)
                                {
                                    _transientDisposables.Add(svc);
                                }
                            }
                            if (null != svc)
                            {
                                list.Add(svc);
                            }
                        }

                        var methodInfo = typeof(Enumerable)
                            .GetMethod("Cast", BindingFlags.Static | BindingFlags.Public);
                        if (methodInfo != null)
                        {
                            var genericMethod = methodInfo.MakeGenericMethod(innerServiceType);
                            var castedValue = genericMethod.Invoke(null, new object[] { list });
                            if (typeof(IEnumerable<>).MakeGenericType(innerServiceType) == serviceType)
                            {
                                return castedValue;
                            }
                            var toArrayMethod = typeof(Enumerable).GetMethod("ToArray", BindingFlags.Static | BindingFlags.Public)
                                .MakeGenericMethod(innerServiceType);

                            return toArrayMethod.Invoke(null, new object[] { castedValue });
                        }
                        return list;
                    }

                    return null;
                }
            }
            else
            {
                return null;
            }
        }

        if (_isRootScope && serviceDefinition.ServiceLifetime == ServiceLifetime.Scoped)
        {
            throw new InvalidOperationException($"can not get scope service from the root scope, serviceType: {serviceType.FullName}");
        }

        if (serviceDefinition.ServiceLifetime == ServiceLifetime.Singleton)
        {
            var svc = _singletonInstances.GetOrAdd(new ServiceKey(serviceType, serviceDefinition), (t) => GetServiceInstance(t.ServiceType, serviceDefinition));
            return svc;
        }
        else if (serviceDefinition.ServiceLifetime == ServiceLifetime.Scoped)
        {
            var svc = _scopedInstances.GetOrAdd(new ServiceKey(serviceType, serviceDefinition), (t) => GetServiceInstance(t.ServiceType, serviceDefinition));
            return svc;
        }
        else
        {
            var svc = GetServiceInstance(serviceType, serviceDefinition);
            if (svc is IDisposable)
            {
                _transientDisposables.Add(svc);
            }
            return svc;
        }
    }
}

这样我们就不仅支持了 IEnumerable<TService> 的注册，也支持 IReadOnlyList<TService>/ IReadOnlyCollection<TService> 的注册

因为 GetService 返回是 object , 不是强类型的，所以为了使用起来方便，定义了几个扩展方法，类似于微软的依赖注入框架里的 GetService<TService>()/GetServices<TService>()/GetRequiredService<TService>()

/// <summary>
/// ResolveService
/// </summary>
/// <typeparam name="TService">TService</typeparam>
/// <param name="serviceProvider">serviceProvider</param>
/// <returns></returns>
public static TService ResolveService<TService>([NotNull]this IServiceProvider serviceProvider)
    => (TService)serviceProvider.GetService(typeof(TService));

/// <summary>
/// ResolveRequiredService
/// throw exception if can not get a service instance
/// </summary>
/// <typeparam name="TService">TService</typeparam>
/// <param name="serviceProvider">serviceProvider</param>
/// <returns></returns>
public static TService ResolveRequiredService<TService>([NotNull] this IServiceProvider serviceProvider)
{
    var serviceType = typeof(TService);
    var svc = serviceProvider.GetService(serviceType);
    if (null == svc)
    {
        throw new InvalidOperationException($"service had not been registered, serviceType: {serviceType}");
    }
    return (TService)svc;
}

/// <summary>
/// Resolve services
/// </summary>
/// <typeparam name="TService">TService</typeparam>
/// <param name="serviceProvider">serviceProvider</param>
/// <returns></returns>
public static IEnumerable<TService> ResolveServices<TService>([NotNull]this IServiceProvider serviceProvider)
    => serviceProvider.ResolveService<IEnumerable<TService>>();

More

后面还更新了一版，主要优化性能，目前来说还不太满意，暂时这里先不提了

Reference

深蓝旭
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
.Net Core DI依赖注入：一个接口注入多个实现类
foreverhot1019的博客
11-17 1758
方式一、默认就可以注入多个实现类 例如接口IShow，注入ShowA和ShowB两个实现类： services.AddTransient<IShow, ShowA>(); services.AddTransient<IShow, ShowB>(); 获取的时候默认是获取到最后一个，如下所示： 可以使用"IEnumerable<IShow> showList" 的方式来获取所有注入的实现类，如下所示： 方式二、使用注入方法”Ad..
工厂方法（Factory Method）模式
旅行人生
10-13 1772
<!--function ContentSize(size){ var obj=document.all.BodyLabel; obj.style.fontSize=size+"px";}--> Flash("pic/aspsky.swf",668,105);加入收藏 联系我们 网站搜索 <!--linkset[0]=new Arra
SQL注入之获取数据库用户表数据
qq_59099375的博客
03-18 1280
SQL注入获取数据库数据
waf绕过总结之权限控制代码混淆及行为造轮子与sql注入绕过
m0_61786761的博客
09-01 528
sqlmap -u 'https://' --proxy="代理" --tamper=rdog.py --user-agent="mozilla15.0....."$b=(base64_decode($_POST['z']);用代理过cc防护，用自定义规则绕过注入代码的防护，用自定义user-agent头绕过检测防护。--random-agent 会随机产生user-agent头。解释：--tamper=rdog.py 注入语句payload的替换绕过。
sql注入
qq_27818157的博客
03-31 99
![]https://img-blog.csdnimg.cn/e3dd5020146344388030c341f2df9229.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA6Ieq6L2s55qE6L2u5a2Q,size_20,color_FFFFFF,t_70,g_se,x_16)
【Unity造轮子】实现一个类csgo的武器轮盘功能源码
07-31
# 【Unity造轮子】实现一个类csgo的武器轮盘功能 # 作者信息 姓名：向宇 博客：[https://xiangyu.blog.csdn.net/](https://xiangyu.blog.csdn.net/) # 文章说明： ...
重复造轮子：从0开始实现Vue数据绑定 | Shellming's Note1
08-03
在本文中，我们将深入探讨Vue.js框架中的数据绑定实现，这是现代前端开发中的一个重要概念。Vue.js通过利用JavaScript的`Object.defineProperty()`方法实现了数据绑定，使得数据的变更能够自动反映到视图上，同时也...
pandacms:造一个java cms的轮子，使用springboot
05-12
2.一开始，项目就分为后台管理和前台两部分 3.致力于内容发布网站的快速二次开发，技术简单，易扩展 项目规划 1.项目功能建构简单，只做基本功能; 2.以方便java程序员快速二次开发为目的。 组建规划： 1.栏目，分为...
d3ForceEasy:一个封装D3js force简单使用的轮子
05-10
一个封装D3js force力导向图 简单使用的轮子 依赖d3.js >v4.0.0 示例 代码在test文件中 使用方法 1.npm install d3_force_easy --save 2.引入配置和数据 import d3ForceEasy from 'd3_force_easy' import 'd3...
personVue一个模仿vue实现mvvm框架的简单轮子
08-12
而"personVue"则是一个旨在模仿Vue.js实现的轻量级MVVM框架。这个项目不仅为我们提供了一个学习Vue.js设计理念和机制的良好平台，还为开发者们提供了在实际应用中尝试和理解MVVM模式的机会。 MVVM（Model-View-...
造轮子是什么意思_封神之作！Github 84k+点赞！一个手把手教你造轮子的项目！...
weixin_39831239的博客
11-15 348
最近发现了一个教你如何造轮子的项目。「通过这个项目，你能学会如何创造自己的操作系统、编程语言、搜索引擎、框架，工具库……」「想要造轮子/提高编程能力或者需要项目经历的同学一定不要错过！」目前的话，这个项目已经在 Github 上收获了 84.2k star！造轮子是快速提高自己的编程能力的一个很实际的办法。在造轮子的过程中，你更多的会去考虑为什么要这样做，而不是怎么使用！比如说现在很火的 Dock...
基于c# 松耦合解决方案
u010465417的博客
04-18 1244
ImplementFactory 组件为自动扫描接口类型成员、自动为接口类型成员装配接口实例、面向接口操作数据源、实现接口实例加载拦截、接口方法调用拦截、以及对应的异常拦截提供了一个有效的解决方案。...........................
【译】Dependency Injection with Autofac
weixin_30243533的博客
06-23 165
先说下为什么翻译这篇文章，既定的方向是架构，然后为了学习架构就去学习一些架构模式、设计思想。 突然有一天发现依赖注入这种技能。为了使得架构可测试、易维护、可扩展，需要架构设计为松耦合类型，简单的说也就是解耦。为了解耦前面的人提出各种理论，主要思想是控制反转，而现在主流的主要是两个：依赖注入、服务定位（有篇英文文章特意讨论这种模式，最终的结论是否定的，乍看了一眼，没看懂） ...
深入浅出AOP（三）--WCF+AOP
邱慕夏 没有比脚更长的路，没有比人更高的山
06-29 3689
Spring.NET的IOC容器解决的，就是如何在应用中将类、对象和服务组合成应用程序的问题。IOC容器通过很正统的方式将分散的组件组合成完整的应用程序。Spring.NET框架就应运而生了。 框架图： 其中Spring.NET Core是整个矿机阿德基础，实现了依赖注入的功能。Spring.AOP为业务对象提供面向切面编程的支持。Spring.WEB提供了客户端。
(摘)使用 .NET Core 实现依赖关系注入
weixin_30569153的博客
10-08 577
为什么使用依赖关系注入？ 使用 .NET，通过 new 运算符（即，new MyService 或任何想要实例化的对象类型）调用构造函数即可轻松实现对象实例化。遗憾的是，此类调用会强制实施客户端（或应用程序）代码到已实例化对象的紧密耦合的连接（硬编码的引用），此外还会引用其程序集/NuGet 包。对于常见的 .NET 类型而言，这不是问题。然而，对于提供“服务”（如日志记录、配置、支付、通知或事...
Asp.net core 学习笔记--（1）依赖注入
瓦力的博客
07-12 1286
依赖注入依赖注入是一种软件的设计技巧，它主要解决的是类与类之间的耦合，这种设计技巧满足面向对象设计的”依赖倒置“原则：类与类之间不相互依赖，都要依赖接口。比如说controller中需要一个”AccessDataBase“的类型来进行对数据库的检索，那么我们可以将这个AccessDataBase类中实现的功能做成一个接口，然后让这个类去实现这个接口，然后，我们在需要这个类的地方（本例中是contro
解决WCF接口无法传递object参数的问题
Seize The Day
02-21 4563
  在某些场合中，我们需要提供以object为参数的方法。不过在WCF中，由于需要序列化与反序列化，因此它要求所有WCF传递的参数类型都是已知的，无法传递object这种未知类型。即使用了KnownType来标记自定义对象，也无法调用。以下代码无法正常执行： [DataContract] public class Product { [DataMem
大数据技术分享 Spark技术讲座 荷兰铁路的预测性维护 共32页.pdf
最新发布
07-18
大数据技术分享 Spark技术讲座 荷兰铁路的预测性维护 共32页.pdf
用SharpGL画一个轮子
09-02
### 回答1： 以下是使用SharpGL绘制一个轮子的示例代码。此代码假定您已经在Visual Studio中创建了一个SharpGL项目并配置了必要的引用。 ```csharp using SharpGL; public partial class Form1 : Form { private OpenGL gl; public Form1() { InitializeComponent(); gl = openGLControl.OpenGL; } private void openGLControl_OpenGLDraw(object sender, RenderEventArgs e) { gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT); gl.LoadIdentity(); gl.Begin(OpenGL.GL_TRIANGLE_FAN); gl.Color(0.7f, 0.7f, 0.7f); gl.Vertex(0.0, 0.0); for (double angle = 0.0; angle <= 2.0 * Math.PI; angle += Math.PI / 6.0) { double x = 0.5 * Math.Sin(angle); double y = 0.5 * Math.Cos(angle); gl.Vertex(x, y); } gl.End(); gl.Begin(OpenGL.GL_TRIANGLE_STRIP); gl.Color(0.5f, 0.5f, 0.5f); for (double angle = 0.0; angle <= 2.0 * Math.PI; angle += Math.PI / 6.0) { double x = 0.5 * Math.Sin(angle); double y = 0.5 * Math.Cos(angle); gl.Vertex(x, y, -0.25); gl.Vertex(x, y, 0.25); } gl.Vertex(0.0, 0.5, -0.25); gl.Vertex(0.0, 0.5, 0.25); gl.End(); } } ``` 这个示例使用了OpenGL的基本图元`GL_TRIANGLE_FAN`和`GL_TRIANGLE_STRIP`。它将一个圆形绘制在xy平面上，并将另一个圆柱体连接到圆形上，形成一个轮子。圆柱体由多个三角形带组成，其中每个三角形带都是一个矩形，包含相邻两个垂直圆柱体表面的四个顶点。`GL_TRIANGLE_FAN`用于绘制圆形，`GL_TRIANGLE_STRIP`用于绘制圆柱体。 ### 回答2： 使用SharpGL绘制一个轮子可以分为以下几个步骤： 1. 初始化OpenGL环境：创建OpenGL控件，并设置视口（Viewport），投影透视矩阵和模型视图矩阵。 2. 绘制外圆环：使用OpenGL的画线函数（glBegin()和glEnd()）绘制一个圆环，可以通过设置画线宽度和颜色来调整外圆环的样式。 3. 绘制内圆环：在外圆环的基础上，通过重新设置画线宽度和颜色，绘制一个半径较小的内圆环，形成轮子的中空效果。 4. 绘制轮辐：使用OpenGL的画线函数和旋转变换（glRotatef()）来绘制轮子的辐条。可以根据需要确定辐条的数量和角度，保证轮辐均匀分布在轮子的内外圆环之间。 5. 绘制轴承：为了增加轮子的真实感，可以绘制一个中间的轴承结构。可以使用OpenGL的绘制几何体函数（如glutWireTorus()）绘制一个环状结构。 6. 设置光照效果：可以使用OpenGL的光照函数（如glEnable(GL_LIGHTING)和glLightfv()）来为轮子添加适当的光照效果，增强其视觉效果。 7. 渲染轮子：在完成上述绘制步骤后，将所有图形元素组合起来，并在OpenGL控件上进行渲染，使轮子显示在屏幕上。 以上是使用SharpGL绘制一个轮子的简要步骤说明，具体的实现过程可以根据个人的需求和具体应用场景进行调整和优化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值