四个数混合运算,数据库存题,程序集构建三层建构

1.Model类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Model
{

   public class TIModel
    {
        private string number1;
        private string number2;
        private string number3;
        private string number4;
        private string operation1;
        private string operation2;
        private string operation3;
        public string Number1
        {
            get
            {
                return number1;
            }
            set
            {
                number1 = value;
            }

        }
        public string Number2
        {
            get
            {
                return number2;
            }
            set
            {
                number2 = value;
            }

        }
        public string Number3
        {
            get
            {
                return number3;
            }
            set
            {
                number3 = value;
            }

        }
        public string Number4
        {
            get
            {
                return number4;
            }
            set
            {
                number4 = value;
            }

        }
        public string Operation1
        {
            get
            {
                return operation1;
            }
            set
            {
                operation1 = value;
            }
        }
        public string Operation2
        {
            get
            {
                return operation2;
            }
            set
            {
                operation2 = value;
            }
        }
        public string Operation3
        {
            get
            {
                return operation3;
            }
            set
            {
                operation3 = value;
            }
        }
    }
}

2.Tool公共类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
using System.Data;

namespace Tool
{

    public class SqlDBhelper
    {
        string constr = "Data Source=.;Initial Catalog=TIKUDB;Integrated Security=True";
        public SqlConnection conn = new SqlConnection();
        public DataSet ds = new DataSet();
        public DataTable dt = new DataTable();
        public SqlDataAdapter sda = new SqlDataAdapter();
        public void dbcon()//连接数据库!
        {

            conn = new SqlConnection(constr);

        }
        public void opens()//打开数据库!
        {
            conn.Open();
        }
        public void closes()//关闭数据库!
        {
            conn.Close();
        }
        public int Inster(string comstr,SqlParameter[] values)//插入数据!
        {
            int a = 0;
            dbcon();
            SqlCommand comm = new SqlCommand(comstr, conn);
            if (values != null)
            {
                comm.Parameters.AddRange(values);
            }
            opens();
            try
            {
                a = comm.ExecuteNonQuery();

            }
            finally
            {
                closes();
            }
            return a;

        }
        public DataTable Read(string comstr)//读取数据!
        {
            dbcon();
            sda = new SqlDataAdapter(comstr, conn);
            sda.Fill(ds);
            dt = ds.Tables[0];
            return dt;

        }
        public int execSql(string comstr)//删除数据!
        {
            dbcon();
            int a = 0;
            SqlCommand comm = new SqlCommand(comstr, conn);
            opens();
            try
            {
                a = comm.ExecuteNonQuery();
            }
            finally
            {
                closes();
            }
            return a;

        }
    }
}

 3. DAL数据库访问类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Tool;
using Model;
using System.Data;
using System.Data.SqlClient;

namespace DAL
{

    public class TIDAL
    {
        SqlDBhelper helper = new SqlDBhelper();
        public DataTable Read()
        {
            string sql = "select * from TI";
            return helper.Read(sql);
        }
        public int InsterTI(TIModel rn)
        {
            string sql = "insert into TI values(@number1,@operation1,@number2,@operation2,@number3,@operation3,@number4)";
            SqlParameter[] parms =
            {
                new SqlParameter("@number1",rn.Number1),
                new SqlParameter("@operation1",rn.Operation1),
                new SqlParameter("@number2",rn.Number2),
                new SqlParameter("@operation2",rn.Operation2),
                new SqlParameter("@number3",rn.Number3),
                new SqlParameter("@operation3",rn.Operation3),
                new SqlParameter("@number4",rn.Number4)

            };
            return helper.Inster(sql, parms);
        }
        public int Delete()
        {
            string sql = "truncate table TI";
            return helper.execSql(sql);
        }

    }

}

4.BLL业务逻辑类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using Model;
using DAL;

namespace BLL
{

