python随机点名小游戏 随机点名编程

功能描述：

1.导入班级名单（excel）

2.随机生成两个学生（当前的和下一个的）

3.对当前的学生进行星级评价

4.评价过的学生加入右侧的历史记录栏

5.保存历史记录到本地

编程语言：C#

主要算法也就是随机算法：

1.先随机产生两个人

2.从两个人中选择一个被点到次数较少的一个（增加一定公平性）

最终界面效果图：

代码清单：

模型类：

学生

using System;

namespace stdCall.Models
{
    /// <summary>
    /// 学生模型类：姓名，学号，被点名次数
    /// </summary>
    class Student
    {
        private String name;
        private String number;
        private int unluckyCallNum;
       /* private String message;*/

        public int UnluckyCallNum
        {
            get { return unluckyCallNum; }
            set { unluckyCallNum = value; }
        }
     
        public Student(String number, String name)
        {
            this.name = name;
            this.number = number;
        }

        public Student(String number, String name ,int unluckyCallNum)
        {
            this.name = name;
            this.number = number;
            this.unluckyCallNum = unluckyCallNum;
        }

        public String Number
        {
            get { return number; }
            set { number = value; }
        }

        public String Name
        {
            get { return name; }
            set { name = value; }
        }

        public String getMessage()
        {
            return (number + "," + name);
        }

 
    }
}

点名模型

using System;

namespace stdCall.Models
{
    /// <summary>
    /// 点名模型类：id，学生号，星级，课程号
    /// </summary>
    class UnluckyCall
    {
        private String id;
        private String studentid;
        private int star;
        private int courseID;

        public UnluckyCall()
        {
            id = "";
            studentid = "";
            star = 0;
            courseID = 0;
        }

        public UnluckyCall(String id, String studentid, int star, int courseNum)
        {
            this.id = id;
            this.studentid = studentid;
            this.star = star;
            this.courseID = courseNum;
        }

        public UnluckyCall( String studentid, int star, int courseNum)
        {
            this.studentid = studentid;
            this.star = star;
            this.courseID = courseNum;
        }

        internal String Studentid
        {
            get { return studentid; }
            set { studentid = value; }
        }

        public int Star
        {
            get { return star; }
            set { star = value; }
        }

        public int CourseID
        {
            get { return courseID; }
            set { courseID = value; }
        }

        public String Id
        {
            get { return id; }
            set { id = value; }
        }

        /// <summary>
        /// 获得模型类的信息
        /// </summary>
        /// <returns></returns>
        public String getMessage()
        {
            return ("id:" + id + ",studentid:" + studentid + ",star:" + star.ToString() + ",courseID:" + courseID.ToString() + "");
        }
    }
}

模型管理类：

学生管理

using stdCall.MyUtils;
using System;
using System.Collections;

namespace stdCall.Models
{
    /// <summary>
    /// 学生管理类，学生表为静态Hash表
    /// </summary>
    class StudentsManager
    {
        private static Hashtable students = new Hashtable();

        public static Hashtable Students
        {
            get { return StudentsManager.students; }
            set { StudentsManager.students = value; }
        }

        /// <summary>
        /// 根据学号获取学生
        /// </summary>
        /// <param name="studentNum"></param>
        /// <returns></returns>
        public Student getStudentByNum(String studentNum)
        {
         //   Student student=null;

            return (Student)students[studentNum];
        }

        /// <summary>
        /// 获取所有学生，返回排序后的ArrayList
        /// </summary>
        /// <returns></returns>
        public ArrayList getAllStudents()
        {
            ArrayList stds = new ArrayList();
            foreach (DictionaryEntry de in students)
            {
                stds.Add((Student)(de.Value));
            }
            stds.Sort(new StudentCompare());
            return stds;
        }

        /// <summary>
        /// 添加一个学生
        /// </summary>
        /// <param name="studentNum"></param>
        /// <param name="name"></param>
        public void addStudent(String studentNum , String name)
        {
            students.Add(studentNum, new Student(studentNum, name));
        }

        /// <summary>
        /// 添加一个学生
        /// </summary>
        /// <param name="studentNum"></param>
        /// <param name="name"></param>
        /// <param name="unluckyNum">被点名次数</param>
        public void addStudent(String studentNum, String name,int unluckyNum)
        {
            students.Add(studentNum, new Student(studentNum, name, unluckyNum));
        }
      
// 
//         public Student getAPoorStdFairly()
//         {
//             Student student = null;
// 
//             return student;
//         }


//         public bool loadStudents()
//         {
//             bool flag = false;
//             return flag;
//         }

    }
}

点名模型管理

using System;
using System.Collections;

namespace stdCall.Models
{
    /// <summary>
    /// 点名模型管理器，点名表unluckyCalls为静态
    /// </summary>
    class UnluckyCallsManager
    {
        private static Hashtable unluckyCalls = new Hashtable();
        private static int callid = 0;

        public static Hashtable UnluckyCalls
        {
            get { return UnluckyCallsManager.unluckyCalls; }
            set { UnluckyCallsManager.unluckyCalls = value; }
        }

