C# PrivateObject中找不到类型的构造函数错误

我正在为计算软件编写一个单元测试。在测试用例中，我使用了“

PrivateObject

”来访问私有方法“

sendNumberToCalculation（）

”，但我在找不到类型上得到了错误构造函数

    public class CalculationTest
{
    [TestMethod]
    public void sendNumberToCalculationTest()
    {

        // -- Act
        PrivateObject obj = new PrivateObject(typeof(Calculation));
        Tokenization token = new Tokenization("5*10-18/(3+19)");
        PolishNotation polish = new PolishNotation(token.MathExpressionParser());

        double expected = 49.19;

        // -- Actual
        double actual = Convert.ToDouble(obj.Invoke("sendNumberToCalculation", polish));

        // -- Assert
        Assert.AreEqual(expected, actual);
    }
}

    public class Calculation
{

    private Tokenization token;

    private PolishNotation polish;
    private Stack<double> numbers = new Stack<double>();
    private Stack<string> operators = new Stack<string>();

    public Calculation(string expression)
    {
        token = new Tokenization(expression);
        polish = new PolishNotation(token.MathExpressionParser());
    }

    private double sendNumberToCalculation()
    {
        int number;
        int number1 = 0;
        int number2 = 0;
        string operatorName = "";
        int counter = 1;
        foreach (var item in polish.InfixToPostfix())
        {
            numbers.Push(Convert.ToDouble(item));
            if (!int.TryParse(item, out number))
            {
                operators.Push(item);
                while (counter <= 2 && numbers.Count > 1)
                {
                    if (counter == 1)
                    {
                        number2 = Convert.ToInt32(numbers.Pop());
                    }
                    else if (counter == 2 && operators.Count > 0)
                    {
                        number1 = Convert.ToInt32(numbers.Pop());
                        operatorName = operators.Pop();
                    }
                }
            }
            operatorDetect(number1, number2, operatorName);
        }
        var result = numbers.Pop();

        return result;
    }

    private void operatorDetect(int number1, int number2, string operatorName)
    {
        switch (operatorName)
        {
            case "+":
                Add(number1, number2);
                break;

            case "*":
                Multipy(number1, number2);
                break;

            case "/":
                Divide(number1, number2);
                break;

            case "-":
                Subtract(number1, number2);
                break;
        }
    }

    private void Add(int number1, int number2)
    {
        double number = number1 + number2;
        numbers.Push(number);
    }

    private void Multipy(int number1, int number2)
    {
        double number = number1 * number2;
        numbers.Push(number);
    }

    private void Subtract(int number1, int number2)
    {
        double number = number1 / number2;
        numbers.Push(number);
    }

    private void Divide(int number1, int number2)
    {
        double number = number1 - number2;
        numbers.Push(number);
    }
}

公共类计算测试
{
[测试方法]
public void sendNumberToCalculationTest（）
{
//--行动
PrivateObject obj=新的PrivateObject（类型（计算））；
标记化标记=新标记化（“5*10-18/（3+19）”；
PolishNotation polish=新的PolishNotation（token.MathExpressionParser（））；
双预期=49.19；
//--实际的
double actual=Convert.ToDouble（obj.Invoke（“sendNumberToCalculation”，波兰语））；
//--断言
断言.AreEqual（预期、实际）；
}
}
公共类计算
{
专用令牌化令牌；
私人抛光剂；
私有堆栈编号=新堆栈（）；
私有堆栈运算符=新堆栈（）；
公共计算（字符串表达式）
{
标记=新标记化（表达式）；
polish=新的PolishNotation（token.MathExpressionParser（））；
}
专用双sendNumberToCalculation（）函数
{
整数；
整数1=0；
整数2=0；
字符串运算符名称=”；
int计数器=1；
foreach（波兰文的var项。InfixToPostfix（））
{
Push（Convert.ToDouble（item））；
如果（！int.TryParse（项目，输出编号））
{
操作员。推送（项目）；
同时（柜台1）
{
如果（计数器==1）
{
number2=Convert.ToInt32（numbers.Pop（））；
}
else if（计数器==2&&operators.Count>0）
{
number1=Convert.ToInt32（numbers.Pop（））；
operatorName=operators.Pop（）；
}
}
}
运算符检测（编号1、编号2、运算符名称）；
}
var result=numbers.Pop（）；
返回结果；
}
私有无效运算符检测（整数1、整数2、字符串运算符名称）
{
开关（操作员名称）
{
格“+”：
添加（编号1，编号2）；
打破
案例“*”：
多比（1号，2号）；
打破
案例“/：
除法（1号，2号）；
打破
案例“-”：
减法（数字1，数字2）；
打破
}
}
专用无效添加（整数1，整数2）
{
双倍数字=数字1+数字2；
数字。推（数字）；
}
私有void Multipy（整数1，整数2）
{
双倍数字=number1*number2；
数字。推（数字）；
}
私有空减法（整数1，整数2）
{
双倍数字=数字1/数字2；
数字。推（数字）；
}
私有无效除法（整数1，整数2）
{
双倍数字=数字1-数字2；
数字。推（数字）；
}
}

计算类不包含无参数构造函数。将构造函数参数传递给

使用PolishNotation类型的一个参数调用sendNumberToCalculation方法，但该方法没有任何参数。要从调用中删除第二个参数，请执行以下操作：

double actual = Convert.ToDouble(obj.Invoke("sendNumberToCalculation"));

---

有一种更简单的方法可以实现这一点，只需先创建对象，然后调用PrivateObject构造函数，该构造函数接受对象而不是类型。

可能会有所帮助

double actual = Convert.ToDouble(obj.Invoke("sendNumberToCalculation"));