    public class TIBLL
    {
        TIDAL dal = new TIDAL();
        public bool Add(TIModel rm)//插入数据
        {
            if (dal.InsterTI(rm) > 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        public bool Delete()//删除数据
        {
            if (dal.Delete() > 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        public DataTable Read()
        {
            return dal.Read();

        }
    }

}

5.UI层类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace UI
{
    interface Iation//定义计算接口
    {
        double Calation(double a, double b);
    }
    class Add : Iation//加法
    {
        public double Calation(double a, double b)
        {
            return a + b;
        }
    }
    class Sub : Iation//减法
    {
        public double Calation(double a, double b)
        {
            return a - b;
        }
    }
    class Mul : Iation//乘法
    {
        public double Calation(double a, double b)
        {
            return a * b;
        }
    }
    class Div : Iation//除法
    {
        public double Calation(double a, double b)
        {
            if (b == 0)
            {
                throw new Exception("除数不能为零!");
            }
            else
            {
                return a / b;
            }
        }
    }
    class Factionsss//实现策略模式!
    {
        private Iation clation;
        public Factionsss(string operation)
        {
            switch (operation)
            {
                case "+":
                    clation = new Add();
                    break;
                case "-":
                    clation = new Sub();
                    break;
                case "*":
                    clation = new Mul();
                    break;
                case "/":
                    clation = new Div();
                    break;
            }

        }
        public double cal(double a, double b)
        {
            return clation.Calation(a, b);
        }

    }
    class Calculate
    { 

        public double Result(double a,string operation1,double b,string operation2,double c,string operation3,double d)
        {

            double answer = 0;

            if (operation2 == "+" || operation2 == "-")
            {
                bool leftPriority;
                if (operation1 == "*" || operation1 == "/")
                {
                    leftPriority = true;
                }
                else if (operation3 == "*" || operation3 == "/")
                {
                    leftPriority = false;
                }
                else
                {
                    leftPriority = true;
                }
                if (leftPriority == true)
                {
                    Factionsss faction = new Factionsss(operation1);
                    double answer1 = faction.cal(a, b);
                    faction = new Factionsss(operation2);
                    double answer2 = faction.cal(answer1, c);
                    faction = new Factionsss(operation3);
                    answer = faction.cal(answer2, d);

                }
                else
                {
                    Factionsss faction = new Factionsss(operation3);
                    double answer1 = faction.cal(c, d);
                    faction = new Factionsss(operation2);
                    double answer2 = faction.cal(b, answer1);
                    faction = new Factionsss(operation1);
                    answer = faction.cal(a, answer2);

                }

            }
            if (operation2 == "*" || operation2 == "/")
            {
                bool leftPriority;
                if (operation1 == "*" || operation1 == "/")
                {
                    leftPriority = true;
                }
                else if (operation3 == "*" || operation3 == "/")
                {
                    leftPriority = false;
                }
                else
                {
                    leftPriority = false;
                }
                if (leftPriority == true)
                {
                    Factionsss faction = new Factionsss(operation1);
                    double answer1 = faction.cal(a, b);
                    faction = new Factionsss(operation2);
                    double answer2 = faction.cal(answer1, c);
                    faction = new Factionsss(operation3);
                    answer = faction.cal(answer2, d);

                }
                else
                {
                    Factionsss faction = new Factionsss(operation2);
                    double answer1 = faction.cal(b, c);
                    faction = new Factionsss(operation3);
                    double answer2 = faction.cal(answer1, d);
                    faction = new Factionsss(operation1);
                    answer = faction.cal(answer2, a);
                }

            }

            return answer;
        }
    }

}

form1代码

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Model;
using BLL;

namespace UI
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        TIBLL bll = new TIBLL();
        private void Form1_Load(object sender, EventArgs e)
        {

        }

        private void button1_Click(object sender, EventArgs e)//开始
        {
            TIModel rm = new TIModel();
            rm.Number1 = textBox1.Text;
            rm.Number2 = textBox2.Text;
            rm.Number3 = textBox3.Text;
            rm.Number4 = textBox4.Text;
            rm.Operation1 = comboBox1.Text;
            rm.Operation2 = comboBox2.Text;
            rm.Operation3 = comboBox3.Text;
            if (bll.Add(rm) == true)
            {
                MessageBox.Show("保存成功!");

            }
            else
            {
                MessageBox.Show("插入失败!");
            }
            textBox1.Clear();
            textBox2.Clear();
            textBox3.Clear();
            textBox4.Clear();
        }

        private void button2_Click(object sender, EventArgs e)
        {
            if (bll.Delete() == true)
            {
                MessageBox.Show("删除失败!");
            }
            else
            {
                MessageBox.Show("删除成功!");
            }
        }

        private void button3_Click(object sender, EventArgs e)
        {
            Form2 fas = new Form2();
            fas.ShowDialog();
        }

    }
}

form2代码

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Model;
using BLL;

namespace UI
{
    public partial class Form2 : Form
    {
        public Form2()
        {
            InitializeComponent();
        }
        TIBLL bll = new TIBLL();
        int i=0;
        private void Form2_Load(object sender, EventArgs e)
        {
            Reading();

        }

