熹熹大人
熹熹大人

简易计算器的设计_C#课程设计

以下内容可且仅可供参考，如有错误欢迎指正。

部分内容借鉴自百度

侵删致歉

位切换键盘的实现用了复杂的拖64给label的方法，此功能可以在自己计算机上的计算器里找到。

目录

一、设计简介

1.设计背景

2.开发工具及环境

二、需求分析

1.设计功能要求

2.其他要求

三、相关工作

1.设计基础

2.功能需求

四、设计原理

详见代码

五、源代码

1.界面

2. Form1.cs

3.Form2.cs

3.Program.cs

一、设计简介

1.设计背景

        伴随着日益升高的物质生活水平以及日常生活中对基本的计算需求的提高。如今，网络快速发展，对算数要求的需求日益增大，计算的效率和性能和人们的生活紧密相关。对此，使用c#语言开发出一个为人们生活带来便利的计算器，以期带来对数据计算的提高。该系统实现了对数的加、减、乘、除以及专业模式的运算。

2.开发工具及环境

1)   开发工具及介绍

        Microsoft Visual Studio（简称VS）。VS是美国微软公司的开发工具包系列产品。VS是一个基本完整的开发工具集，它包括了整个软件生命周期中所需要的大部分工具，如UML工具、代码管控工具、集成开发环境(IDE)等等。所写的目标代码适用于微软支持的所有平台，包括Microsoft Windows、Windows Mobile、Windows CE、.NET Framework、.Net Core、.NET Compact Framework和Microsoft Silverlight 及Windows Phone。

2)   开发环境

        window10系统、window11系统、Microsoft Visual Studio2019、2022。

二、需求分析

1.设计功能要求

1）实现加、减、乘、除、求开方、求倒数等。

2）实现进制之间的转换功能：十进制、二进制、十六进制、八进制。

2.其他要求

1）界面美观，功能丰富

2）开放平台：vs2010及以上

三、相关工作

1.设计基础

        使用Windows窗体应用程序，设计出美观丰富的用户界面（UI）以及相关代码编写设计程序而集成的一个简易的计算器，通过Windows窗体应用程序来添加控件，来组成所需要的运算和数字来达到简易模式以及专业模式。

2.功能需求

        图形化用户界面，设计的简易计算器，用户通过button按钮选择用户想要的算法、数字以及运算符号，进行简易模式以及专业模式。具体如下：

1）当进行简易模式的时候

  1. 鼠标单击“计算器”上的数字按钮（0、1、2、3、4、5、6、7、8、9、.）累次可以设置参与运算的数值。
  2. 鼠标单击“计算器”上的运算符号按钮（+、-、*、=、%）。
  3. 如果需要删除错误的数据，鼠标单击“计算器”上的Delete button按钮。
  4. 如果要清除历史就单击CE按钮。
  5. 此简易模式可以读取历史记录、清除历史记录、保存历史记录，以便于用户在旁边的空白处查看。

2）当进行专业模式的时候

  1. 鼠标单击“计算器”上面的数字按钮（button）（0、1、2、3、4、5、6、7、8、9、.、A、B、C、D、E、F、b、x、^、！、（））累次可以设置参与运算的数值。
  2. 鼠标单击“计算器”上的运算符号按钮（content）（+、-、*、=、%、）。
  3. 鼠标单击“计算器”，选择进制（二进制（前缀0b）、八进制（前缀0）、十进制、十六进制（0x））。
  4. 此简易模式也可以读取历史记录、清除历史记录、保存历史记录，展示在旁边的空白格中。
  5. 在专业模式下，还有含有64位数字的二进制，在数字上修改二进制，变可在下方得到相应的八进制、十进制、十六进制。

四、设计原理

详见代码

五、源代码

1.界面

Form1.cs[设计]

简易计算器的设计_C#课程设计_第1张图片

 Form2.cs[设计]

 简易计算器的设计_C#课程设计_第2张图片

2. Form1.cs

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 System.Text.RegularExpressions;
using System.IO;

