C# 为什么我必须指定泛型类型arg，而它'；从输入参数来看，很明显是什么类型？

因此，在我放弃了寻找问题的最佳解决方案的希望之后，我现在又开始按照我在第一次编辑中描述的方式实施我的策略。没那么糟，但有件事我不相信

（你不必阅读链接中的内容来回答这个问题，但如果有人想了解我正在做的事情的更多细节，我只是添加了它）

以下是我现在拥有的用于添加项目的内容：

public interface IAddingStrategy
{
    bool Add(AddArgs args);
}

public class NormalAdd : IAddingStrategy
{
    public bool Add(AddArgs args)
    {
        if (!(args is NormalAddArgs))
            throw new Exception("NormalAdd: Invalid args!");
        Console.WriteLine("Normal add");
        return true;
    }
}

public class ForceAdd : IAddingStrategy
{
    public bool Add(AddArgs args)
    {
        if (!(args is ForceAddArgs))
            throw new Exception("NormalAdd: Invalid args!");
        Console.WriteLine("Force add");
        return true;
    }
}

public abstract class AddArgs
{
}

public class NormalAddArgs : AddArgs
{
    public int row;
    public int col;

    public NormalAddArgs(int row, int col)
    {
        this.row = row;
        this.col = col;
    }
}

public class ForceAddArgs : AddArgs
{
    public int id;

    public ForceAddArgs(int id)
    {
        this.id = id;
    }
}

public class Adder
{
    private Dictionary<Type, IAddingStrategy> dic = new Dictionary<Type, IAddingStrategy>();
    public Adder()
    {
        dic.Add(typeof(NormalAdd), new NormalAdd());
        dic.Add(typeof(ForceAdd), new ForceAdd());
    }

    private IAddingStrategy GetStrategy(Type type)
    {
        IAddingStrategy strategy;
        if (!dic.TryGetValue(type, out strategy))
            return null;
        return strategy;
    }

    public bool Add<T, V>(V args) where T : IAddingStrategy where V : AddArgs
    {
        IAddingStrategy strategy = GetStrategy(typeof(T));
        if (strategy == null)
            return false;
        return strategy.Add(args);
    }
}

公共接口策略
{
bool Add（AddArgs args）；
}
公共类NormalAdd:IAddingStrategy
{
公共bool Add（AddArgs args）
{
如果（！（args为NormalAddArgs））
抛出新异常（“NormalAdd:Invalid args！”）；
控制台写入线（“正常添加”）；
返回true；
}
}
公共类ForceAdd:IAddingStrategy
{
公共bool Add（AddArgs args）
{
如果（！（args为ForceAddArgs））
抛出新异常（“NormalAdd:Invalid args！”）；
控制台写入线（“强制添加”）；
返回true；
}
}
公共抽象类AddArgs
{
}
公共类NormalAddArgs:AddArgs
{
公共int row；
公共int col；
公共NormalAddArgs（整数行，整数列）
{
this.row=行；
this.col=col；
}
}
公共类ForceAddArgs:AddArgs
{
公共int id；
公共ForceAddArgs（内部id）
{
this.id=id；
}
}
公共类加法器
{
私有字典dic=新字典（）；
公共加法器（）
{
添加（typeof（NormalAdd），new NormalAdd（））；
dic.Add（typeof（ForceAdd），new ForceAdd（））；
}
私有IAddingStrategy GetStrategy（类型）
{
发展战略；
if（！dic.TryGetValue（类型，输出策略））
返回null；
回报策略；
}
公共bool Add（V args）where T:IAddingStrategy where V:AddArgs
{
IAddingStrategy=GetStrategy（类型（T））；
如果（策略==null）
返回false；
返回策略。添加（args）；
}
}

是最后一点让我恼火。如果我现在想使用这个加法器，我必须：

var adder = new Adder();
adder.Add<NormalAdd, NormalAddArgs>(new NormalAddArgs(10, 5));

var加法器=新加法器（）；
adder.Add（新的NormalAddArgs（10,5））；

如果从参数中可以很清楚地看出我使用的是

NormalAddArgs

，为什么我必须指定第二个泛型arg？i、 为什么我不能直接做加法器添加（新的NormalAddArgs（10，5））？因为这是我最终希望做的

那么，为什么我不能这样做呢？是否有一些约束我必须添加到这样做，或

---

谢谢您的帮助。

因为类型推断是一件要么全有要么全无的事情。它要么推断调用的所有类型，要么不推断任何类型。您必须告诉它

NormalAdd

。顺便说一句，从您的代码判断，根本不需要使用

V

类型参数！将

args

generic的类型设置为泛型不会带来任何好处。只需将其设置为

AddArgs args

。感谢您的支持。是的，安东，你是对的。我以为我设置了一些类型安全约束，但似乎没有。我猜，

Add（V args）其中T:IAddingStrategy其中V:AddArgs

就是我的意思。但是，由于以一种通用的方式实施

IAddingStrategy

给我带来了我无法解决的麻烦（见我的链接^）-不确定是我的无知还是缺乏语言自由，我想没有办法。。。再次感谢。