        private void button1_Click(object sender, EventArgs e)
        {
            Reading();
        }
        private void Reading()
        {

            DataTable dt = bll.Read();
            textBox1.Text = dt.Rows[i][0].ToString().Trim();
            label1.Text = dt.Rows[i][1].ToString().Trim();
            textBox2.Text = dt.Rows[i][2].ToString().Trim();
            label2.Text = dt.Rows[i][3].ToString().Trim();
            textBox3.Text = dt.Rows[i][4].ToString().Trim();
            label3.Text = dt.Rows[i][5].ToString().Trim();
            textBox4.Text = dt.Rows[i][6].ToString().Trim();
            i++;
            if (i == dt.Rows.Count - 1)
            {
                MessageBox.Show("你做完了!");
            }

        }

        private void textBox5_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                Calculate calcuate = new Calculate();
                double a=double.Parse(textBox1.Text);
                double b=double.Parse(textBox2.Text);
                double c=double.Parse(textBox3.Text);
                double d=double.Parse(textBox4.Text);
                string operation1=label1.Text;
                string operation2=label2.Text;
                string operation3=label3.Text;
                double answer = calcuate.Result(a, operation1, b, operation2, c, operation3, d);
                if (textBox5.Text == answer.ToString())
                {
                    MessageBox.Show("回答正确!");
                }
                else
                {
                    MessageBox.Show("回答错误!");
                }
                textBox5.Clear();
                Reading();

            }
        }
    }
}

6,数据库存题测试

7,总结

一开始真的不懂怎么去实现程序集下的三层架构,直到现在依然感觉掌握的很灵活,还有就是四个数的运算,老师让去掉工厂模式,但是去掉工厂模式代码的编写会更加的麻烦,所以就没有去掉工厂模式,但是总感觉这样写程序的性能会大幅度降低,还有就是计算类的存放问题,应该放到哪一个层里面搞不明白,本来想放在业务逻辑层的,但是最终还是放在了UI层!

时间: 2024-11-08 21:07:14

四个数混合运算,数据库存题,程序集构建三层建构的相关文章

三个数混合运算和三层架构