        /// <summary>
        /// 根据学生号获取点名次数
        /// </summary>
        /// <param name="studentnum"></param>
        /// <returns>点名次数</returns>
        public int getCallNumByStdNum(String studentnum){
            int num = 0;
            foreach (DictionaryEntry de in unluckyCalls)
            {
                UnluckyCall uc = (UnluckyCall)de.Value;
                if (uc.Studentid.Equals(studentnum))
                {
                    num++;
                }
            }
            return num;
        }

        /************************************************************************/
        /* bug                                                                     */
        /************************************************************************/
        public ArrayList getCallsByStdNum(String studentnum){
            ArrayList unluckycalls = new ArrayList();
            foreach (DictionaryEntry de in unluckyCalls)
            {
                UnluckyCall uc = (UnluckyCall)de.Value;
                if (uc.Studentid.Equals(studentnum))
                {
                    unluckycalls.Add(uc);
                }
            }
            return unluckycalls;
        }

        /// <summary>
        /// 根据课程号获取点名的学生列表
        /// </summary>
        /// <param name="courseid"></param>
        /// <returns>学生列表</returns>
        public ArrayList getPoolStdsByCourseID(int courseid)
        {
            ArrayList students = new ArrayList();
            foreach (DictionaryEntry de in unluckyCalls)
            {
                UnluckyCall uc = (UnluckyCall)de.Value;
                if (uc.CourseID==courseid)
                {
                    students.Add(new StudentsManager().getStudentByNum(uc.Studentid));
                }
            }
            return students;
        }

        /************************************************************************/
        /* BUG                                                                     */
        /************************************************************************/
        /// <summary>
        /// BUG，未实现
        /// </summary>
        /// <param name="studentnum"></param>
        /// <param name="courseid"></param>
        /// <returns></returns>
        public int getStarBySNumCID(String studentnum,int courseid)
        {
            String id = getCallID();
            return ((UnluckyCall)unluckyCalls[id]).Star;
        }

        /// <summary>
        /// 添加一个点名
        /// </summary>
        /// <param name="studentNum"></param>
        /// <param name="star"></param>
        /// <param name="courseID"></param>
        public void addUnluckyCall(String studentNum ,int star, int courseID)
        {
            String id = getCallID();
            unluckyCalls.Add(id, new UnluckyCall(id, studentNum, star, courseID));
        }
// 
//         public bool loadUnluckyCalls()
//         {
//             bool flag = false;
//             return flag;
//         }

        /// <summary>
        /// 获取点名ID
        /// </summary>
        /// <returns></returns>
        public String getCallID()
        {
            callid++;
            return callid.ToString();
        }


      
    }
}

读取excel的类（可重用）

using System;
using System.Collections.Generic;
using Excel = Microsoft.Office.Interop.Excel;

namespace stdCall.MyExcel
{
    /// <summary>
    /// Excel读取类
    /// </summary>
    class ExcelHelper
    {
        private Excel._Application excelApp;
        private string fileName = string.Empty;
        private Excel.WorkbookClass wbclass;
        public ExcelHelper(string _filename)
        {
            excelApp = new Excel.Application();
            object objOpt = System.Reflection.Missing.Value;
            wbclass = (Excel.WorkbookClass)excelApp.Workbooks.Open(_filename, objOpt, false, objOpt, objOpt, objOpt, true, objOpt, objOpt, true, objOpt, objOpt, objOpt, objOpt, objOpt);
        }
        /// <summary>
        /// 所有sheet的名称列表
        /// </summary>
        /// <returns></returns>
        public List<string> GetSheetNames()
        {
            List<string> list = new List<string>();
            Excel.Sheets sheets = wbclass.Worksheets;
            string sheetNams = string.Empty;
            foreach (Excel.Worksheet sheet in sheets)
            {
                list.Add(sheet.Name);
            }
            return list;
        }
        /// <summary>
        /// 获取sheet表
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public Excel.Worksheet GetWorksheetByName(string name)
        {
            Excel.Worksheet sheet = null;
            Excel.Sheets sheets = wbclass.Worksheets;
            foreach (Excel.Worksheet s in sheets)
            {
                if (s.Name == name)
                {
                    sheet = s;
                    break;
                }
            }
            return sheet;
        }
        /// <summary>
        /// 获取sheetName的所有内容
        /// </summary>
        /// <param name="sheetName">sheet名称</param>
        /// <returns></returns>
        public Array GetContent(string sheetName)
        {
            Excel.Worksheet sheet = GetWorksheetByName(sheetName);
            //获取A1 到AM24范围的单元格
            Excel.Range rang = sheet.get_Range("A1", "B200");
            //读一个单元格内容
            //sheet.get_Range("A1", Type.Missing);
            //不为空的区域,列,行数目
            //   int l = sheet.UsedRange.Columns.Count;
            // int w = sheet.UsedRange.Rows.Count;
            //  object[,] dell = sheet.UsedRange.get_Value(Missing.Value) as object[,];
            System.Array values = (Array)rang.Cells.Value2;
            // double d=(double)values.GetValue(1,1);
            return values;
        }

        /// <summary>
        /// 关闭文件
        /// </summary>
        public void Close()
        {
            excelApp.Quit();
            excelApp = null;
        }

    }
}

读取excel并导入文本文件的类

using stdCall.File;
using stdCall.MyExcel;
using stdCall.Resource;
using stdCall;
using System;
using System.Windows.Forms;