namespace _1._2
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        
        private static List temp = new List();
        private static long tempx = 0;
        private void Add(object sender, EventArgs e)
        {   //数字和符号的Click事件
            Button button = (Button)sender;
            textBox1.Text += button.Text;
        }
        private void Reset(object sender, EventArgs e)
        {   // CE的Click事件
            textBox1.Text = "";
        }
        private void Delete(object sender, EventArgs e)
        {   // ←的Click事件
            //移除最后一个字符
            if (textBox1.TextLength > 0)
                textBox1.Text = textBox1.Text.Remove(textBox1.TextLength - 1);
        }
        private void Equal(object sender, EventArgs e)
        {   // = 的Click事件，计算并显示
            //自动清除历史文件夹
            Cleanf();
            List zhonglist = ToList(textBox1.Text);
            List houlist = houzhui(zhonglist);
            List s = zhonglist;
            s.Add("=");
            s.Add(Calculate(houlist));
            string s1 = string.Join("", s);
            if (temp.Count > 9)//最多存十条记录
            {
                temp.RemoveAt(0);
            }
            temp.Add(s1);
            textBox2.Text = string.Join(",",temp);
            textBox1.Text = Calculate(houlist);
        }
        //中缀转List
        static List ToList(string s)
        {
            List ls = new List();//存放中缀表达式
            String str = "";               //拼接多位数、小数
            char c = ' ';                  //遍历输入的字符
            int i = 0;

            do
            {
                if((s[i] == '-' && i == 0) || (i > 0 && s[i] == '-' && !char.IsDigit(s[i - 1])))//在负数前加零方便后续计算
                {
                    ls.Add("0");
                }
                if (!char.IsDigit(c = s[i])&&c != '.') //如果c不是数字和'.'，就加入ls
                {
                    ls.Add(c.ToString());
                    i++;    //i后移
                }
                else//如果是数字，需要考虑多位数
                {
                    str = "";   //先将str清空
                    while (i < s.Length && (char.IsDigit(c = s[i]) || c == '.'))
                    {
                        str += c;
                        i++;
                    }
                    ls.Add(str);
                }
            } while (i < s.Length);
            return ls;
        }
        //中缀改后缀
        static List houzhui(List ls)
        {
            //定义两个栈,一个存临时结果，一个存运算符
            Stack operators = new Stack();
            
            List num = new List();

            //遍历 ls
            foreach (var item in ls)
            {
                Regex regex = new Regex("[+-]?\\d+.?\\d*");//整数和浮点数
                //如果是一个数，则加入num
                if (regex.Match(item).Length > 0)
                {
                    num.Add(item);
                }
                else if (item.Equals("("))//Equals:比较是否相同
                {
                    operators.Push(item);
                }
                else if (item.Equals(")"))
                {
                    //如果是右括号,则依次弹出operators栈顶的运算符,并压入num,直到遇到左括号为止,并将这对括号丢弃
                    while (!operators.Peek().Equals("("))//Peek()返回顶部对象
                    {
                        num.Add(operators.Pop());
                    }
                    operators.Pop();   //将 ( 弹出
                }
                else
                {
                    //当item 的 优先级小于或等于operators栈顶运算符，将operators栈顶的运算符弹出并加入到num中，再次转到operators与operators中新的栈顶运算符比较
                    while (operators.Count != 0 && compare(operators.Peek()) >= compare(item))
                    {
                        num.Add(operators.Pop());
                    }
                    //还需要将 item 压入栈
                    operators.Push(item);
                }
            }

            //将operators中剩余的运算符依次弹出并加入num
            while (operators.Count != 0)
            {
                num.Add(operators.Pop());
            }

            return num;  //按顺序输出就是对应的后缀表达式对应的List
        }
        //运算符优先级
        public static int compare(string operation)
        {
            int res = 0;
            switch (operation)
            {
                case "+":
                    res = 1;
                    break;
                case "-":
                    res = 1;
                    break;
                case "*":
                    res = 2;
                    break;
                case "/":
                    res = 2;
                    break;
                case "%":
                    res = 3;
                    break;
                case "^":
                    res = 4;
                    break;
                case "!":
                    res = 5;
                    break;
                default:
                    Console.WriteLine("不存在该运算符");
                    break;
            }
            return res;
        }
        //计算后缀表达式
        static string Calculate(List ls)
        {
            Regex regex = new Regex("[+-]?\\d+.?\\d*");
            //创建栈
            Stack stack = new Stack();
            //遍历 list
            foreach (var item in ls)
            {
                //使用正则表达式来取出数
                if (regex.Match(item).Length > 0) //如果是数字,就压入栈中
                {
                    stack.Push(regex.Match(item).Value);
                }
                else if (item.Equals("!"))//弹出一个数字进行计算
                {
                    int num1 = int.Parse(stack.Pop());
                    int res = leicheng(num1);
                    stack.Push(res.ToString());
                }
                else    //不是数就弹出两个数字进行计算
                {
                    double num2 = double.Parse(stack.Pop());
                    if (stack.Count == 0)
                    {
                        stack.Push("0");
                    }
                    double num1 = double.Parse(stack.Pop());
                    double res = 0;
                    if (item.Equals("+"))
                    {
                        res = num1 + num2;
                    }
                    else if (item.Equals("-"))
                    {
                        res = num1 - num2;
                    }
                    else if (item.Equals("*"))
                    {
                        res = num1 * num2;
                    }
                    else if (item.Equals("÷"))
                    {
                        res = num1 / num2;
                    }
                    else if (item.Equals("%"))
                    {
                        res = num1 % num2;
                    }
                    else if (item.Equals("^"))
                    {
                        res = Math.Pow(num1, num2);
                    }
                    else
                    {
                        throw new Exception("表达式有误");
                    }
                    stack.Push(res.ToString());
                }
            }

            //最后留在stack中的数据就是运算结果
            return stack.Pop();
        }
        //累乘
        private static int leicheng(int n)
        {
            if(n == 1)
            {
                return n;
            }
            else
            {
                return n * leicheng(n - 1);
            }
        }
        //进制转换
        //二进制的前缀为 0b
        //八进制的前缀为 0
        //十六进制的前缀为 0x
        private void jinzhi2(object sender, EventArgs e)
        {
            String s = textBox1.Text;
            switch(s[0])
            {
                case '0':
                    switch (s[1])
                    {
                        case 'x'://十六转二
                            s = s.Substring(2);//去掉前缀
                            textBox1.Text = Convert.ToString(Convert.ToInt32(s, 16), 2);//先转十再转二
                            break;
                        default://八转二
                            s = s.Substring(1);
                            textBox1.Text = Convert.ToString(Convert.ToInt32(s, 8), 2);
                            break;
                    }
                    break;
                default://十转二
                    textBox1.Text = Convert.ToString(Convert.ToInt32(s), 2);
                    break;
            }
        }
        private void jinzhi8(object sender, EventArgs e)
        {
            String s = textBox1.Text;
            switch (s[0])
            {
                case '0':
                    switch (s[1])
                    {
                        case 'x'://十六转八
                            s = s.Substring(2);//去掉前缀
                            textBox1.Text = Convert.ToString(Convert.ToInt32(s, 16), 8);//先转十再转八
                            break;
                        case 'b'://二转八
                            s = s.Substring(2);
                            textBox1.Text = Convert.ToString(Convert.ToInt32(s, 2), 8);
                            break;
                    }
                    break;
                default://十转八
                    textBox1.Text = Convert.ToString(Convert.ToInt32(s), 8);
                    break;
            }
        }
        private void jinzhi10(object sender, EventArgs e)
        {
            String s = textBox1.Text;
            
            switch (s[1])
            {
                case 'x'://十六转十
                    s = s.Substring(2);//去掉前缀
                    textBox1.Text = Convert.ToString(Convert.ToInt32(s, 16));
                    break;
                case 'b'://二转十
                    s = s.Substring(2);
                    textBox1.Text = Convert.ToString(Convert.ToInt32(s, 2));
                    break;
                default://八转十
                    s = s.Substring(1);
                    textBox1.Text = Convert.ToString(Convert.ToInt32(s, 8));
                    break;
            }
        }
        private void jinzhi16(object sender, EventArgs e)
        {
            String s = textBox1.Text;
            switch (s[0])
            {
                case '0':
                    switch (s[1])
                    {
                        case 'b'://二转十六
                            s = s.Substring(2);//去掉前缀
                            textBox1.Text = Convert.ToString(Convert.ToInt32(s, 2), 16); ;//先转十再转十六
                            break;
                        default://八转十六
                            s = s.Substring(1);
                            textBox1.Text = Convert.ToString(Convert.ToInt32(s, 8), 16);
                            break;
                    }
                    break;
                default://十转十六
                    textBox1.Text = Convert.ToString(Convert.ToInt32(s), 16);
                    break;
            }
        }
        private void Reset2(object sender, EventArgs e)
        {   // 清除历史记录的Click事件
            textBox2.Text = "";
            temp.Clear();
            Cleanf();
        }
        //清空历史记录文件
        private void Cleanf()
        {
            File.Delete("历史记录1.txt");
            FileStream f = File.Create("历史记录1.txt");
            f.Close();
        }
        //读取文件到历史记录
        private void Readf(object sender, EventArgs e)
        {   //读取历史记录的Click事件
            StreamReader sr = new StreamReader("历史记录1.txt");
            string s;
            if((s = sr.ReadLine()) != null)
            {
                String[] s1 = s.Split(',');
                List s2 = new List(s1);
                temp = s2;
                textBox2.Text = string.Join(",", temp);
            }
            sr.Close();
        }
        //打开文件，
        private void Openf(object sender, EventArgs e)
        {  //保存历史记录的Click事件
            StreamWriter sw = new StreamWriter("历史记录1.txt");
            sw.WriteLine(string.Join(",", temp));
            sw.Close();
        }

        //以下是位切换键盘设计代码，不会高级方法，拖了64个label控制0和1

        private void jisuan(string s,int n)
        {
            long t = 1;
            for(int i = 0;i < n - 1;i++)
            {
                t *= 2;
            }
            if(s == "0")
            {
                tempx -= t;
            }
            else
            {
                tempx += t;
            }

            label72.Text = Convert.ToString(tempx , 8);
            label73.Text = Convert.ToString(tempx);
            label74.Text = Convert.ToString(tempx, 16);
        }
        private void ex1(object sender, EventArgs e)
        {
            if(label1.Text == "0")
            {
                label1.Text = "1";
            }
            else
            {
                label1.Text = "0";
            }
            jisuan(label1.Text,1);
        }

        private void ex2(object sender, EventArgs e)
        {
            if (label2.Text == "0")
            {
                label2.Text = "1";
            }
            else
            {
                label2.Text = "0";
            }
            jisuan(label2.Text, 2);
        }

        private void ex3(object sender, EventArgs e)
        {
            if (label3.Text == "0")
            {
                label3.Text = "1";
            }
            else
            {
                label3.Text = "0";
            }
            jisuan(label3.Text, 3);
        }

        private void ex4(object sender, EventArgs e)
        {
            if (label4.Text == "0")
            {
                label4.Text = "1";
            }
            else
            {
                label4.Text = "0";
            }
            jisuan(label4.Text, 4);
        }

        private void ex5(object sender, EventArgs e)
        {
            if (label5.Text == "0")
            {
                label5.Text = "1";
            }
            else
            {
                label5.Text = "0";
            }
            jisuan(label5.Text, 5);
        }

        private void ex6(object sender, EventArgs e)
        {
            if (label6.Text == "0")
            {
                label6.Text = "1";
            }
            else
            {
                label6.Text = "0";
            }
            jisuan(label6.Text, 6);
        }

        private void ex7(object sender, EventArgs e)
        {
            if (label7.Text == "0")
            {
                label7.Text = "1";
            }
            else
            {
                label7.Text = "0";
            }
            jisuan(label7.Text, 7);
        }

        private void ex8(object sender, EventArgs e)
        {
            if (label8.Text == "0")
            {
                label8.Text = "1";
            }
            else
            {
                label8.Text = "0";
            }
            jisuan(label8.Text, 8);
        }

        private void ex9(object sender, EventArgs e)
        {
            if (label9.Text == "0")
            {
                label9.Text = "1";
            }
            else
            {
                label9.Text = "0";
            }
            jisuan(label9.Text, 9);
        }

        private void ex10(object sender, EventArgs e)
        {
            if (label10.Text == "0")
            {
                label10.Text = "1";
            }
            else
            {
                label10.Text = "0";
            }
            jisuan(label10.Text, 10);
        }

        private void ex11(object sender, EventArgs e)
        {
            if (label11.Text == "0")
            {
                label11.Text = "1";
            }
            else
            {
                label11.Text = "0";
            }
            jisuan(label11.Text, 11);
        }

        private void ex12(object sender, EventArgs e)
        {
            if (label12.Text == "0")
            {
                label12.Text = "1";
            }
            else
            {
                label12.Text = "0";
            }
            jisuan(label12.Text, 12);
        }

        private void ex13(object sender, EventArgs e)
        {
            if (label13.Text == "0")
            {
                label13.Text = "1";
            }
            else
            {
                label13.Text = "0";
            }
            jisuan(label13.Text, 13);
        }

        private void ex14(object sender, EventArgs e)
        {
            if (label14.Text == "0")
            {
                label14.Text = "1";
            }
            else
            {
                label14.Text = "0";
            }
            jisuan(label14.Text, 14);
        }

        private void ex15(object sender, EventArgs e)
        {
            if (label15.Text == "0")
            {
                label15.Text = "1";
            }
            else
            {
                label15.Text = "0";
            }
            jisuan(label15.Text, 15);
        }

        private void ex16(object sender, EventArgs e)
        {
            if (label16.Text == "0")
            {
                label16.Text = "1";
            }
            else
            {
                label16.Text = "0";
            }
            jisuan(label16.Text, 16);
        }

        private void ex17(object sender, EventArgs e)
        {
            if (label17.Text == "0")
            {
                label17.Text = "1";
            }
            else
            {
                label17.Text = "0";
            }
            jisuan(label17.Text, 17);
        }

        private void ex18(object sender, EventArgs e)
        {
            if (label18.Text == "0")
            {
                label18.Text = "1";
            }
            else
            {
                label18.Text = "0";
            }
            jisuan(label18.Text, 18);
        }

        private void ex19(object sender, EventArgs e)
        {
            if (label19.Text == "0")
            {
                label19.Text = "1";
            }
            else
            {
                label19.Text = "0";
            }
            jisuan(label19.Text, 19);
        }

        private void ex20(object sender, EventArgs e)
        {
            if (label20.Text == "0")
            {
                label20.Text = "1";
            }
            else
            {
                label20.Text = "0";
            }
            jisuan(label20.Text, 20);
        }

        private void ex21(object sender, EventArgs e)
        {
            if (label21.Text == "0")
            {
                label21.Text = "1";
            }
            else
            {
                label21.Text = "0";
            }
            jisuan(label21.Text, 21);
        }

        private void ex22(object sender, EventArgs e)
        {
            if (label22.Text == "0")
            {
                label22.Text = "1";
            }
            else
            {
                label22.Text = "0";
            }
            jisuan(label22.Text, 22);
        }

        private void ex23(object sender, EventArgs e)
        {
            if (label23.Text == "0")
            {
                label23.Text = "1";
            }
            else
            {
                label23.Text = "0";
            }
            jisuan(label23.Text, 23);
        }

        private void ex24(object sender, EventArgs e)
        {
            if (label24.Text == "0")
            {
                label24.Text = "1";
            }
            else
            {
                label24.Text = "0";
            }
            jisuan(label24.Text, 24);
        }

        private void ex25(object sender, EventArgs e)
        {
            if (label25.Text == "0")
            {
                label25.Text = "1";
            }
            else
            {
                label25.Text = "0";
            }
            jisuan(label25.Text, 25);
        }

        private void ex26(object sender, EventArgs e)
        {
            if (label26.Text == "0")
            {
                label26.Text = "1";
            }
            else
            {
                label26.Text = "0";
            }
            jisuan(label26.Text, 26);
        }

        private void ex27(object sender, EventArgs e)
        {
            if (label27.Text == "0")
            {
                label27.Text = "1";
            }
            else
            {
                label27.Text = "0";
            }
            jisuan(label27.Text, 27);
        }

        private void ex28(object sender, EventArgs e)
        {
            if (label28.Text == "0")
            {
                label28.Text = "1";
            }
            else
            {
                label28.Text = "0";
            }
            jisuan(label28.Text, 28);
        }

        private void ex29(object sender, EventArgs e)
        {
            if (label29.Text == "0")
            {
                label29.Text = "1";
            }
            else
            {
                label29.Text = "0";
            }
            jisuan(label29.Text, 29);
        }

        private void ex30(object sender, EventArgs e)
        {
            if (label30.Text == "0")
            {
                label30.Text = "1";
            }
            else
            {
                label30.Text = "0";
            }
            jisuan(label30.Text, 30);
        }

        private void ex31(object sender, EventArgs e)
        {
            if (label31.Text == "0")
            {
                label31.Text = "1";
            }
            else
            {
                label31.Text = "0";
            }
            jisuan(label31.Text, 31);
        }
        private void ex32(object sender, EventArgs e)
        {
            if (label32.Text == "0")
            {
                label32.Text = "1";
            }
            else
            {
                label32.Text = "0";
            }
            jisuan(label32.Text, 32);
        }
        private void ex33(object sender, EventArgs e)
        {
            if (label33.Text == "0")
            {
                label33.Text = "1";
            }
            else
            {
                label33.Text = "0";
            }
            jisuan(label33.Text, 33);
        }
        private void ex34(object sender, EventArgs e)
        {
            if (label34.Text == "0")
            {
                label34.Text = "1";
            }
            else
            {
                label34.Text = "0";
            }
            jisuan(label34.Text, 34);
        }
        private void ex35(object sender, EventArgs e)
        {
            if (label35.Text == "0")
            {
                label35.Text = "1";
            }
            else
            {
                label35.Text = "0";
            }
            jisuan(label35.Text, 35);
        }
        private void ex36(object sender, EventArgs e)
        {
            if (label36.Text == "0")
            {
                label36.Text = "1";
            }
            else
            {
                label36.Text = "0";
            }
            jisuan(label36.Text, 36);
        }
        private void ex37(object sender, EventArgs e)
        {
            if (label37.Text == "0")
            {
                label37.Text = "1";
            }
            else
            {
                label37.Text = "0";
            }
            jisuan(label37.Text, 37);
        }
        private void ex38(object sender, EventArgs e)
        {
            if (label38.Text == "0")
            {
                label38.Text = "1";
            }
            else
            {
                label38.Text = "0";
            }
            jisuan(label38.Text, 38);
        }
        private void ex39(object sender, EventArgs e)
        {
            if (label39.Text == "0")
            {
                label39.Text = "1";
            }
            else
            {
                label39.Text = "0";
            }
            jisuan(label39.Text, 39);
        }
        private void ex40(object sender, EventArgs e)
        {
            if (label40.Text == "0")
            {
                label40.Text = "1";
            }
            else
            {
                label40.Text = "0";
            }
            jisuan(label40.Text, 40);
        }
        private void ex41(object sender, EventArgs e)
        {
            if (label41.Text == "0")
            {
                label41.Text = "1";
            }
            else
            {
                label41.Text = "0";
            }
            jisuan(label41.Text, 41);
        }
        private void ex42(object sender, EventArgs e)
        {
            if (label42.Text == "0")
            {
                label42.Text = "1";
            }
            else
            {
                label42.Text = "0";
            }
            jisuan(label42.Text, 42);
        }
        private void ex43(object sender, EventArgs e)
        {
            if (label43.Text == "0")
            {
                label43.Text = "1";
            }
            else
            {
                label43.Text = "0";
            }
            jisuan(label43.Text, 43);
        }
        private void ex44(object sender, EventArgs e)
        {
            if (label44.Text == "0")
            {
                label44.Text = "1";
            }
            else
            {
                label44.Text = "0";
            }
            jisuan(label44.Text, 44);
        }
        private void ex45(object sender, EventArgs e)
        {
            if (label45.Text == "0")
            {
                label45.Text = "1";
            }
            else
            {
                label45.Text = "0";
            }
            jisuan(label45.Text, 45);
        }
        private void ex46(object sender, EventArgs e)
        {
            if (label46.Text == "0")
            {
                label46.Text = "1";
            }
            else
            {
                label46.Text = "0";
            }
            jisuan(label46.Text, 46);
        }
        private void ex47(object sender, EventArgs e)
        {
            if (label47.Text == "0")
            {
                label47.Text = "1";
            }
            else
            {
                label47.Text = "0";
            }
            jisuan(label47.Text, 47);
        }
        private void ex48(object sender, EventArgs e)
        {
            if (label48.Text == "0")
            {
                label48.Text = "1";
            }
            else
            {
                label48.Text = "0";
            }
            jisuan(label48.Text, 48);
        }
        private void ex49(object sender, EventArgs e)
        {
            if (label49.Text == "0")
            {
                label49.Text = "1";
            }
            else
            {
                label49.Text = "0";
            }
            jisuan(label49.Text, 9);
        }
        private void ex50(object sender, EventArgs e)
        {
            if (label50.Text == "0")
            {
                label50.Text = "1";
            }
            else
            {
                label50.Text = "0";
            }
            jisuan(label50.Text, 50);
        }
        private void ex51(object sender, EventArgs e)
        {
            if (label51.Text == "0")
            {
                label51.Text = "1";
            }
            else
            {
                label51.Text = "0";
            }
            jisuan(label51.Text, 51);
        }
        private void ex52(object sender, EventArgs e)
        {
            if (label52.Text == "0")
            {
                label52.Text = "1";
            }
            else
            {
                label52.Text = "0";
            }
            jisuan(label52.Text, 52);
        }
        private void ex53(object sender, EventArgs e)
        {
            if (label53.Text == "0")
            {
                label53.Text = "1";
            }
            else
            {
                label53.Text = "0";
            }
            jisuan(label53.Text, 53);
        }
        private void ex54(object sender, EventArgs e)
        {
            if (label54.Text == "0")
            {
                label54.Text = "1";
            }
            else
            {
                label54.Text = "0";
            }
            jisuan(label54.Text, 54);
        }
        private void ex55(object sender, EventArgs e)
        {
            if (label55.Text == "0")
            {
                label55.Text = "1";
            }
            else
            {
                label55.Text = "0";
            }
            jisuan(label55.Text, 55);
        }
        private void ex56(object sender, EventArgs e)
        {
            if (label56.Text == "0")
            {
                label56.Text = "1";
            }
            else
            {
                label56.Text = "0";
            }
            jisuan(label56.Text, 56);
        }
        private void ex57(object sender, EventArgs e)
        {
            if (label57.Text == "0")
            {
                label57.Text = "1";
            }
            else
            {
                label57.Text = "0";
            }
            jisuan(label57.Text, 57);
        }
        private void ex58(object sender, EventArgs e)
        {
            if (label58.Text == "0")
            {
                label58.Text = "1";
            }
            else
            {
                label58.Text = "0";
            }
            jisuan(label58.Text, 58);
        }
        private void ex59(object sender, EventArgs e)
        {
            if (label59.Text == "0")
            {
                label59.Text = "1";
            }
            else
            {
                label59.Text = "0";
            }
            jisuan(label59.Text, 59);
        }
        private void ex60(object sender, EventArgs e)
        {
            if (label60.Text == "0")
            {
                label60.Text = "1";
            }
            else
            {
                label60.Text = "0";
            }
            jisuan(label60.Text, 60);
        }
        private void ex61(object sender, EventArgs e)
        {
            if (label61.Text == "0")
            {
                label61.Text = "1";
            }
            else
            {
                label61.Text = "0";
            }
            jisuan(label61.Text, 61);
        }
        private void ex62(object sender, EventArgs e)
        {
            if (label62.Text == "0")
            {
                label62.Text = "1";
            }
            else
            {
                label62.Text = "0";
            }
            jisuan(label62.Text, 62);
        }
        private void ex63(object sender, EventArgs e)
        {
            if (label63.Text == "0")
            {
                label63.Text = "1";
            }
            else
            {
                label63.Text = "0";
            }
            jisuan(label63.Text, 63);
        }
        private void ex64(object sender, EventArgs e)
        {
            if (label64.Text == "0")
            {
                label64.Text = "1";
            }
            else
            {
                label64.Text = "0";
            }
            jisuan(label64.Text, 64);
        }

        private void label79_Click(object sender, EventArgs e)
        {
            System.Environment.Exit(0);
        }

        private void textBox2_TextChanged(object sender, EventArgs e)
        {

        }
        //
    }
}

