【结对项目总结】优化的四则运算生成器

结对小组信息：

13070027 郑亦然

13070038 李芳达

基于之前的个人项目(http://www.cnblogs.com/yuki8819/p/5305107.html)，本项目将主体功能封装，并加入了新的控制模块，并且制作了GUI

效果如图

程序主要分为三个模块：Controller, Generator, Calculator

Controller负责控制GUI，与后台交互

Generator封装了生成算式的功能

Calculator封装了计算算式的功能

关于Calculator和Generator的设计可见http://www.cnblogs.com/yuki8819/p/5305107.html

Generator支持参数修改：本轮生成多少算式？算式中运算数的最大数值？算式长度？

使用主界面中的Option按钮可以进入修改参数的界面

按下Next按钮可以生成一条算式，在输入框中输入答案后，按OK按钮可以得到结果（作对或做错，以及正确答案）

做完规定的题数后，会得到最后的得分（即作对的题数）

按Restart键可以重新开始一轮答题

测试方面，由于这个程序本身在输入上不会出现非法输入（输入框有格式限制），所以我新建了一个控制台程序来测试Calculator模块，代码如下：

static void Main(string[] args)
{
    while (true)
    {
        string line = Console.ReadLine();
        Console.WriteLine(Calculate(line));
    }
}

输入算式，由CMD显示运算结果或错误提示

输入错误测试：

+12-34（以符号开始）

12-34+（以符号结束）

12++34*56（连续的运算符）

12+34/0-56*78（0作被除数）

12x45+56*78/23（非法字符）

（空算式）

12+34/56*78（正确算式）

结果：

这次的结对项目是我和同学李芳达一起完成的，在设计过程中，我们一起讨论了几种可行的解决方案，最后选择了上述方案。对于GUI的选择，我们使用了Unity3D的GUI系统。虽然我们都对这个引擎不很熟悉，但是我们对它很感兴趣，所以决定一起学习使用这个引擎。过程还是比较顺利的，最终结果也比较令人满意。

全部源代码：

PS: 源代码需要在Unity3D工程下才可以运行

Controller

using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using System;

public class Controller : MonoBehaviour 
{
    public GameObject field_Answer;
    public GameObject btn_Next;
    public GameObject btn_Restart;
    public GameObject btn_Options;
    public GameObject btn_OK;
    public GameObject txt_Quiz;
    public GameObject txt_Result;

    public GameObject OptionText;

    public GameObject field_Amount;
    public GameObject field_Max;
    public GameObject field_Operators;

    public Generator generator;

    public string result;
    public int count;
    public int correct;

    // Use this for initialization
    void Start()
    {
        generator = new Generator();
        field_Answer = new GameObject();
        btn_Next = new GameObject();
        btn_Restart = new GameObject();
        btn_Options = new GameObject();
        btn_OK = new GameObject();
        OptionText = new GameObject();
        txt_Quiz = new GameObject();
        txt_Result = new GameObject();
        field_Amount = new GameObject();
        field_Max = new GameObject("field_Max");
        field_Operators = new GameObject("field_Operators");

        field_Answer = GameObject.Find("field_Answer");
        btn_Next = GameObject.Find("btn_Next");
        btn_Restart = GameObject.Find("btn_Restart");
        btn_Options = GameObject.Find("btn_Options");
        btn_OK = GameObject.Find("btn_OK");
        txt_Quiz = GameObject.Find("txt_Quiz");
        txt_Result = GameObject.Find("txt_Result");

        OptionText = GameObject.Find("OptionText");

        field_Amount = GameObject.Find("field_Amount");
        field_Max = GameObject.Find("field_Max");
        field_Operators = GameObject.Find("field_Operators");



        field_Amount.SetActive(false);
        field_Max.SetActive(false);
        field_Operators.SetActive(false);
        txt_Result.SetActive(false);

        count = 0;
        correct = 0;
    }

    // Update is called once per frame
    void Update()
    {
        
    }

    public void OnNext()
    {
        generator.GenerateLines();
        Text txt = txt_Quiz.GetComponent<Text>();
        txt.text = generator.lines;
        result = Calculator.Calculate(generator.lines_final, generator.tf);
        Debug.Log(result);
        btn_OK.SetActive(true);
        InputField inf = field_Answer.GetComponent<InputField>();
        inf.text = "";
    }

    public void OnOK()
    {
        count++;
        btn_OK.SetActive(false);
        InputField inf = field_Answer.GetComponent<InputField>();
        if (inf.text == result)
        {
            correct++;
            Text txt = txt_Quiz.GetComponent<Text>();
            txt.text = "Correct!";
        }
        else
        {
            Text txt = txt_Quiz.GetComponent<Text>();
            txt.text = "Wrong answer! The answer should be: " + result;
        }
        if (count >= generator.rows)
        {
            txt_Result.SetActive(true);
            Text txt = txt_Result.GetComponent<Text>();
            txt.text = "Finished!
Your Score is: " + correct + " out of " + count;
            btn_Next.SetActive(false);
        }
    }

    public void OnRestart()
    {
        btn_OK.SetActive(false);
        count = 0;
        correct = 0;
        Text txt = txt_Quiz.GetComponent<Text>();
        txt.text = "";
        txt_Result.SetActive(false);
        btn_Next.SetActive(true);
    }

    public void OnOptions()
    {
        if (!field_Amount.active)
        {
            field_Amount.SetActive(true);
            InputField infa = field_Amount.GetComponent<InputField>();
            infa.text = "" + generator.rows;
            field_Max.SetActive(true);
            InputField infm = field_Max.GetComponent<InputField>();
            infm.text = "" + generator.max;
            field_Operators.SetActive(true);
            InputField info = field_Operators.GetComponent<InputField>();
            info.text = "" + generator.operators;

            field_Answer.SetActive(false);
            btn_Next.SetActive(false);
            txt_Quiz.SetActive(false);
            btn_OK.SetActive(false);
            txt_Result.SetActive(false);

            Text txt = OptionText.GetComponent<Text>();
            txt.text = "Confirm";
        }
        else
        {
            field_Amount.SetActive(false);
            InputField infa = field_Amount.GetComponent<InputField>();
            generator.rows = Int32.Parse(infa.text);
            field_Max.SetActive(false);
            InputField infm = field_Max.GetComponent<InputField>();
            generator.max = Int32.Parse(infm.text);
            field_Operators.SetActive(false);
            InputField info = field_Operators.GetComponent<InputField>();
            generator.operators = Int32.Parse(info.text);

            field_Answer.SetActive(true);
            btn_Next.SetActive(true);
            txt_Quiz.SetActive(true);
            btn_OK.SetActive(false);
            txt_Result.SetActive(false);

            Text txt = OptionText.GetComponent<Text>();
            txt.text = "Options";
            OnRestart();
        }
        
    }
}

Generator

using System;
using System.Reflection;
using System.Globalization;
using Microsoft.CSharp;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Text;
using System.Collections.Generic;
using System.IO;

using UnityEngine;
using System.Collections;


public class Generator
{
    public int max;//最大数值
    public int rows;//生成算式个数
    public int operators;//每行运算符个数
    public List<int> nums;
    public List<int> add_n_minus;
    public List<int> div;
    public List<int> div_nums;
    public int tf;//通分分母
    public int amount;
    public string lines;
    public string lines_tf;//通分分母字符串
    public string lines_final;//通分分子字符串
    public int count;


    public Generator()
    {
        max = 50;
        rows = 10;
        operators = 10;
    }


    public void GenerateLines()
    {
        tf = 1;
        nums = new List<int>();
        add_n_minus = new List<int>();
        div = new List<int>();
        div_nums = new List<int>();
        System.Random rnd = new System.Random(GetRandomSeed());
        amount = rnd.Next(1, operators + 1);
        lines = "";
        lines_tf = "";
        lines_final = "";

        int x = 0;
        int d = 0;
        for (int i = 0; i < amount; i++)
        {
            //A new number
            rnd = new System.Random(GetRandomSeed());
            nums.Add(rnd.Next(1, max));
            lines += nums[i];
            //A new operator
            System.Random rnd0 = new System.Random(GetRandomSeed());
            int key = rnd0.Next(0, 4);
            switch (key)
            {
                case 0:
                    x = 0;
                    lines += "+";
                    add_n_minus.Add(lines.Length);
                    break;
                case 1:
                    x = 0;
                    lines += "-";
                    add_n_minus.Add(lines.Length);
                    break;
                case 2:
                    x++;
                    if (x <= 3)
                    {
                        lines += "*";
                        break;
                    }
                    else
                    {
                        goto case 1;
                    }
                case 3:
                    x = 0;
                    d++;
                    if (d <= 3)
                    {
                        lines += "/";
                        div.Add(i);
                        break;
                    }
                    else
                    {
                        goto case 1;
                    }
                default:
                    x = 0;
                    break;
            }
        }

        rnd = new System.Random(GetRandomSeed());
        nums.Add(rnd.Next(1, max));
        lines += nums[amount];

        for (int i = 0; i < div.Count; i++)
        {
            div_nums.Add(nums[div[i] + 1]);
            lines_tf += div_nums[i];
            lines_tf += "*";
            tf *= div_nums[i];
        }

        lines_final += lines_tf;
        lines_final += lines;

        if (div.Count > 0)
        {
            for (int i = 1; i <= add_n_minus.Count; i++)
            {
                lines_final = lines_final.Insert(i * lines_tf.Length + add_n_minus[i - 1], lines_tf);
            }
        }
    }

    public int GetRandomSeed()
    {
        byte[] bytes = new byte[4];
        System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
        rng.GetBytes(bytes);
        return BitConverter.ToInt32(bytes, 0);
    }
}

Calculator

using UnityEngine;
using System;
using System.Reflection;
using System.Globalization;
using Microsoft.CSharp;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Text;
using System.Collections.Generic;
using System.IO;
using System.Collections;

static class Calculator
{
    public static string Calculate(string lines)
    {
        if (lines[0] < '0' || lines[0] > '9')
        {
            return "Error: the formula must be begun with a number";
        }
        if (lines[lines.Length - 1] < '0' || lines[lines.Length - 1] > '9')
        {
            return "Error: the formula must be ended with a number";
        }
        for (int i = 0; i < lines.Length; i++)
        {
            if ((lines[i] >= '0' && lines[i] <= '9') || lines[i] == '+' || lines[i] == '-' || lines[i] == '*' || lines[i] == '/')
            {
                if (lines[i] < '0' || lines[i] > '9')
                {
                    if (lines[i + 1] < '0' || lines[i + 1] > '9')
                    {
                        return "Error: continuous operators are not allowed";
                    }
                    if (lines[i] == '/')
                    {
                        if (lines[i + 1] == '0')
                        {
                            return "Error: 0 cannot be divided";
                        }
                    }
                }
            }
            else
            {
                return "Error: invalid characters included";
            }
        }

        string temp = lines;
        List<int> nums = new List<int>();
        List<int> add_n_minus = new List<int>();
        List<int> div = new List<int>();
        List<int> div_nums = new List<int>();
        string lines_tf = "";
        string lines_final = "";
        int tf = 1;
        for (int i = temp.Length; i >= 0; i--)
        {
            if (temp[i] == '+' || temp[i] == '-' || temp[i] == '*' || temp[i] == '/')
            {
                string n = temp.Substring(i + 1, temp.Length - i);
                temp = temp.Remove(i);
                nums.Add(Int32.Parse(n));
                if (temp[i] == '+' || temp[i] == '-')
                {
                    add_n_minus.Add(lines.Length - i);
                }
                else if (temp[i] == '/')
                {
                    div.Add(nums.Count);
                }
            }
        }
        nums.Add(Int32.Parse(temp));
        nums.Reverse(0,nums.Count - 1);
        div.Reverse();
        for (int i = 0; i < div.Count; i++)
        {
            div[i] = nums.Count - div[i];
        }
        for (int i = 0; i < div.Count; i++)
        {
            div_nums.Add(nums[div[i] + 1]);
            lines_tf += div_nums[i];
            lines_tf += "*";
            tf *= div_nums[i];
        }

        lines_final += lines_tf;
        lines_final += lines;

        if (div.Count > 0)
        {
            for (int i = 1; i <= add_n_minus.Count; i++)
            {
                lines_final = lines_final.Insert(i * lines_tf.Length + add_n_minus[i - 1], lines_tf);
            }
        }

        // 1.CSharpCodePrivoder
        CSharpCodeProvider objCSharpCodePrivoder = new CSharpCodeProvider();

        // 2.ICodeComplier
        ICodeCompiler objICodeCompiler = objCSharpCodePrivoder.CreateCompiler();

        // 3.CompilerParameters
        CompilerParameters objCompilerParameters = new CompilerParameters();
        objCompilerParameters.ReferencedAssemblies.Add("System.dll");
        objCompilerParameters.GenerateExecutable = false;
        objCompilerParameters.GenerateInMemory = true;

        // 4.CompilerResults


        CompilerResults cr = objICodeCompiler.CompileAssemblyFromSource(objCompilerParameters, GenerateCode(lines_final, tf));

        if (cr.Errors.HasErrors)
        {
            Debug.Log("编译错误：");
            foreach (CompilerError err in cr.Errors)
            {
                Debug.Log(err.ErrorText);
            }
            return "Error: compiler error.";
        }
        else
        {
            //通过反射，调用HelloWorld的实例
            Assembly objAssembly = cr.CompiledAssembly;
            object objHelloWorld = objAssembly.CreateInstance("DynamicCodeGenerate.HelloWorld");
            MethodInfo objMI = objHelloWorld.GetType().GetMethod("OutPut");
            return objMI.Invoke(objHelloWorld, null).ToString();
        }
    }

    public static string Calculate(string lines_final, int tf)
    {
        if (tf == 0)
        {
            return "Error: 0 cannot be divided";
        }
        if (lines_final[0] < '0' || lines_final[0] > '9')
        {
            return "Error: the formula must be begun with a number";
        }
        if (lines_final[lines_final.Length - 1] < '0' || lines_final[lines_final.Length - 1] > '9')
        {
            return "Error: the formula must be ended with a number";
        }
        for (int i = 0; i < lines_final.Length; i++)
        {
            if ((lines_final[i] >= '0' && lines_final[i] <= '9') || lines_final[i] == '+' || lines_final[i] == '-' || lines_final[i] == '*' || lines_final[i] == '/')
            {
                if (lines_final[i] < '0' || lines_final[i] > '9')
                {
                    if (lines_final[i + 1] < '0' || lines_final[i + 1] > '9')
                    {
                        return "Error: continuous operators are not allowed";
                    }
                    if (lines_final[i] == '/')
                    {
                        if (lines_final[i + 1] == '0')
                        {
                            return "Error: 0 cannot be divided";
                        }
                    }
                }
            }
            else
            {
                return "Error: invalid characters included";
            }
        }

        // 1.CSharpCodePrivoder
        CSharpCodeProvider objCSharpCodePrivoder = new CSharpCodeProvider();

        // 2.ICodeComplier
        ICodeCompiler objICodeCompiler = objCSharpCodePrivoder.CreateCompiler();

        // 3.CompilerParameters
        CompilerParameters objCompilerParameters = new CompilerParameters();
        objCompilerParameters.ReferencedAssemblies.Add("System.dll");
        objCompilerParameters.GenerateExecutable = false;
        objCompilerParameters.GenerateInMemory = true;

        // 4.CompilerResults
        

        CompilerResults cr = objICodeCompiler.CompileAssemblyFromSource(objCompilerParameters, GenerateCode(lines_final, tf));

        if (cr.Errors.HasErrors)
        {
            Debug.Log("编译错误：");
            foreach (CompilerError err in cr.Errors)
            {
                Debug.Log(err.ErrorText);
            }
            return "Error: compiler error.";
        }
        else
        {
            //通过反射，调用HelloWorld的实例
            Assembly objAssembly = cr.CompiledAssembly;
            object objHelloWorld = objAssembly.CreateInstance("DynamicCodeGenerate.HelloWorld");
            MethodInfo objMI = objHelloWorld.GetType().GetMethod("OutPut");
            return objMI.Invoke(objHelloWorld, null).ToString();
        }
    }

    public static string GenerateCode(string lines_final, int tf)
    {
        StringBuilder sb = new StringBuilder();
        sb.Append("using System;using System.IO;using System.Collections.Generic;using System.Text;");
        sb.Append(Environment.NewLine);
        sb.Append("namespace DynamicCodeGenerate");
        sb.Append(Environment.NewLine);
        sb.Append("{");
        sb.Append(Environment.NewLine);
        sb.Append("	public class HelloWorld");
        sb.Append(Environment.NewLine);
        sb.Append("	{");
        sb.Append(Environment.NewLine);
        sb.Append("	public string OutPut()");
        sb.Append(Environment.NewLine);
        sb.Append("		{");
        sb.Append(Environment.NewLine);
        sb.Append("long tf = " + tf + ";");
        sb.Append(Environment.NewLine);
        sb.Append("long re = " + lines_final + ";");
        sb.Append(Environment.NewLine);
        sb.Append("for (int i = 2; i < re || i < tf; i++){while (re % i == 0 && tf % i == 0){re = re / i;tf = tf / i;}}");
        sb.Append(Environment.NewLine);
        //sb.Append("Console.Write("Result = ");");
        sb.Append("		if (tf != 1){return re.ToString() + "/" + tf.ToString();} else{return re.ToString();}");
        sb.Append(Environment.NewLine);
        sb.Append(Environment.NewLine);
        sb.Append("		}");
        sb.Append(Environment.NewLine);
        sb.Append("	}");
        sb.Append(Environment.NewLine);
        sb.Append("}");
        string code = sb.ToString();
        return code;
    }
}