Configuration 清洁垃圾自动传真配置？

只是想知道是否有一个很好的方法来找出Autofac模块中的垃圾配置。我的意思是，随着大量重构的完成，项目变得越来越大，可能会有一些类变得未使用，但它们仍然在模块配置中注册。这些垃圾类可能被整形器隐藏，因为配置代码中使用了整形器。我只是不想查看配置代码中的每一行，以确定是否不再使用接口或类，然后手动删除它们

---

如果有一个好主意，自动找出所有这些垃圾，那就太好了。请把你的精彩想法说出来。谢谢。

您可以从container.ComponentRegistry.registrations属性获取所有注册。然后，您可以将代码附加到所有注册的激活生存期事件，以便获得所有已解析的类型。然后，您应该运行/测试您拥有的所有功能（或解析所有控制器），以便解析所有依赖项。然后可以比较已注册的类型和已解析的类型。请注意运行此代码时出现的问题，如性能影响、多线程问题。下面是一个简单的工作示例，请随意改进：

class Program
{
    internal class MyUsedClass : IMyUsedClass {}
    internal interface IMyUsedClass {}
    internal class MyUsedClass2 {}
    internal class MyNotUsedClass {}

    static void Main(string[] args)
    {
        // register your modules and types
        var builder = new ContainerBuilder();
        builder.RegisterType<MyUsedClass>().As<IMyUsedClass>();
        builder.RegisterType<MyUsedClass2>();
        builder.RegisterType<MyNotUsedClass>();

        using (var container = builder.Build())
        {
            // get all registered types
            var typesRegistered = new HashSet<Type>();
            foreach (var type in container.ComponentRegistry.Registrations.SelectMany(r => r.Services.Select(s => (s as IServiceWithType).ServiceType)))
            {
                typesRegistered.Add(type);
            }


            // get all resolved types via lifetime events
            // please be aware of performance impact, multithreading, etc
            var typesResolved = new HashSet<Type>();
            foreach (var registration in container.ComponentRegistry.Registrations)
            {
                registration.Activating +=
                    (sender, eventArgs) =>
                    {
                        foreach (var type in eventArgs.Component.Services.Select(s => (s as IServiceWithType).ServiceType))
                        {
                            typesResolved.Add(type);
                        }
                    };
            }

            // application is working
            container.Resolve<IMyUsedClass>();
            container.Resolve<MyUsedClass2>();

            // Types that are registered but were not resolved.
            foreach (var type in typesRegistered.Where(type => !typesResolved.Contains(type)))
            {
                Console.WriteLine("Registered But Not Resolved: {0}",type);
            }
        }

        Console.ReadKey();
    }
}

类程序
{
内部类MyUsedClass:IMyUsedClass{}
内部接口IMyUsedClass{}
内部类MyUsedClass2{}
内部类MyNotUsedClass{}
静态void Main（字符串[]参数）
{
//注册你的模块和类型
var builder=new ContainerBuilder（）；
builder.RegisterType（）.As（）；
RegisterType（）；
RegisterType（）；
使用（var container=builder.Build（））
{
//获取所有注册类型
var typesRegistered=new HashSet（）；
foreach（container.ComponentRegistry.Registrations.SelectMany中的变量类型（r=>r.Services.Select（s=>（s作为IServiceWithType.ServiceType）））
{
类型注册。添加（类型）；
}
//通过生存期事件获取所有已解析的类型
//请注意性能影响、多线程等
var typesResolved=new HashSet（）；
foreach（容器中的var注册.ComponentRegistry.Registrations）
{
注册，激活+=
（发送方，事件参数）=>
{
foreach（eventArgs.Component.Services.Select中的变量类型（s=>（s作为IServiceWithType.ServiceType））
{
类型解析。添加（类型）；
}
};
}
//应用程序正在运行
container.Resolve（）；
container.Resolve（）；
//已注册但未解析的类型。
foreach（typesRegistered.Where（type=>！typesResolved.Contains（type））中的变量类型）
{
WriteLine（“已注册但未解析：{0}”，类型）；
}
}
Console.ReadKey（）；
}
}