1,数据访问层 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Data; using System.Data.SqlClient; using System.Windows.Forms; namespace SQL1 { class DB1//数据访问层! { public SqlConnection conn = new SqlConnecti

MathExamV2.0四则混合运算计算题生成器

MathExamV2.0四则混合运算计算题生成器----211606360 丁培晖 211606343 杨宇潇 一.预估与实际 PSP2.1 Personal Software Process Stages 预估耗时(分钟) 实际耗时(分钟) Planning 计划 ? Estimate ? 估计这个任务需要多少时间 60 100 Development 开发 ? Analysis ? 需求分析 (包括学习新技术) 360 440 ? Design Spec ? 生成设计文档 20 20 ? D

第四次作业 结对编程 (四则混合运算)

一 需求分析 本次我们做的程序是数学的四则混合运算,并且增加了部分人性化的功能,接下来,我们谈谈这个程序的相关需求,此程序是一个1—10的四则混合运算,那么可以想到主要用于小学生,(ps 个人想法,不排除其他高年级的使用,因为用户可以输入任意的随机数范围),此外,本程序还可能会出现在家庭.教育机构和部分教学网站上面,因为他们可能会给学生出一些简单的数学题目,可以自由设置测试时间,题目数量等内容,而这一程序正好解决了这一个问题,我想,产品的需求必须首先知道用户需要什么,要以客户为中心.而这个产品正

lintcode 中等题:4 Sum 四个数之和

题目 四数之和 给一个包含n个数的整数数组S,在S中找到所有使得和为给定整数target的四元组(a, b, c, d). 样例 例如,对于给定的整数数组S=[1, 0, -1, 0, -2, 2] 和 target=0. 满足要求的四元组集合为: (-1, 0, 0, 1) (-2, -1, 1, 2) (-2, 0, 0, 2) 注意 四元组(a, b, c, d)中,需要满足a <= b <= c <= d 答案中不可以包含重复的四元组. 解题 怎么感觉下面程序已经没法修改了但是在

201574010343/201571030318《小学四则混合运算》结对项目报告

github代码地址:https://github.com/zxt555/demo2/tree/master/src 一:需求分析 1. 由计算机从题库文件中随机选择20道加减乘除混合算式,用户输入算式答案,程序检查答案是否正确,每道题正确计5分,错误不计分,20道题测试结束后给出测试总分: 2.系统随机产生一百以内的两个数进行运算选择加.减.乘.除运算. 3.系统随机产生一百以内的两个数进行运算. 4.练习时,用户从键盘输入结果,正确和错误均有提示,错误的话提示下会有正确的结果. 5. 根据实

关于位运算的水题

找数字2 Time Limit: 25000ms, Special Time Limit:50000ms, Memory Limit:32768KB Total submit users: 92, Accepted users: 67 Problem 11466 : No special judgement Problem description 给定2n+1个数字,只有一个数字出现了奇数次,其余的数字都出现了偶数次,现在你需要找出出现奇数次的数字. Input 包含多组数据,每组数据第一行为一

三则混合运算下的取模

取模的一个简单性质:加法,减法,乘法,以及三则的混合运算在过程中取模与算出最终结果取模结果一样 这个性质使一些超出long long 的数据便于被记录存储并运算: 首先用string s ; cin >> s;来写入数据,读成字符串之后虽然进行了记录,但并不能很方便地进行运算与使用, 这时使用for()循环,一点点读取字符串,并对每一步的结果都进行取模,则可 顺利将很大的数据转化为一个可以用int 或 long long 存储的数据 如下题代码(红点标记的两行)就是利用了过程与结果取模一致这个

软件工程学习之小学四则混合运算出题软件 Version 1.00 设计思路及感想

对于小学四则混合运算出题软件的设计,通过分析设计要求,我觉得为了这个软件在今后便于功能上的扩充,可以利用上学期所学习的<编译原理>一课中的LL1语法分析及制导翻译的算法来实现.这样做的好处有以下几点: 1. 由于LL1制导翻译是一项成熟且可靠的技术,并且其递归下降算法易于改编为算式生成算法: 2. 我们有系统的方法可以获得较复杂表达式的LL1文法,则可以方便地生成形式丰富的算式: 3.由于四则混合运算中需要考虑运算优先级的问题,那么采用LL1分析器可以很方便的实现计算表达式的功能: 4.当用户

IO-04. 混合类型数据格式化输入(5)

IO-04. 混合类型数据格式化输入(5) 时间限制 400 ms 内存限制 65536 kB 代码长度限制 8000 B 判题程序 Standard 作者 乔林(清华大学) 本题要求编写程序,顺序读入浮点数1.整数.字符.浮点数2,再按照字符.整数.浮点数1.浮点数2的顺序输出. 输入格式: 输入在一行中顺序给出浮点数1.整数.字符.浮点数2,其间以1个空格分隔. 输出格式: 在一行中按照字符.整数.浮点数1.浮点数2的顺序输出,其中浮点数保留小数点后2位. 输入样例: 2.12 88 c 4