3.Form2.cs

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 System.Text.RegularExpressions;
using System.IO;

namespace _1._2
{


    public partial class Form2 : Form
    {
        public Form2()
        {
            InitializeComponent();
        }

        private static List temp = new List();

        private void button2_Click(object sender, EventArgs e)//CE按钮
        {
            textBox1.Text = "";
        }

        private void button5_Click(object sender, EventArgs e)
        {

        }

        private void Add(object sender, EventArgs e)
        {   //数字和符号的Click事件
            Button button = (Button)sender;
            textBox1.Text += button.Text;
        }

        private void button8_Click(object sender, EventArgs e)
        {

        }

        private void button3_Click(object sender, EventArgs e)//delect按钮
        {
            if (textBox1.TextLength > 0)
                textBox1.Text = textBox1.Text.Remove(textBox1.TextLength - 1);
        }

        private void button9_Click(object sender, EventArgs e)//“=”按钮
        {
            Cleanf();
            List zhonglist = ToList(textBox1.Text);
            List houlist = houzhui(zhonglist);
            List s = zhonglist;
            s.Add("=");
            s.Add(Calculate(houlist));
            string s1 = string.Join("", s);
            if (temp.Count > 9)//最多存十条记录
            {
                temp.RemoveAt(0);
            }
            temp.Add(s1);
            textBox2.Text = string.Join(",", temp);
            textBox1.Text = Calculate(houlist);
        }
        //中缀转List
        static List ToList(string s)
        {
            List ls = new List();//存放中缀表达式
            String str = "";               //拼接多位数、小数
            char c = ' ';                  //遍历输入的字符
            int i = 0;

            do
            {
                if ((s[i] == '-' && i == 0) || (i > 0 && s[i] == '-' && !char.IsDigit(s[i - 1])))//在负数前加零方便后续计算
                {
                    ls.Add("0");
                }
                if (!char.IsDigit(c = s[i]) && c != '.') //如果c不是数字和'.'，就加入ls
                {
                    ls.Add(c.ToString());
                    i++;    //i后移
                }
                else//如果是数字，需要考虑多位数
                {
                    str = "";   //先将str清空
                    while (i < s.Length && (char.IsDigit(c = s[i]) || c == '.'))
                    {
                        str += c;
                        i++;
                    }
                    ls.Add(str);
                }
            } while (i < s.Length);
            return ls;
        }
        static List houzhui(List ls)
        {
            //定义两个栈,一个存临时结果，一个存运算符
            Stack operators = new Stack();

            List num = new List();

            //遍历 ls
            foreach (var item in ls)
            {
                Regex regex = new Regex("[+-]?\\d+.?\\d*");//整数和浮点数
                //如果是一个数，则加入num
                if (regex.Match(item).Length > 0)
                {
                    num.Add(item);
                }
                else if (item.Equals("("))//Equals:比较是否相同
                {
                    operators.Push(item);
                }
                else if (item.Equals(")"))
                {
                    //如果是右括号,则依次弹出operators栈顶的运算符,并压入num,直到遇到左括号为止,并将这对括号丢弃
                    while (!operators.Peek().Equals("("))//Peek()返回顶部对象
                    {
                        num.Add(operators.Pop());
                    }
                    operators.Pop();   //将 ( 弹出
                }
                else
                {
                    //当item 的 优先级小于或等于operators栈顶运算符，将operators栈顶的运算符弹出并加入到num中，再次转到operators与operators中新的栈顶运算符比较
                    while (operators.Count != 0 && compare(operators.Peek()) >= compare(item))
                    {
                        num.Add(operators.Pop());
                    }
                    //还需要将 item 压入栈
                    operators.Push(item);
                }
            }

            //将operators中剩余的运算符依次弹出并加入num
            while (operators.Count != 0)
            {
                num.Add(operators.Pop());
            }

            return num;  //按顺序输出就是对应的后缀表达式对应的List
        }
        //运算符优先级
        public static int compare(string operation)
        {
            int res = 0;
            switch (operation)
            {
                case "+":
                    res = 1;
                    break;
                case "-":
                    res = 1;
                    break;
                case "^":
                    res = 3;
                    break;
                case "*":
                    res = 2;
                    break;
                case "÷":
                    res = 3;
                    break;
                case "%":
                    res = 4;
                    break;
                case "!":
                    res = 5;
                    break;
                default:
                    Console.WriteLine("不存在该运算符");
                    break;
            }
            return res;
        }
        //计算后缀表达式
        static string Calculate(List ls)
        {
            Regex regex = new Regex("[+-]?\\d+.?\\d*");
            //创建栈
            Stack stack = new Stack();
            //遍历 list
            foreach (var item in ls)
            {
                //使用正则表达式来取出数
                if (regex.Match(item).Length > 0) //如果是数字,就压入栈中
                {
                    stack.Push(regex.Match(item).Value);
                }
                else    //不是数就弹出两个数字进行计算
                {
                    double num2 = double.Parse(stack.Pop());
                    double num1 = double.Parse(stack.Pop());
                    double res = 0;
                    if (item.Equals("+"))
                    {
                        res = num1 + num2;
                    }
                    else if (item.Equals("-"))
                    {
                        res = num1 - num2;
                    }
                    else if (item.Equals("×"))
                    {
                        res = num1 * num2;
                    }
                    else if (item.Equals("÷"))
                    {
                        res = num1 / num2;
                    }
                    else if (item.Equals("%"))
                    {
                        res = num1 % num2;
                    }
                    else
                    {
                        throw new Exception("表达式有误");
                    }
                    stack.Push(res.ToString());
                }
            }

            //最后留在stack中的数据就是运算结果
            return stack.Pop();
        }
        private void Cleanf()
        {
            File.Delete("历史记录2.txt");
            FileStream f = File.Create("历史记录2.txt");
            f.Close();
        }