namespace stdCall.MyExcel
{
    /// <summary>
    /// 提供导入excel模块的服务
    /// </summary>
    class ExcelService
    {
        ExcelHelper excelHelper ;
        /// <summary>
        /// 倒入excel主函数
        /// </summary>
        /// <returns></returns>
        public bool loadExcel(){
            bool flag = false;
            try
            {
                OpenFileDialog ofd = new OpenFileDialog();                //new一个方法
                ofd.Filter = "excel文件(*.xls)|*.xls|所有文件(*.*)|*.*";
                //  ofd.InitialDirectory = Environment.GetFolderPath_r(Environment.SpecialFolder.MyDocuments); //定义打开的默认文件夹位置
                ofd.ShowDialog();
                if (ofd.FileName == null || ofd.FileName == "") return false;
                excelHelper = new ExcelHelper(ofd.FileName);
                FileHelper fileHelper = new FileHelper();
                fileHelper.openWriteFile(ResourseLoader.FileSTDSPath, false);
                Array stds = excelHelper.GetContent("Sheet1");
                excelHelper.Close();
                int y = 1;
                do
                {
                    String stdnum = (stds.GetValue(y, 1)).ToString();
                    fileHelper.writeSingleData(stdnum);
                    String stdname = stds.GetValue(y, 2).ToString().Trim();
                    fileHelper.writeSingleData(stdname);
                    y++;
                } while (stds.GetValue(y, 1) != null);
                fileHelper.closeFile();
                flag = true;
            }
            catch (System.Exception ex)
            {
                flag = false;
            }
            return flag;
        }
    }
}

读写文件类（可重用）

using System;
using System.IO;
using System.Windows.Forms;

namespace stdCall.File
{
    /// <summary>
    /// 文本文件读写类，File为静态类
    /// </summary>
    class FileHelper
    {
        private static StreamReader readFile;
        private static StreamWriter writeFile;

        public static StreamReader ReadFile
        {
            get { return FileHelper.readFile; }
            set { FileHelper.readFile = value; }
        }

        public static StreamWriter WriteFile
        {
            get { return FileHelper.writeFile; }
            set { FileHelper.writeFile = value; }
        }

        /// <summary>
        /// 打开读文件，未确认是否关闭
        /// </summary>
        /// <param name="filepath"></param>
        /// <returns></returns>
        public  bool openReadFile(String filepath)
        {
            bool flag = false;
            try
            {
                readFile = new StreamReader(filepath);
                flag = true;
            }
            catch (System.Exception ex)
            {
                Console.Write(ex.Message);
            }
            return flag;
        }

        /// <summary>
        /// 打开写文件，未确认是否关闭，默认添加内容到尾部
        /// </summary>
        /// <param name="filepath"></param>
        /// <returns></returns>
        public bool openWriteFile(String filepath)
        {
            bool flag = false;
            try
            {
                writeFile = new StreamWriter(filepath,true);
                flag = true;
            }
            catch (System.Exception ex)
            {
                Console.Write(ex.Message);
            }
            return flag;
        }

        /// <summary>
        /// 打开写文件，可选择是否覆盖
        /// </summary>
        /// <param name="filepath"></param>
        /// <param name="apendFlag">false为覆盖</param>
        /// <returns></returns>
        public bool openWriteFile(String filepath,bool apendFlag)
        {
            bool flag = false;
            try
            {
                writeFile = new StreamWriter(filepath, apendFlag);
                flag = true;
            }
            catch (System.Exception ex)
            {
                Console.Write(ex.Message);
            }
            return flag;
        }

        /// <summary>
        /// 确认是否关闭，并关闭文件
        /// </summary>
        /// <returns></returns>
        public  bool closeFile()
        {
            bool flag = false;
            try
            {
                if (readFile != null)
                {
                    readFile.Close();
                }
                if (writeFile != null)
                {
                    writeFile.Close();
                }
                flag = true;
            }
            catch (System.Exception ex)
            {
                Console.Write(ex.Message);
                flag = false;
            }
            return flag;
        }

        /// <summary>
        /// 读取一行数据
        /// </summary>
        /// <returns></returns>
        public  String readSingleData()
        {
            String data = null;
            try
            {
                if (!ReadFile.EndOfStream)
                {
                    data=readFile.ReadLine().Trim();
                }
            }
            catch (System.Exception ex)
            {
                Console.Write(ex.Message);
            }
            return data;
        }

        /// <summary>
        /// 写入一行数据
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public  bool writeSingleData(String data)
        {
            bool flag = false;
            try
            {
                writeFile.WriteLine(data);
                flag = true;
            }
            catch (System.Exception ex)
            {
                Console.Write("writeSingleData:" + ex.Message);
                ThreadExceptionDialog warnDialog = new ThreadExceptionDialog(ex);
                warnDialog.ShowDialog();
                flag = false;
            }
            return flag;
        }
    }
}

读取文件并转换为模型的类

using stdCall.File;
using stdCall.Models;
using stdCall;
using System;
using System.Windows.Forms;

namespace stdCall.Resource
{
    /// <summary>
    /// 资源加载类，包含名单和点名的文本文件路径（静态）
    /// </summary>
    class ResourseLoader
    {
        private StudentsManager studentManager = new StudentsManager();
        private UnluckyCallsManager unluckyCallsManager = new UnluckyCallsManager();
        private static  String fileSTDSPath = @".\students.txt";
        private static String fileCourseIDPath = @".\course.txt";
   /*     public static Hashtable static_controls = new Hashtable();*/


