C# 如何使用Autofac将参数传递给构造函数

我肯定我错过了一些东西

我正在尝试将非DI代码转换为使用autofac。我有一个与硬件对话的类，它获取IP地址并抽象出接口。我有一个配置和操作硬件的高级类。我正在尝试解决如何在不传入DI容器副本的情况下实例化此类的多个副本

string FirstIP, SecondIP;
//Set values from config/user etc.

var FirstDevice = new HighLevelIF(new LowLevelIF(FirstIP));
var SecondDevice = new HighLevelIF(new LowLevelIF(SecondIP));

如果我只想要一个设备对象，那么在Autofac中连接起来似乎很简单。但要有两个地址不同的实例化，我只能在运行时知道，我看不到用autofac实现这一点的方法。我能看到的唯一方法是编写一个低级别的工厂，并将其传递给该方法，然后对其进行实例化

var FirstDevice = new HighLevelIFFactory.Create
                      (LowLevelIFFactory.Create
                      (FirstIP));

---

您可以使用

.WithParameter（）

方法

例如：

var builder = new ContainerBuilder();
builder.RegisterType<MyType>().As<IMyInterface>().WithParameter("paramName", "paramValue");

var builder=newcontainerbuilder（）；
builder.RegisterType（）.As（）.WithParameter（“paramName”、“paramValue”）；

编辑：重读你的问题。也许你想命名你的注册，然后得到合适的一个

您也可以这样做：

var builder = new ContainerBuilder();
builder.RegisterType<MyType>().Named<IMyInterface>("MyName");
builder.RegisterType<MyType>().Named<IMyInterface>("MyOtherName");

var container = builder.Build();

// later
container.ResolveNamed<IMyInterface>("MyName"); //gets MyName registration

var builder=newcontainerbuilder（）；
builder.RegisterType（）.Named（“MyName”）；
builder.RegisterType（）.Named（“MyOtherName”）；
var container=builder.Build（）；
//后来
容器名称（“MyName”）//获取MyName注册

您可以使用

.WithParameter（）

方法

例如：

var builder = new ContainerBuilder();
builder.RegisterType<MyType>().As<IMyInterface>().WithParameter("paramName", "paramValue");

var builder=newcontainerbuilder（）；
builder.RegisterType（）.As（）.WithParameter（“paramName”、“paramValue”）；

编辑：重读你的问题。也许你想命名你的注册，然后得到合适的一个

您也可以这样做：

var builder = new ContainerBuilder();
builder.RegisterType<MyType>().Named<IMyInterface>("MyName");
builder.RegisterType<MyType>().Named<IMyInterface>("MyOtherName");

var container = builder.Build();

// later
container.ResolveNamed<IMyInterface>("MyName"); //gets MyName registration

var builder=newcontainerbuilder（）；
builder.RegisterType（）.Named（“MyName”）；
builder.RegisterType（）.Named（“MyOtherName”）；
var container=builder.Build（）；
//后来
容器名称（“MyName”）//获取MyName注册

如果您需要按需解决这些IP，并且它们可能在运行时发生更改，那么这是您的最佳选择

如果您有一组在应用程序启动时加载的地址列表，并且您只需要以最有效的方式在这些实例之间切换，那么可以使用，这样可以避免将容器注入类中

战略示例

var builder = new ContainerBuilder();
// Register all instances of IDiscountCalculator
builder.RegisterAssemblyTypes(this.GetType().Assembly)
       .Where(t => typeof(IDiscountCalculator).IsAssignableFrom(t));
builder.Register<DiscountStrategy>().As<IDiscountStrategy>();
var container = builder.Build();
var strategy = container.Resolve<IDiscountStrategy>();

Console.WriteLine(strategy.GetDiscount("Regular", 10)); // 0
Console.WriteLine(strategy.GetDiscount("Normal", 10)); // 1
Console.WriteLine(strategy.GetDiscount("Special", 10)); // 5

var builder=newcontainerbuilder（）；
//注册IDiscountCalculator的所有实例
builder.RegisterAssemblyTypes（this.GetType（）.Assembly）
。式中（t=>typeof（IDiscountCalculator）.IsAssignableFrom（t））；
builder.Register（）.As（）；
var container=builder.Build（）；
var strategy=container.Resolve（）；
Console.WriteLine（strategy.get折扣（“常规”，10））；//0
Console.WriteLine（strategy.get折扣（“Normal”，10））；//1.
Console.WriteLine（strategy.get折扣（“特殊”，10））；//5.

这取决于以下类型：

public interface IDiscountStrategy 
{
    decimal GetDiscount(string userType, decimal orderTotal);
}

public class DiscountStrategy : IDiscountStrategy
{
    private readonly IEnumerable<IDiscountCalculator> _discountCalculators;

    public DiscountStrategy(IEnumerable<IDiscountCalculator> discountCalculators)
    {
        _discountCalculators = discountCalculators;
    }

    public decimal GetDiscount(string userType, decimal orderTotal)
    {
        var calculator = _discountCalculators.FirstOrDefault(x => x.AppliesTo(userType));
        if (calculator == null) return 0;
        return calculator.CalculateDiscount(orderTotal);
    }
}

public interface IDiscountCalculator
{
    bool AppliesTo(string userType);
    decimal CalculateDiscount(decimal orderTotal);
}

public class NormalUserDiscountCalculator : IDiscountCalculator
{
    public bool AppliesTo(string userType)
    {
        return userType == "Normal";
    }