        private void button22_Click(object sender, EventArgs e)//“读取历史”按钮
        {
            StreamReader sr = new StreamReader("历史记录2.txt");
            String s;
            if ((s = sr.ReadLine() )!= null)
            {
                String[] s1 = s.Split(',');
                List s2 = new List(s1);
                temp = s2;
                textBox2.Text = string.Join(",", temp);
            }
            sr.Close();
        }

        private void button23_Click(object sender, EventArgs e)//“清除历史记录”
        {
            textBox2.Text = "";
            temp.Clear();
            Cleanf();
        }

        private void button24_Click(object sender, EventArgs e)
        {
            StreamWriter sw = new StreamWriter("历史记录2.txt");
            sw.WriteLine(string.Join(",", temp));
            sw.Close();
        }

        private void label1_Click(object sender, EventArgs e)
        {
            System.Environment.Exit(0);
        }

        private void textBox2_TextChanged(object sender, EventArgs e)
        {

        }
    }
    }

3.Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;

namespace _1._2
{
    static class Program
    {
        /// 
        /// 应用程序的主入口点。
        /// 
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            //跳转窗口


         Form2 EasyModel = new Form2();
         Form1 PerModel = new Form1(); 
         EasyModel.ShowDialog();
        for(int i=0;i<1;i++)
            {
                if (EasyModel.DialogResult == DialogResult.OK)
                {
                    PerModel.ShowDialog();
                }
                if (PerModel.DialogResult == DialogResult.Cancel)
                {
                    EasyModel.ShowDialog();
                    i = -1;
                }
             
            }
      

        }
    }
}