        public static String FileCourseIDPath
        {
            get { return ResourseLoader.fileCourseIDPath; }
            set { ResourseLoader.fileCourseIDPath = value; }
        }

        public static String FileSTDSPath
        {
            get { return ResourseLoader.fileSTDSPath; }
        }

        private static  String fileUCSPath = @".\unluckycalls.txt";

        public static String FileUCSPath
        {
            get { return ResourseLoader.fileUCSPath; }
        } 

        private FileHelper fileHelper = new FileHelper();
        public static int CourseID = 0;


        /// <summary>
        /// 加载所有系统资源（学生列表，点名历史，课程ID）
        /// </summary>
        public void loadSystemResourse()
        {
            loadUnluckyCalls();
            loadStudents();
        }

        /// <summary>
        /// 加载学生表
        /// </summary>
        public void loadStudents()
        {
            fileHelper.openReadFile(fileSTDSPath);
            while (!FileHelper.ReadFile.EndOfStream)
            {
                String stdNum = fileHelper.readSingleData();
                String stdName = fileHelper.readSingleData();
                new StudentsManager().addStudent(stdNum,stdName,new UnluckyCallsManager().getCallNumByStdNum(stdNum));
            }
            fileHelper.closeFile();
        }

        /// <summary>
        /// 加载点名历史表
        /// </summary>
        public void loadUnluckyCalls()
        {
            fileHelper.openReadFile(fileUCSPath);
            while (!FileHelper.ReadFile.EndOfStream)
            {
                String stdNum = fileHelper.readSingleData();
                String star = fileHelper.readSingleData();
                String courseID = fileHelper.readSingleData();

                new UnluckyCallsManager().addUnluckyCall(stdNum, int.Parse(star), int.Parse(courseID));
            }
            fileHelper.closeFile();
        }

        /// <summary>
        /// 加载课程ID，未实现
        /// </summary>
        public void loadCourseID()
        {
          /*  CourseID = 2;*/
            fileHelper.openReadFile(fileCourseIDPath);
            CourseID = int.Parse(fileHelper.readSingleData().Trim())+1;
            fileHelper.closeFile();
        }


        /// <summary>
        /// 设置此堂课程编号
        /// </summary>
        /// <param name="courseid"></param>
        public void setCourseID(int courseid)
        {
            CourseID = courseid;
            FileHelper fh = new FileHelper();
            fh.closeFile();
            fh.openWriteFile(ResourseLoader.FileCourseIDPath,false);
            try
            {
                fh.writeSingleData(courseid.ToString());
            }
            catch (System.Exception ex)
            {
                ThreadExceptionDialog warnDialog = new ThreadExceptionDialog(ex);
                warnDialog.ShowDialog();
            }
            fh.closeFile();
        }


    }
}

随机算法模块：

服务类

using stdCall.MyAnimate;
using stdCall.Models;
using stdCall;

namespace stdCall.MyRandom
{
    /// <summary>
    /// 提供核心随机服务
    /// </summary>
    class RandomService
    {
        public static Student currentStudent;
        public static Student nextStudent;
        private StudentsManager studentManager = new StudentsManager();

        /// <summary>
        /// 点击random按钮触发，随机主函数，包括动画
        /// 先做当前学生Label的动画（做 AnimateService.animateNum次：获取随机学生，进行动画）
        /// 再做下一个学生Label的动画（做 AnimateService.animateNum次：Service.getAnimateService().animateNextResulted()）
        /// </summary>
        public void startRandom(){
            AnimateService animateService = new AnimateService();
            Student std = null;
            int num = AnimateService.animateNum;
            System.Collections.ArrayList stds = studentManager.getAllStudents();
            for (int i = 0; i < num; i++)
            {
                std = Caculator.getAPoorStdNum(stds);
                animateService.animateCurrentStd(std, i);
            }
            RandomService.currentStudent = std;
            RandomService.nextStudent=animateService.animateNextAndReturnStd();
        }
    }
}

具体算法实现类

using stdCall.Models;
using System;
using System.Collections;

namespace stdCall.MyRandom
{
    /// <summary>
    /// 核心算法类
    /// </summary>
    class Caculator
    {
        public static int RandomStdNum = 2;

        /// <summary>
        /// 按算法获取一个可怜的学生
        /// </summary>
        /// <param name="calllist">包含点名次数的学生列表</param>
        /// <returns>学生</returns>
        public static Student getAPoorStdNum(ArrayList calllist)
        {
            int index= decideFinally(calllist, randomFirstly(calllist.Count));
            Student std=(Student)calllist[index];
            new StudentsManager().getStudentByNum(std.Number).UnluckyCallNum++;
            return std;
        }

        /// <summary>
        /// 初始随机产生RandomStdNum个学生索引
        /// </summary>
        /// <param name="range">随机数范围</param>
        /// <returns>RandomStdNum个学生索引数组</returns>
        public static int[] randomFirstly(int range)
        {
            int[] s=new int[RandomStdNum];
            for (int i = 0; i < RandomStdNum; i++)
            {
                s[i] = -1;
            }
                s = getRandomNum(RandomStdNum, 0, range);
            return s;
        }