您可以从container.ComponentRegistry.registrations属性获取所有注册。然后，您可以将代码附加到所有注册的激活生存期事件，以便获得所有已解析的类型。然后，您应该运行/测试您拥有的所有功能（或解析所有控制器），以便解析所有依赖项。然后可以比较已注册的类型和已解析的类型。请注意运行此代码时出现的问题，如性能影响、多线程问题。下面是一个简单的工作示例，请随意改进：

class Program
{
    internal class MyUsedClass : IMyUsedClass {}
    internal interface IMyUsedClass {}
    internal class MyUsedClass2 {}
    internal class MyNotUsedClass {}

    static void Main(string[] args)
    {
        // register your modules and types
        var builder = new ContainerBuilder();
        builder.RegisterType<MyUsedClass>().As<IMyUsedClass>();
        builder.RegisterType<MyUsedClass2>();
        builder.RegisterType<MyNotUsedClass>();

        using (var container = builder.Build())
        {
            // get all registered types
            var typesRegistered = new HashSet<Type>();
            foreach (var type in container.ComponentRegistry.Registrations.SelectMany(r => r.Services.Select(s => (s as IServiceWithType).ServiceType)))
            {
                typesRegistered.Add(type);
            }


            // get all resolved types via lifetime events
            // please be aware of performance impact, multithreading, etc
            var typesResolved = new HashSet<Type>();
            foreach (var registration in container.ComponentRegistry.Registrations)
            {
                registration.Activating +=
                    (sender, eventArgs) =>
                    {
                        foreach (var type in eventArgs.Component.Services.Select(s => (s as IServiceWithType).ServiceType))
                        {
                            typesResolved.Add(type);
                        }
                    };
            }

            // application is working
            container.Resolve<IMyUsedClass>();
            container.Resolve<MyUsedClass2>();

            // Types that are registered but were not resolved.
            foreach (var type in typesRegistered.Where(type => !typesResolved.Contains(type)))
            {
                Console.WriteLine("Registered But Not Resolved: {0}",type);
            }
        }

        Console.ReadKey();
    }
}

类程序
{
内部类MyUsedClass:IMyUsedClass{}
内部接口IMyUsedClass{}
内部类MyUsedClass2{}
内部类MyNotUsedClass{}
静态void Main（字符串[]参数）
{
//注册你的模块和类型
var builder=new ContainerBuilder（）；
builder.RegisterType（）.As（）；
RegisterType（）；
RegisterType（）；
使用（var container=builder.Build（））
{
//获取所有注册类型
var typesRegistered=new HashSet（）；
foreach（container.ComponentRegistry.Registrations.SelectMany中的变量类型（r=>r.Services.Select（s=>（s作为IServiceWithType.ServiceType）））
{
类型注册。添加（类型）；
}
//通过生存期事件获取所有已解析的类型
//请注意性能影响、多线程等
var typesResolved=new HashSet（）；
foreach（容器中的var注册.ComponentRegistry.Registrations）
{
注册，激活+=
（发送方，事件参数）=>
{
foreach（eventArgs.Component.Services.Select中的变量类型（s=>（s作为IServiceWithType.ServiceType））
{
类型解析。添加（类型）；
}
};
}
//应用程序正在运行
container.Resolve（）；
container.Resolve（）；
//已注册但未解析的类型。
foreach（typesRegistered.Where（type=>！typesResolved.Contains（type））中的变量类型）
{
WriteLine（“已注册但未解析：{0}”，类型）；
}
}
Console.ReadKey（）；
}
}

谢谢您的回答。不过，我认为这个问题仍然存在。在项目的某个阶段，测试代码中可能有“container.Resolve（）”。在从生产代码中删除MyNotUsedClass后，测试仍将通过。@bigbearzhu因此运行测试以获取所有已使用的注册不适合您，请尝试其他方法。感谢您的帮助