你可能感兴趣的:(课程设计,c#)

  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • 你可能遗漏的一些C#/.NET/.NET Core知识点 追逐时光者 C#.NETDotNetGuide编程指南c#.net.netcoremicrosoft
    前言在这个快速发展的技术世界中，时常会有一些重要的知识点、信息或细节被忽略或遗漏。《C#/.NET/.NETCore拾遗补漏》专栏我们将探讨一些可能被忽略或遗漏的重要知识点、信息或细节，以帮助大家更全面地了解这些技术栈的特性和发展方向。拾遗补漏GitHub开源地址https://github.com/YSGStudyHards/DotNetGuide/blob/main/docs/DotNet/D
  • C#动态加载DLL程序集及使用反射创建实例-简记 不全 C#相关Asp.netWebFormAsp.netMVCc#Assembly反射程序集
    Assembly动态加载程序集：分两种情况：1、需要加载的程序集已经在程序中被引用了，则直接从当前程序域中查找即可：Assemblyassembly=AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(x=>x.GetName().Name.Contains("theAssemblyName"));2、需要加载的程序集未被加载，则使用程序集
  • 开发游戏的学习规划 杰克逊的日记 游戏学习
    第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
  • python可以制作大型游戏_python能做游戏吗-python能开发游戏吗 靖dede python可以制作大型游戏
    python可以写游戏，但不适合。下面我们来分析一下具体原因。用锤子能造汽车吗？谁也没法说不能吧？历史上也确实曾经有些汽车，是用锤子造出来的。但一般来说，还是用工业机器人更合适对吗？比较大型的，使用Python的游戏有两个，一个是《EVE》，还有一个是《文明》。但这仅仅是个例，没有广泛意义。一般来说，用来做游戏的语言，有两种。一是C++。。一是C#。。Python理论上，不仅不适合做游戏，而是只要
  • 2023-04-18 夕彦
    躺在不想起，给自己找起来的理由care，照顾自己的身体心情和家人，安好连接和共创课程设计，会议和督导
  • 【C#生态园】深度剖析：C#嵌入式开发工具大揭秘 friklogff C#生态园c#开发语言
    C#嵌入式开发：全面了解六大框架与库前言随着物联网和嵌入式系统的快速发展，越来越多的开发者开始关注使用C#语言进行嵌入式开发。本文将介绍几种用于C#的嵌入式开发框架和相关库，以及它们的核心功能、安装配置方法和API概览，帮助读者了解并选择适合自己项目的工具和资源。欢迎订阅专栏：C#生态园文章目录C#嵌入式开发：全面了解六大框架与库前言1.nanoFramework：一个用于C#的嵌入式开发框架1.
  • Lua 与 C#交互 z2014z luac#开发语言
    Lua与C#交互前提Lua是一种嵌入式脚本语言，Lua的解释器是用C编写的，因此可以方便的与C/C++进行相互调用。轻量级Lua语言的官方版本只包括一个精简的核心和最基本的库，这使得Lua体积小、启动速度快，也适合嵌入在别的程序里。交互过程C#调用Lua:由C#文件调用Lua解析器底层dll库（由C语言编写），再由dll文件执行相应的Lua文件。Lua调用C#：1、Wrap方式：首先生成C#源文件
  • C# 开发教程-入门基础 天马3798 教程系列整理c#开发语言
    1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
  • C# 禁止程序重复启动 wiseyao1219 c#
    修改：Program.cs[STAThread]staticvoidMain(){Mutexmutex=newMutex(true,"NewGuid123456",outboolisCreatedNew);if(!isCreatedNew){MessageBox.Show(Application.ProductName+"isrunning...");return;}Application.Ena
  • C#中判断socket是否已断开的方法 wiseyao1219 c#
    代码如下：Sockets=newSocket(..);if(s.Poll(-1,SelectMode.SelectRead)){intnRead=s.Receive();if(nRead==0){//socket连接已断开}}参考：C#中判断socket是否已断开的方法
  • C#文件被占用的解决方案 花北城 C#项目文件占用
    问题打更新包时，提示文件被占用。System.IO.IOException:文件“D:\RS\RS_CCVI20111210.exe”正由另一进程使用，因此该进程无法访问该文件。在System.IO.__Error.WinIOError(Int32errorCode,StringmaybeFullPath)在System.IO.FileStream.Init(Stringpath,FileMode
  • C#实现软件自动升级 BruceEditCode
    winform程序相对web程序而言，功能更强大，编程更方便，但软件更新却相当麻烦，要到客户端一台一台地升级，本文结合实际情况，通过软件实现自动升级，弥补了这一缺陷，有较好的参考价值。由于程序在运行时不能用新的版本覆盖自己，因此，我们将登录窗口单独做成一个可执行文件，用户登录时，从网上检测是否有新的主程序，如果有，则从后台下载并覆盖老的版本，用户输入正确的用户名和密码后，通过参数将必要的信息（如用
  • C# 自动化 TineAine C#代码片段自动化c#自动化模拟操作
    实现的方法可能很笨，但是确实很好用usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Runtime.InteropServices;usingSystem.Text;usingSystem.Threading;usingSystem.Threading.Tasks;/******************
  • 技术周总结 09.09~09.15周日(C# WinForm WPF) 打破砂锅问到底007 wpfc#WinForm
    文章目录一、09.09周一1.1)问题01:Windows桌面开发中，WPF和WinForm的区别和联系？联系：区别：二、09.12周四2.1）问题01：visualstudio的相关快捷键有哪些？通用快捷键编辑导航调试窗口管理2.2）问题02：publicpartialclassChoosePLReason:CommonBaseForm2.3)问题03：介绍WindowsForms中的Syste
  • 通过C# 裁剪PDF页面 Eiceblue C#.NETPDFc#pdf开发语言visualstudio
    在处理PDF文档时，有时需要精确地裁剪页面以适应特定需求，比如去除广告、背景信息或者仅仅是为了简化文档内容。本文将指导如何使用免费.NET控件通过C#实现裁剪PDF页面。免费库FreeSpire.PDFfor.NET支持在.NET(C#,VB.NET,ASP.NET,.NETCore)程序中实现创建、操作、转换和打印PDF文档等操作。可以从以下链接下载产品包后手动添加引用，或者直接通过NuGet安
  • 【Unity基础】如何选择脚本编译方式Mono和IL2CPP？ tealcwu Unity基础unity游戏引擎
    Edit->ProjectSettings->Player在Unity中，ScriptingBackend决定了项目的脚本编译方式，即如何将C#代码转换为可执行代码。Unity提供了两种主要的ScriptingBackend选项：Mono和IL2CPP。它们之间的区别影响了项目的性能、平台支持、编译时间和调试体验。以下是两者的详细对比：1.Mono简介:Mono是Unity最早使用的脚本后端，基于
  • C# Tuple、ValueTuple 語衣 C#知识补充c#
    栏目总目录TupleTuple是C#4.0引入的一个新特性，主要用于存储一个固定数量的元素序列，且这些元素可以具有不同的类型。Tuple是一种轻量级的数据结构，非常适合用于临时存储数据，而无需定义完整的类或结构体。优点简便性：可以快速创建一个包含多个不同类型数据的对象，而无需定义新的类或结构体。灵活性：元素数量和类型在编译时确定，但可以在不同上下文中重复使用不同元素的Tuple。缺点性能：作为引用
  • C# Linq语句用法大全以及Lambda表达式 一个小码码 c#linq开发语言.net
    C#Linq语句用法大全以及Lambda表达式Linq：是一种用于数据查询和操作的语言集成查询（LanguageIntegratedQuery）技术。通过Linq，我们可以使用类似于SQL查询的方式来查询、筛选和操作各种类型的数据集合，包括数组、列表、集合、XML文档、数据库表等等。常见的有：LinqtoObjects：用于操作对象集合，例如数组、列表等。LinqtoXML：用于操作XML数据，支
  • C#中的LInq语句 weixin_30588907 c#数据库
    语言集成查询(LINQ)是一组技术的名称，这些技术建立在将查询功能直接集成到C#语言（以及VisualBasic和可能的任何其他.NET语言）的基础上。借助于LINQ，查询现在已是高级语言构造，就如同类、方法、事件等等。对于编写查询的开发人员来说，LINQ最明显的“语言集成”部分是查询表达式。查询表达式是使用C#3.0中引入的声明性查询语法编写的。通过使用查询语法，您甚至可以使用最少的代码对数据源
  • C#的linq语句 木生火18624 C#开发
    /查询表达式必须以form子句开头，以select或者group子句结束，在这两个子句之间，可以使用///where、orderby、join、let和其他的from子句本章要点用列表在对象上执行传统查询扩展方法LINQ查询操作符平行LNQ表达式树本章源代码下载地址(wrox.com)打开网页www.wrox.com/go/procsharp,单击DownloadCode选项卡即可下载本章源代码。
  • C# 多线程操作同一个文件，如何避免冲突 FlYFlOWERANDLEAF c#开发语言
    1使用lock经测试，依然存在线程冲突privatestaticobjectlocker=newobject();……lock(locker){stringbText=File.ReadAllText(FPath);returnbText;}……lock(locker){File.WriteAllText(FPath,aContent);}2使用ReaderWriterLockSlim经测试，依然
  • C#LINQ常用扩展语句 月落. C#c#linqsolr
    在C#中，LINQ提供了许多扩展方法，这些方法定义在System.Linq命名空间中。以下是一些常用的LINQ扩展方法：Where-过滤数据集合，返回满足条件的元素。varfilteredItems=collection.Where(item=>item.SomeProperty>10);Select-从数据集合中选择数据或创建新的投影。varprojectedItems=collection.S
  • source insight4.0中文乱码解决方法 鹿屿二向箔 c语言stm32keilmdk
    Sourceinsight是强大、顺手的代码编辑器，它几乎支持所有的语言，包括：C，C++，C#，HTML等等，能够自动创建并维护它自己高性能的符号数据库，包括函数、全局变量、结构、类和工程源文件里定义的其它类型的符号，对于大工程的源码阅读非常方便。但是因为是国外软件，对中文支持不是很好，很多电脑安装使用都会出现注释乱码问题，很让人抓狂。网上很多人遇到类似的问题，也有很多解决方式，也有很多“终极解
  • C#基础知识-.NET，变量，容量单位，数据类型 yi碗汤园 c#开发语言
    目录1.NET简介2.变量1）定义2）声明3）赋值3.容量单位4.数据类型1）整形(整数)2）非整型(小数)3）非数值型本篇文章来分享一下C#的基础知识，主要讲述一下变量和数据类型的相关知识。1.NET简介.NETdonet是Microsoft新一代多语言的开发平台，用于构建和运行应用程序。Unity借助Mono实现跨平台，核心是.NETFramework框架。2.变量1）什么是变量变量是用来存储
  • C# 在WPF中实现图表生成 A_nanda WPF赏析c#wpf开发语言
    在现代应用程序中，数据可视化是一个重要的功能，它可以帮助用户更直观地理解数据。在C#WPF（WindowsPresentationFoundation）中，有多种方式可以生成图表。以下是五种常见的方法，每种方法都有其独特的优势和局限。1.使用System.Windows.Shapes命名空间代码示例：<RectangleWidth="50"Height="50"Fill="Blue"Canva
  • C#中关闭窗口清除内容 Vae_Mars AI对话中的其他知识c#开发语言
    1.解释说明-窗口关闭时是可以执行函数的，可以做一部分事件处理-因为删除文件夹的方案不好做，所以改成清空文件夹内的内容2.程序示例publicMainWindow(){InitializeComponent();//检查窗口关闭this.Closing+=MainWindow_Closing;}//执行具体的方法privatevoidMainWindow_Closing(objectsender,
  • 大三时MySQL课程设计《MySQL集群的研究与实现》 weixin_30908941 数据库嵌入式php
    河南中医学院《MySQL数据库管理》课程设计报告题目：MySQL集群的研究与实现完成日期：2012年12月31日目录1.课程设计题目概述.32.研究内容与目的.33.研究方法.43.1研究方法………………………………………………………………………..43.2实验方法…………………………………………………………………………53.3可行性分析..…………………………………………………………………………
  • C#中Invoke的用法（） 世界太过浮夸 .netc#
    转自：http://www.cnblogs.com/lsgsanxiao/p/5523282.htmlinvoke和begininvoke区别一直对invoke和begininvoke的使用和概念比较混乱，这两天看了些资料，对这两个的用法和原理有了些新的认识和理解。首先说下，invoke和begininvoke的使用有两种情况：control中的invoke、begininvoke。delegra
  • .NET常见面试题汇总 .Net Core 爱好者 .netc#
    首先，汇总一共分为三部分：一是关于.NET技术的面试问题，二是关于.NET项目中的实际问题，三是历年出现过一些面试题汇总一、.NET技术面试问题请简述.NET中的装箱和拆箱。什么是泛型，以及它在.NET中的用途？请解释一下C#中的委托是什么，以及它们如何工作？什么是事件，如何使用它们？请解释一下C#中的特性(Attributes)及其应用场景。.NET中的异步编程模式有哪些？什么是LINQ，它在.
  • jvm调优总结（从基本概念 到 深度优化） oloz javajvmjdk虚拟机应用服务器
    JVM参数详解：http://www.cnblogs.com/redcreen/archive/2011/05/04/2037057.html   Java虚拟机中，数据类型可以分为两类：基本类型和引用类型。基本类型的变量保存原始值，即：他代表的值就是数值本身；而引用类型的变量保存引用值。“引用值”代表了某个对象的引用，而不是对象本身，对象本身存放在这个引用值所表示的地址的位置。
  • 【Scala十六】Scala核心十：柯里化函数 bit1129 scala
    本篇文章重点说明什么是函数柯里化，这个语法现象的背后动机是什么，有什么样的应用场景，以及与部分应用函数(Partial Applied Function)之间的联系   1. 什么是柯里化函数 A way to write functions with multiple parameter lists. For instance def f(x: Int)(y: Int) is a
  • HashMap dalan_123 java
    HashMap在java中对很多人来说都是熟的；基于hash表的map接口的非同步实现。允许使用null和null键；同时不能保证元素的顺序；也就是从来都不保证其中的元素的顺序恒久不变。 1、数据结构     在java中，最基本的数据结构无外乎：数组 和 引用（指针），所有的数据结构都可以用这两个来构造，HashMap也不例外，归根到底HashMap就是一个链表散列的数据
  • Java Swing如何实时刷新JTextArea，以显示刚才加append的内容 周凡杨 java更新swingJTextArea
    在代码中执行完textArea.append("message")后，如果你想让这个更新立刻显示在界面上而不是等swing的主线程返回后刷新，我们一般会在该语句后调用textArea.invalidate()和textArea.repaint()。 问题是这个方法并不能有任何效果，textArea的内容没有任何变化，这或许是swing的一个bug，有一个笨拙的办法可以实现
  • servlet或struts的Action处理ajax请求 g21121 servlet
    其实处理ajax的请求非常简单，直接看代码就行了： //如果用的是struts //HttpServletResponse response = ServletActionContext.getResponse(); // 设置输出为文字流 response.setContentType("text/plain"); // 设置字符集 res
  • FineReport的公式编辑框的语法简介 老A不折腾 finereport公式总结
    FINEREPORT用到公式的地方非常多，单元格（以=开头的便被解析为公式），条件显示，数据字典，报表填报属性值定义，图表标题，轴定义，页眉页脚，甚至单元格的其他属性中的鼠标悬浮提示内容都可以写公式。 简单的说下自己感觉的公式要注意的几个地方：   1.if语句语法刚接触感觉比较奇怪，if(条件式子,值1,值2)，if可以嵌套，if(条件式子1，值1，if(条件式子2，值2，值3)
  • linux mysql 数据库乱码的解决办法 墙头上一根草 linuxmysql数据库乱码
    linux 上mysql数据库区分大小写的配置 lower_case_table_names=1 1-不区分大小写 0-区分大小写   修改/etc/my.cnf 具体的修改内容如下:   [client] default-character-set=utf8   [mysqld] datadir=/var/lib/mysql socket=/va
  • 我的spring学习笔记6-ApplicationContext实例化的参数兼容思想 aijuans Spring 3
    ApplicationContext能读取多个Bean定义文件，方法是： ApplicationContext appContext = new ClassPathXmlApplicationContext（ new String[]｛“bean-config1.xml”，“bean-config2.xml”，“bean-config3.xml”，“bean-config4.xml
  • mysql 基准测试之sysbench annan211 基准测试mysql基准测试MySQL测试sysbench
    1 执行如下命令，安装sysbench-0.5： tar xzvf sysbench-0.5.tar.gz  cd sysbench-0.5  chmod +x autogen.sh  ./autogen.sh  ./configure --with-mysql --with-mysql-includes=/usr/local/mysql
  • sql的复杂查询使用案列与技巧 百合不是茶 oraclesql函数数据分页合并查询
      本片博客使用的数据库表是oracle中的scott用户表;          -------------------  自然连接查询           查询 smith 的上司(两种方法) &
  • 深入学习Thread类 bijian1013 javathread多线程java多线程
    一．             线程的名字 下面来看一下Thread类的name属性，它的类型是String。它其实就是线程的名字。在Thread类中，有String getName()和void setName(String)两个方法用来设置和获取这个属性的值。 同时，Thr
  • JSON串转换成Map以及如何转换到对应的数据类型 bijian1013 javafastjsonnet.sf.json
            在实际开发中，难免会碰到JSON串转换成Map的情况，下面来看看这方面的实例。另外，由于fastjson只支持JDK1.5及以上版本，因此在JDK1.4的项目中可以采用net.sf.json来处理。 一.fastjson实例 JsonUtil.java package com.study; impor
  • 【RPC框架HttpInvoker一】HttpInvoker：Spring自带RPC框架 bit1129 spring
    HttpInvoker是Spring原生的RPC调用框架，HttpInvoker同Burlap和Hessian一样，提供了一致的服务Exporter以及客户端的服务代理工厂Bean，这篇文章主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成   在 【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中
  • 【Mahout二】基于Mahout CBayes算法的20newsgroup的脚本分析 bit1129 Mahout
    #!/bin/bash # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information re
  • nginx三种获取用户真实ip的方法 ronin47
    随着nginx的迅速崛起，越来越多公司将apache更换成nginx. 同时也越来越多人使用nginx作为负载均衡, 并且代理前面可能还加上了CDN加速，但是随之也遇到一个问题：nginx如何获取用户的真实IP地址,如果后端是apache,请跳转到<apache获取用户真实IP地址>，如果是后端真实服务器是nginx，那么继续往下看。 实例环境： 用户IP 120.22.11.11
  • java-判断二叉树是不是平衡 bylijinnan java
    参考了 http://zhedahht.blog.163.com/blog/static/25411174201142733927831/ 但是用java来实现有一个问题。 由于Java无法像C那样“传递参数的地址，函数返回时能得到参数的值”，唯有新建一个辅助类：AuxClass import ljn.help.*; public class BalancedBTree {
  • BeanUtils.copyProperties VS PropertyUtils.copyProperties 诸葛不亮 PropertyUtilsBeanUtils
     BeanUtils.copyProperties VS  PropertyUtils.copyProperties  作为两个bean属性copy的工具类，他们被广泛使用，同时也很容易误用，给人造成困然；比如：昨天发现同事在使用BeanUtils.copyProperties copy有integer类型属性的bean时，没有考虑到会将null转换为0，而后面的业
  • [金融与信息安全]最简单的数据结构最安全 comsci 数据结构
          现在最流行的数据库的数据存储文件都具有复杂的文件头格式，用操作系统的记事本软件是无法正常浏览的，这样的情况会有什么问题呢？        从信息安全的角度来看，如果我们数据库系统仅仅把这种格式的数据文件做异地备份，如果相同版本的所有数据库管理系统都同时被攻击，那么
  • vi区段删除 Cwind linuxvi区段删除
    区段删除是编辑和分析一些冗长的配置文件或日志文件时比较常用的操作。简记下vi区段删除要点备忘。   vi概述    引文中并未将末行模式单独列为一种模式。单不单列并不重要，能区分命令模式与末行模式即可。   vi区段删除步骤： 1. 在末行模式下使用:set nu显示行号 非必须，随光标移动vi右下角也会显示行号，能够正确找到并记录删除开始行
  • 清除tomcat缓存的方法总结 dashuaifu tomcat缓存
    用tomcat容器，大家可能会发现这样的问题，修改jsp文件后，但用IE打开 依然是以前的Jsp的页面。 出现这种现象的原因主要是tomcat缓存的原因。 解决办法如下: 在jsp文件头加上 <meta http-equiv="Expires" content="0"> <meta http-equiv="kiben&qu
  • 不要盲目的在项目中使用LESS CSS dcj3sjt126com Webless
    　如果你还不知道LESS CSS是什么东西，可以看一下这篇文章，是我一朋友写给新人看的《CSS——LESS》 　　不可否认，LESS CSS是个强大的工具，它弥补了css没有变量、无法运算等一些“先天缺陷”，但它似乎给我一种错觉，就是为了功能而实现功能。 　　比如它的引用功能 ? .rounded_corners{     
  • [入门]更上一层楼 dcj3sjt126com PHPyii2
    更上一层楼 通篇阅读完整个“入门”部分，你就完成了一个完整 Yii 应用的创建。在此过程中你学到了如何实现一些常用功能，例如通过 HTML 表单从用户那获取数据，从数据库中获取数据并以分页形式显示。你还学到了如何通过 Gii 去自动生成代码。使用 Gii 生成代码把 Web 开发中多数繁杂的过程转化为仅仅填写几个表单就行。 本章将介绍一些有助于更好使用 Yii 的资源：
  • Apache HttpClient使用详解 eksliang httpclienthttp协议
    Http协议的重要性相信不用我多说了，HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性（具体区别，日后我们再讨论），它不仅是客户端发送Http请求变得容易，而且也方便了开发人员测试接口（基于Http协议的），即提高了开发的效率，也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会
  • zxing二维码扫描功能 gundumw100 androidzxing
    经常要用到二维码扫描功能 现给出示例代码 import com.google.zxing.WriterException; import com.zxing.activity.CaptureActivity; import com.zxing.encoding.EncodingHandler; import android.app.Activity; import an
  • 纯HTML+CSS带说明的黄色导航菜单 ini htmlWebhtml5csshovertree
    HoverTree带说明的CSS菜单:纯HTML+CSS结构链接带说明的黄色导航   在线体验效果：http://hovertree.com/texiao/css/1.htm代码如下,保存到HTML文件可以看到效果：   <!DOCTYPE html > <html > <head> <title>HoverTree
  • fastjson初始化对性能的影响 kane_xie fastjson序列化
    之前在项目中序列化是用thrift，性能一般，而且需要用编译器生成新的类，在序列化和反序列化的时候感觉很繁琐，因此想转到json阵营。对比了jackson，gson等框架之后，决定用fastjson，为什么呢，因为看名字感觉很快。。。   网上的说法：   fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴的工程师开发。
  • 基于Mybatis封装的增删改查实现通用自动化sql mengqingyu DAO
    1.基于map或javaBean的增删改查可实现不写dao接口和实现类以及xml，有效的提高开发速度。 2.支持自定义注解包括主键生成、列重复验证、列名、表名等 3.支持批量插入、批量更新、批量删除 <bean id="dynamicSqlSessionTemplate" class="com.mqy.mybatis.support.Dynamic
  • js控制input输入框的方法封装(数字，中文，字母，浮点数等) qifeifei javascript js
    在项目开发的时候，经常有一些输入框，控制输入的格式，而不是等输入好了再去检查格式，格式错了就报错，体验不好。 /** 数字，中文，字母,浮点数(+/-/.) 类型输入限制，只要在input标签上加上 jInput="number,chinese,alphabet,floating" 备注：floating属性只能单独用*/     funct
  • java 计时器应用 tangqi609567707 javatimer
    mport java.util.TimerTask;   import java.util.Calendar;   public class MyTask extends TimerTask {        private static final int
  • erlang输出调用栈信息 wudixiaotie erlang
    在erlang otp的开发中，如果调用第三方的应用，会有有些错误会不打印栈信息，因为有可能第三方应用会catch然后输出自己的错误信息，所以对排查bug有很大的阻碍，这样就要求我们自己打印调用的栈信息。用这个函数：erlang:process_display (self (), backtrace).需要注意这个函数只会输出到标准错误输出。 也可以用这个函数：erlang:get_s
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他