        /// <summary>
        /// 按公平算法决定最终的倒霉鬼索引
        /// </summary>
        /// <param name="calllist">包含点名次数的学生列表</param>
        /// <param name="students">初始随机产生的学生索引数组</param>
        /// <returns>最终倒霉鬼索引</returns>
        public static int decideFinally(ArrayList calllist,int []students)
        {
            int luckiestStudent = 0;
            int fairness = 1000;
            for (int i = 0; i < RandomStdNum; i++)
            {
                ArrayList ca = new ArrayList();
                foreach (Student std in calllist)
                {
                    ca.Add(new Student(std.Number,std.Name,std.UnluckyCallNum));
                }
                int index = students[i];
                ((Student)(ca[index])).UnluckyCallNum++;
                if (computeUnlucky(ca) < fairness)
                {
                    luckiestStudent = students[i];
                    fairness = computeUnlucky(ca);
                }
            }
            return luckiestStudent;
        }

        /// <summary>
        /// 计算公平值，各个学生倒霉值的平方的和
        /// </summary>
        /// <param name="calllist">包含点名次数的学生列表</param>
        /// <returns>公平值</returns>
        public static int computeUnlucky(ArrayList calllist)
        {
            int result = 0;
            foreach(Student std in calllist){
                result += std.UnluckyCallNum * std.UnluckyCallNum;
            }
            return result;
        }

        /// <summary>
        /// 随机产生num个数
        /// </summary>
        /// <param name="num"></param>
        /// <param name="minValue">范围最小值（包含）</param>
        /// <param name="maxValue">范围最大值（不包含）</param>
        /// <returns></returns>
        private static int[] getRandomNum(int num, int minValue, int maxValue)
        {
            Random ra = new Random(unchecked((int)DateTime.Now.Ticks));
            int[] arrNum = new int[num];
            int tmp = 0;
            for (int i = 0; i <= num - 1; i++)
            {
                tmp = ra.Next(minValue, maxValue); //随机取数
                arrNum[i] = getNum(arrNum, tmp, minValue, maxValue, ra); //取出值赋到数组中
            }
            return arrNum;
        }

        /// <summary>
        /// 递归，确保随机不重复
        /// </summary>
        /// <param name="arrNum"></param>
        /// <param name="tmp"></param>
        /// <param name="minValue"></param>
        /// <param name="maxValue"></param>
        /// <param name="ra"></param>
        /// <returns></returns>
        private static int getNum(int[] arrNum, int tmp, int minValue, int maxValue, Random ra)
        {
            int n = 0;
            while (n <= arrNum.Length - 1)
            {
                if (arrNum[n] == tmp) //利用循环判断是否有重复
                {
                    tmp = ra.Next(minValue, maxValue); //重新随机获取。
                    getNum(arrNum, tmp, minValue, maxValue, ra);//递归:如果取出来的数字和已取得的数字有重复就重新随机获取。
                }
                n++;
            }
            return tmp;
        }
    }
}

评价模块：

评价服务

using stdCall.MyRandom;
using stdCall.Resource;
using stdCall.TotalService;
using stdCall;
using System.Windows.Forms;
using stdCall.MyUtils;

namespace stdCall.MyEvaluation
{
    /// <summary>
    /// 继承ResourceGet，提供评价模块的服务
    /// </summary>
    class EvaluateService:ResourceGet
    {
        Evaluation evaluation = new Evaluation();

        /// <summary>
        /// 评价主函数
        /// 点击星星触发
        /// 因为逻辑和第一次不同，判断是否已做了第一次随机，没有不继续
        /// 添加当前学生到历史记录
        /// 改变RandomService.currentStudent=RandomService.nextStudent;
        /// 延迟，让星星保留一段时间
        /// </summary>
        /// <param name="sender">点击的星星</param>
        public void evaluateCurrentStd(object sender){
            if (RandomService.nextStudent == null || RandomService.currentStudent == null)
            {
                return;
            }
            Panel panel_history = (Panel)resources["panel_history"];
            evaluation.markStarAndAddHisLabel((PictureBox)sender, RandomService.currentStudent, panel_history.Controls);
            Utils.Delay(500);
            FormMain.clearStars();
            Service.getAnimateService().animateCurrentStd(RandomService.nextStudent, 1);
            RandomService.currentStudent = RandomService.nextStudent;
            RandomService.nextStudent=Service.getAnimateService().animateNextAndReturnStd();
            //Utils.Delay(100);
        }
    }
}

评价具体实现的类

using stdCall.History;
using stdCall.Models;
using stdCall.Resource;
using System;
using System.Collections;
using System.Windows.Forms;

namespace stdCall.MyEvaluation
{
    /// <summary>
    /// 评价类
    /// </summary>
    class Evaluation
    {

        public static ArrayList picStars;
        public static int historyPosx = 0;
        public static int historyPosy = 0;
        public static Label latestHistoryLabel = new Label();
        private static bool firstFlag = true;