    public decimal CalculateDiscount(decimal orderTotal)
    {
        return orderTotal * 0.1m;
    }
}

public class SpecialUserDiscountCalculator : IDiscountCalculator
{
    public bool AppliesTo(string userType)
    {
        return userType == "Special";
    }

    public decimal CalculateDiscount(decimal orderTotal)
    {
        return orderTotal * 0.5m;
    }
}

公共接口IDisconntStrategy
{
decimal GetDiscount（字符串用户类型，decimal orderTotal）；
}
公共课折扣策略：IDiscountStrategy
{
私有只读IEnumerable\u折扣计算器；
公共折扣策略（IEnumerable折扣计算器）
{
_折扣计算器=折扣计算器；
}
公共decimal GetDiscount（字符串用户类型，decimal orderTotal）
{
var calculator=\u折扣计算器.FirstOrDefault（x=>x.AppliesTo（userType））；
if（calculator==null）返回0；
返回calculator.CalculateDiscovery（orderTotal）；
}
}
公共接口IDisontCalculator
{
bool AppliesTo（字符串用户类型）；
十进制计算结果（十进制订单总数）；
}
公共类NormalUserDiscountCalculator:IDiscountCalculator
{
公共bool AppliesTo（字符串用户类型）
{
返回userType==“正常”；
}
公共十进制计算器查询（十进制顺序合计）
{
退货订单总数*0.1m；
}
}
公共类特殊计算器DiscountCalculator:IDiscountCalculator
{
公共bool AppliesTo（字符串用户类型）
{
返回userType==“特殊”；
}
公共十进制计算器查询（十进制顺序合计）
{
退货订单总额*0.5m；
}
}

---

请注意，使用

AppliesTo

方法也意味着您可以制定一种策略，选择多个应用于特定目的的实例，就像一个过滤器一样。

如果您需要按需解决这些IP，并且它们可能在运行时发生更改，这是您的最佳选择

如果您有一组在应用程序启动时加载的地址列表，并且您只需要以最有效的方式在这些实例之间切换，那么可以使用，这样可以避免将容器注入类中

战略示例

var builder = new ContainerBuilder();
// Register all instances of IDiscountCalculator
builder.RegisterAssemblyTypes(this.GetType().Assembly)
       .Where(t => typeof(IDiscountCalculator).IsAssignableFrom(t));
builder.Register<DiscountStrategy>().As<IDiscountStrategy>();
var container = builder.Build();
var strategy = container.Resolve<IDiscountStrategy>();

Console.WriteLine(strategy.GetDiscount("Regular", 10)); // 0
Console.WriteLine(strategy.GetDiscount("Normal", 10)); // 1
Console.WriteLine(strategy.GetDiscount("Special", 10)); // 5

var builder=newcontainerbuilder（）；
//注册IDiscountCalculator的所有实例
builder.RegisterAssemblyTypes（this.GetType（）.Assembly）
。式中（t=>typeof（IDiscountCalculator）.IsAssignableFrom（t））；
builder.Register（）.As（）；
var container=builder.Build（）；
var strategy=container.Resolve（）；
Console.WriteLine（strategy.get折扣（“常规”，10））；//0
Console.WriteLine（strategy.get折扣（“Normal”，10））；//1.
Console.WriteLine（strategy.get折扣（“特殊”，10））；//5.

这取决于以下类型：

public interface IDiscountStrategy 
{
    decimal GetDiscount(string userType, decimal orderTotal);
}

public class DiscountStrategy : IDiscountStrategy
{
    private readonly IEnumerable<IDiscountCalculator> _discountCalculators;

    public DiscountStrategy(IEnumerable<IDiscountCalculator> discountCalculators)
    {
        _discountCalculators = discountCalculators;
    }

    public decimal GetDiscount(string userType, decimal orderTotal)
    {
        var calculator = _discountCalculators.FirstOrDefault(x => x.AppliesTo(userType));
        if (calculator == null) return 0;
        return calculator.CalculateDiscount(orderTotal);
    }
}

public interface IDiscountCalculator
{
    bool AppliesTo(string userType);
    decimal CalculateDiscount(decimal orderTotal);
}

public class NormalUserDiscountCalculator : IDiscountCalculator
{
    public bool AppliesTo(string userType)
    {
        return userType == "Normal";
    }

    public decimal CalculateDiscount(decimal orderTotal)
    {
        return orderTotal * 0.1m;
    }
}

public class SpecialUserDiscountCalculator : IDiscountCalculator
{
    public bool AppliesTo(string userType)
    {
        return userType == "Special";
    }

    public decimal CalculateDiscount(decimal orderTotal)
    {
        return orderTotal * 0.5m;
    }
}

公共接口IDisconntStrategy
{
decimal GetDiscount（字符串用户类型，decimal orderTotal）；
}
公共课折扣策略：IDiscountStrategy
{
私有只读IEnumerable\u折扣计算器；
公共折扣策略（IEnumerable折扣计算器）
{
_折扣计算器=折扣计算器；
}
公共decimal GetDiscount（字符串用户类型，decimal orderTotal）
{
var calculator=\u折扣计算器.FirstOrDefault（x=>x.AppliesTo（userType））；
if（calculator==null）返回0；
返回calculator.CalculateDiscovery（orderTotal）；
}
}
公共接口IDisontCalculator
{
布尔Ap