        private const int blankInside = 5;
        private const int blankOutside = 10;
        private const int picStarHeight = 20;
        /// <summary>
        /// 待优化，评分，并生成星级图片到历史记录栏，直接添加至外部容器，并返回一个包含学生姓名的历史记录Label，在外部添加
        /// </summary>
        /// <param name="picstar">星级评价（0-5）</param>
        /// <param name="currentStd"></param>
        /// <param name="collection">容器类</param>
        /// <returns>包含学生姓名的历史记录Label</returns>
        public void markStarAndAddHisLabel(PictureBox picstar, Student currentStd,Control.ControlCollection collection)
        {
            
            if (currentStd == null) return ;
            int stars = 0;
            foreach (PictureBox pb in picStars)
            {
                if (pb != picstar)
                {
                    pb.Load("star_yellow.png");
                    stars++;
                }
                else
                {
                    pb.Load("star_yellow.png");
                    stars++;
                    break;
                }
            }

            new StudentsManager().getStudentByNum(currentStd.Number).UnluckyCallNum++;
            new CurrentHistory().addUnluckyCall(currentStd.Number,stars,ResourseLoader.CourseID);
            if (firstFlag)
            {
                latestHistoryLabel = generateHistoryLabelStars(collection, currentStd.Name, stars, historyPosx, historyPosy);
                firstFlag = false;
            }
            else
            {
                latestHistoryLabel = generateHistoryLabelStars(collection, currentStd.Name, stars, latestHistoryLabel);
            }
            collection.Add(latestHistoryLabel);
        }


        private Label generateHistoryLabelStars(Control.ControlCollection collection, String text, int stars, Label label)
        {
      
            generateHistoryStar(collection, stars, label.Location.X, label.Location.Y + label.Size.Height * 2 + picStarHeight + blankInside*2 + blankOutside);
            return generateLabel(text, label.Location.X, label.Location.Y + label.Size.Height + blankOutside + picStarHeight+blankInside);
        }

        /// <summary>
        /// 生成一个历史记录Label
        /// </summary>
        /// <param name="text">Label内容</param>
        /// <param name="posx">Label位置x</param>
        /// <param name="posy">Label位置y</param>
        /// <returns></returns>
        public Label generateHistoryLabel(String text, int posx, int posy)
        {
            historyPosy += 45;
            return generateLabel(text,posx,posy);
        }

        /// <summary>
        /// 生成星级图片到历史记录栏，直接添加至外部容器，并返回一个包含学生姓名的历史记录Label，在外部添加
        /// </summary>
        /// <param name="collection">外部容器</param>
        /// <param name="text"></param>
        /// <param name="stars">星级（0-5）</param>
        /// <param name="posx"></param>
        /// <param name="posy"></param>
        /// <returns></returns>
        public Label generateHistoryLabelStars(Control.ControlCollection collection,String text, int stars,int posx, int posy)
        {
           /* historyPosy += 65;*/
            Label lable=generateLabel(text, posx, posy);
            generateHistoryStar(collection, stars,posx, posy +lable.Size.Height+blankInside);
            return lable;
        }

        /// <summary>
        /// 生成并返回一个Label
        /// </summary>
        /// <param name="text"></param>
        /// <param name="posx"></param>
        /// <param name="posy"></param>
        /// <returns></returns>
        private Label generateLabel(String text, int posx, int posy)
        {
            Label mylabel = new Label();
            mylabel.AutoSize = true;
            mylabel.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
            mylabel.Font = new System.Drawing.Font("Buxton Sketch", 21.75F, ((System.Drawing.FontStyle)((System.Drawing.FontStyle.Bold | System.Drawing.FontStyle.Italic))), System.Drawing.GraphicsUnit.Point, ((byte)(0)));
            mylabel.Location = new System.Drawing.Point(posx, posy);
            mylabel.Size = new System.Drawing.Size(164, 38);
            mylabel.TabIndex = 1;
            mylabel.Text = text;
            return mylabel;
        }

        /// <summary>
        /// 根据评分生成历史记录栏的星级，直接添加至外部容器
        /// </summary>
        /// <param name="collection">外部容器</param>
        /// <param name="stars"></param>
        /// <param name="posx"></param>
        /// <param name="posy"></param>
        public void generateHistoryStar(Control.ControlCollection collection,int stars,int posx,int posy){
            int starPosX = posx;
            int starPosY = posy;
            for (int i = 0; i < stars; i++)
            {

                System.Windows.Forms.PictureBox pictureBox_star;
                pictureBox_star = new System.Windows.Forms.PictureBox();
                pictureBox_star.Location = new System.Drawing.Point(starPosX, starPosY);
                pictureBox_star.Name = "pictureBox_stars";
                pictureBox_star.Size = new System.Drawing.Size(picStarHeight, picStarHeight);
                pictureBox_star.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
                pictureBox_star.TabIndex = 3;
                pictureBox_star.TabStop = false;
               /* pictureBox_star.Click += new System.EventHandler(this.pictureBox_stars_Click);*/
                pictureBox_star.Load("star_yellow.png");
                collection.Add(pictureBox_star);
               // picStars.Add(pictureBox_star);
                starPosX += 25;
            }
        }
    }
}

历史记录模块：

历史记录服务类

using stdCall;

namespace stdCall.History
{
    /// <summary>
    /// 提供保存当前历史的服务
    /// </summary>
    class HistoryService
    {
        CurrentHistory currentHistory = new CurrentHistory();
        /// <summary>
        /// 保存当前历史主函数
        /// </summary>
        /// <returns></returns>
        public bool saveCurrentHistory()
        {
            bool flag = false;
            try
            {
                currentHistory.save();
                flag = true;
            }
            catch (System.Exception ex)
            {
                flag = false;
            }
            return flag;
        }
    }
}

历史记录模型类

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

namespace stdCall.History
{
    class unluckSavingCall:UnluckyCall
    {
        private bool saveflag = false;

        public unluckSavingCall(string studentid, int star, int courseNum)
        {
            // TODO: Complete member initialization
            this.Studentid = studentid;
            this.Star = star;
            this.CourseID = courseNum;
        }

        /// <summary>
        /// 防止重复保存
        /// </summary>
        public bool Saveflag
        {
            get { return saveflag; }
            set { saveflag = value; }
        }
    }
}

历史记录具体实现类

using stdCall.File;
using stdCall.Models;
using stdCall.Resource;
using System;
using System.Collections;
using System.Windows.Forms;

namespace stdCall.History
{
    /// <summary>
    /// 历史记录类
    /// </summary>
    class CurrentHistory
    {
        public static ArrayList unluckSavingCalls = new ArrayList();

        /// <summary>
        /// 保存历史记录到ResouseLoader.FileUCSPath
        /// </summary>
        /// <returns></returns>
        public bool save(){
            new FileHelper().closeFile();
            new FileHelper().openWriteFile(ResourseLoader.FileUCSPath);
            bool flag = true;
            foreach (unluckSavingCall uc in unluckSavingCalls)
            {
                if (!uc.Saveflag)
                {
                    try
                    {
                        new FileHelper().writeSingleData(uc.Studentid);
                        new FileHelper().writeSingleData(uc.Star.ToString());
                        new FileHelper().writeSingleData(uc.CourseID.ToString());
                        uc.Saveflag = true;
                    }
                    catch (System.Exception ex)
                    {
                        flag = false;
                        ThreadExceptionDialog warnDialog = new ThreadExceptionDialog(ex);
                        warnDialog.ShowDialog();
                        uc.Saveflag = false;
                    }
                }
            }
            new FileHelper().closeFile();
            return flag;
        }

        /// <summary>
        /// 添加一个点名
        /// </summary>
        /// <param name="studentid"></param>
        /// <param name="star"></param>
        /// <param name="courseNum"></param>
        public void addUnluckyCall(String studentid, int star, int courseNum)
        {
            unluckSavingCalls.Add(new unluckSavingCall(studentid, star, courseNum));
        }

        public void getHistoryCalls()
        {

        }
        /// <summary>
        /// 删除历史记录，未实现
        /// </summary>
        /// <param name="studentnum"></param>
        public void delCallByStdNum(int studentnum)
        {

        }

        

    }
}

所有服务获取类

using stdCall.MyAnimate;
using stdCall.MyEvaluation;
using stdCall.MyExcel;
using stdCall.MyRandom;
namespace stdCall.TotalService
{
    /// <summary>
    /// 总服务类，即各模块服务获取类
    /// </summary>
    class Service
    {

        public static stdCall.Resource.ResourseServer getResouseService()
        {
            return new stdCall.Resource.ResourseServer();
        }

        public static RandomService getRandomService()
        {
            return new RandomService();
        }

        public static EvaluateService getEvaluateService()
        {
            return new EvaluateService();
        }


        public static ExcelService getExcelService()
        {
            return new ExcelService();
        }

        public static AnimateService getAnimateService()
        {
            return new AnimateService();
        }

        public static stdCall.History.HistoryService getHistoryService()
        {
            return new stdCall.History.HistoryService();
        }

    }
}

界面类实现

using stdCall;
using stdCall.MyEvaluation;
using stdCall.Models;
using stdCall.TotalService;
using System;
using System.Collections;
using System.Windows.Forms;

namespace stdCall
{
    /// <summary>
    /// 主页面
    /// </summary>
    public partial class FormMain : Form
    {
        ArrayList historyStds = new ArrayList();
        static ArrayList picStars = new ArrayList();
        StudentsManager studentManager = new StudentsManager();
        UnluckyCallsManager unluckyCallsManager = new UnluckyCallsManager();
        /// <summary>
        /// 
        /// </summary>
        public FormMain()
        {
            FormMain.CheckForIllegalCrossThreadCalls = false;
            InitializeComponent();
            sendControlsToModles();
            Service.getResouseService().loadSystemResourse();
            new CourseDialog().ShowDialog();
            generateStars();
            Evaluation.picStars = picStars;
        }

        /// <summary>
        /// 让需要空间的模块获取控件
        /// </summary>
        private void sendControlsToModles()
        {
            Service.getAnimateService().addResource("label_currentStd", this.label_currentStd);
            Service.getAnimateService().addResource("label_hideCurrentStd", this.label_hideCurrentStd);
            Service.getAnimateService().addResource("label_nextStd", this.label_nextStd);
            Service.getAnimateService().addResource("label_hideNextStd", this.label_hideNextStd);
            Service.getAnimateService().addResource("panel_current", this.panel_current);
            Service.getAnimateService().addResource("panel_nextstd", this.panel_nextstd);
            Service.getEvaluateService().addResource("panel_history", this.panel_history);
        }

        /// <summary>
        /// 生成星级（黑），并加入容器
        /// </summary>
        private void generateStars()
        {
            int starSize = 52;
            int starPosX = this.label_currentStd.Width / 2 - starSize;
            int starPosY = 0;

            for (int i = 0; i < 5; i++)
            {

                System.Windows.Forms.PictureBox pictureBox_star;
                pictureBox_star = new System.Windows.Forms.PictureBox();
                pictureBox_star.Cursor = System.Windows.Forms.Cursors.Hand;
                pictureBox_star.Location = new System.Drawing.Point(starPosX, starPosY);
                pictureBox_star.Name = "pictureBox_stars";
                pictureBox_star.Size = new System.Drawing.Size(starSize, starSize);
                pictureBox_star.SizeMode = System.Windows.Forms.PictureBoxSizeMode.StretchImage;
                pictureBox_star.TabIndex = 3;
                pictureBox_star.TabStop = false;
                pictureBox_star.Click += new System.EventHandler(this.pictureBox_stars_Click);
                pictureBox_star.Load("star_black.png");
                this.panel_star.Controls.Add(pictureBox_star);
                picStars.Add(pictureBox_star);
                starPosX += starSize+8;
            }
        }

        
        /// <summary>
        /// 星级初始化并随机产生倒霉鬼
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button_random_Click(object sender, EventArgs e)
        {
            clearStars();
            Service.getRandomService().startRandom();
        }
    
        /// <summary>
        /// 星星变黑，初始化
        /// </summary>
        public static void  clearStars()
        {
            foreach (PictureBox pb in picStars)
            {
                pb.Load("star_black.png");
            }
        }


        /// <summary>
        /// 星级的评价，点击可评价，不可修改
        /// </summary>
        /// <param name="sender">点击的图片</param>
        /// <param name="e"></param>
        private void pictureBox_stars_Click(object sender, EventArgs e)
        {
            Service.getEvaluateService().evaluateCurrentStd(sender);
           // clearStars();
        }

        /// <summary>
        /// 保存当前历史记录
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button_save_Click(object sender, EventArgs e)
        {
            stdCall.View.DialogReply reply = new stdCall.View.DialogReply();
            if (Service.getHistoryService().saveCurrentHistory())
            {
                reply.setReply("当前历史保存成功！");
                reply.ShowDialog();
            }
            else
            {
                reply.setReply("当前历史保存失败，请检查！");
                reply.ShowDialog();
            }
        }

        /// <summary>
        /// 点击加载excel（班级名单）
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button_loadExcel_Click(object sender, EventArgs e)
        {
            stdCall.View.DialogReply reply = new stdCall.View.DialogReply();
            if (Service.getExcelService().loadExcel())
            {
                reply.setReply("班级名单导入成功！");
                reply.ShowDialog();
                //reply.Dispose();
            }
            else
            {
                reply.setReply("班级名单导入失败，请检查！");
                reply.ShowDialog();
            }
        }

 
   

    }
}

课程ID询问对话框

using stdCall;
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 stdCall.TotalService;
using stdCall.Resource;

namespace stdCall
{
    /// <summary>
    /// 课程设置对话框
    /// </summary>
    public partial class CourseDialog : Form
    {
        /// <summary>
        /// 
        /// </summary>
        public CourseDialog()
        {
            InitializeComponent();
            ResourseLoader rl=new ResourseLoader();
            rl.loadCourseID();
            textBox_courseID.Text = ResourseLoader.CourseID.ToString();
        }

        private void button_ok_Click(object sender, EventArgs e)
        {
            try
            {
            	int courseid = int.Parse(textBox_courseID.Text);
                new ResourseLoader().setCourseID(int.Parse(textBox_courseID.Text));
                this.Dispose();
            }
            catch (System.Exception ex)
            {
                ThreadExceptionDialog td = new ThreadExceptionDialog(ex);
                td.ShowDialog();
            }
        }

       
    }
}

操作回复对话框

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;

namespace stdCall.View
{
    /// <summary>
    /// 操作回复对话框
    /// </summary>
    public partial class DialogReply : Form
    {
        public DialogReply()
        {
            InitializeComponent();
        }
        public void setReply(String text){
            this.label_reply.Text = text;
        }

        private void button_ok_Click(object sender, EventArgs e)
        {
            this.Dispose();
        }
    }
}

实用类（目前只有延迟函数）

using System;
using System.Windows.Forms;

namespace stdCall.MyUtils
{
    /// <summary>
    /// 实用类
    /// </summary>
    class Utils
    {
        /// <summary>
        /// 延迟函数，毫秒级
        /// </summary>
        /// <param name="delayTime">延迟时间，毫秒级</param>
        /// <returns></returns>
        public static bool Delay(int delayTime)
        {
            DateTime now = DateTime.Now;
            int s;
            do
            {
                TimeSpan spand = DateTime.Now - now;
                s = spand.Milliseconds;
                Application.DoEvents();
            }
            while (s < delayTime);
            return true;
        }
    }
}

学生排序类

using stdCall.Models;
namespace stdCall.MyUtils
{
    /// <summary>
    /// 学生ArrayList的排序规则：学号升序
    /// </summary>
    class StudentCompare : System.Collections.IComparer
    {
        public int Compare(object x, object y)
        {
            return int.Parse(((Student)x).Number) - int.Parse(((Student)y).Number);
        }
    }
  
}