精华内容
下载资源
问答
  • c#期末作业
    千次阅读
    2018-02-09 20:15:08

    一直以来我都想做一个爬虫程序,想了解它的原理。虽然学了一学期的计算机网络和操作系统,但是对网络编程和多线程依然是云里雾里。通过这次C#开发技术的期末大作业,不仅实现了我一直以来想做的爬虫程序,也学到了很多,总算对多线程编程有了一点初步的了解,了解了爬虫的原理。果然是实践出真知。

    下载地址:https://pan.baidu.com/s/1smJFksd

    因为只是一个工具,所以界面就比较简单,一开始我实现的只是将爬取的网页下载到对应目录(先根据网址建好文件夹),爬取图片的是后来加上去的。

    代码不贴了,下载后也能看到的。


    爬虫工作流程如下:


    改进方向:

          1.爬虫与数据库

             数据库保存爬出来的数据

             数据库简单整理爬出来的数据

          2.应对“反爬”的网站

    更多相关内容
  • 教师管理系统,用C#写的,学校实训的时候做的,内含所用的数据库
  • 期末 作业 图书管理系统 ,C#2005 自己的期末作业。 可能不是很完善。 在借书方面,验证不够。。。 时间充促。。。
  • c#期末作业

    2015-06-17 18:17:37
    c#期末作业
  • 基于控制台应用和数据库的C#期末作业
  • C#期末作业通讯录C#期末作业通讯录C#期末作业通讯录
  • C#期末作业—基于Unity实现多智能体协同建图C#期末作业—基于Unity实现多智能体协同建图C#期末作业—基于Unity实现多智能体协同建图C#期末作业—基于Unity实现多智能体协同建图C#期末作业—基于Unity实现...
  • C#期末作业点餐系统.rar
  • c# - 期末作业:俄罗斯方块

    千次阅读 2020-01-11 20:56:06
    c# - 期末作业:俄罗斯方块总体视图 & 废话集结区代码(全)FormMain.csProgram.csBrick.csBrick1.csBrick2.csBrick3.csBrick4.csBrick5.csBrick6.csBrick7.csBricks.csCanvas.cs现存bug 总体视图 & 废话...

    总体视图 & 废话集结区

    具体介绍传送门,请点!!!!!

    然后放图
    1111
    这个大作业真的是写吐了当时。。。。

    实现功能有:
    随机生成砖块并显示
    实现砖块的旋转和自动下落
    有背景音乐,砖块消除和游戏失败的音效
    玩家可以选择停止播放背景音乐

    先是那啥消除整行那里判断不对。。。。强行改了两个下午勉强能看,多行消除还有bug。。。。想创新点想很久,最后弄了个背景音乐的开关 && 两个样品的叠加播放,当时查了和流是有关系的,百度了很多东西也搞不明白到底是怎么操作的就很糟心了;;;;好在后面解决了

    终于,全部搞完,调试完准备录视频的时候,不对,全部录完视频&&加完那啥,,,文字解释之后意识到,。。,老师要求的作业是口头演示(然而我之前找到满绩学长的视频是没有讲话的///难道是我记错了。应该不会。所以上课的时候重新录了一个,极其嘈杂///掩面哭泣,这可能就是我成绩不好的原因吧 555555

    资源下载

    c# - 期末大作业:俄罗斯方块,点击下载
    俄罗斯方块

    代码(全)

    FormMain.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.Media;
    using System.Threading;
    using System.Runtime.InteropServices; 
    
    namespace OhMyTetris
    {
        public partial class FormMain : Form
        {
            #region 私有属性
    
            //画布模型
            private Canvas m_canvas;   
     
            //画布
            private Graphics m_picture;  
    
            //用于显示下一个砖块的画布
            private Graphics m_nextpic;
    
            //装载声音文件
            private SoundPlayer m_bgm = new SoundPlayer("bgm.wav");
            private SoundPlayer m_gameover = new SoundPlayer("gameover.wav");
            private SoundPlayer m_disappear = new SoundPlayer("disappear.wav");
    
            private float m_x;
            private float m_y;
            private bool m_isrun;
    
            #endregion
    
            #region 停止背景音乐的播放
    
            [DllImport("winmm.DLL",EntryPoint = "PlaySound",
                SetLastError = true,CharSet = CharSet.Unicode,ThrowOnUnmappableChar = true)]
            private static extern bool PlaySound(string szSound, System.IntPtr hMod,PlaySoundFlags flags);
            [System.Flags]
            public enum PlaySoundFlags : int
            {
                SND_SYNC = 0x0000, //同步播放声音,在播放完后PlaySound函数才返回
                SND_ASYNC = 0x0001, //用异步方式播放声音,PlaySound函数在开始播放后立即返回
                SND_NODEFAULT = 0x0002, //不播放缺省声音,若无此标志,则PlaySound在没找到声音时会播放缺省声音
                SND_LOOP = 0x0008, //重复播放声音,必须与SND_ASYNC标志一块使用
                SND_NOSTOP = 0x0010, //PlaySound不打断原来的声音播出并立即返回FALSE
                SND_NOWAIT = 0x00002000, //如果驱动程序正忙则函数就不播放声音并立即返回
                SND_FILENAME = 0x00020000, //pszSound参数指定了WAVE文件名
                SND_RESOURCE = 0x00040004 //pszSound参数是WAVE资源的标识符,这时要用到hmod参数
            }
    
            public void runSound()
            {
                PlaySound("bgm.wav", IntPtr.Zero,PlaySoundFlags.SND_ASYNC | PlaySoundFlags.SND_FILENAME | PlaySoundFlags.SND_LOOP);
            }
            #endregion
    
            //开启或禁止背景音乐事件:
            private void buttonPlayMusic_Click(object sender, EventArgs e)
            {
                //如果是音符,就停止播放背景乐
                if (buttonPlayMusic.Text == "🈲")
                {
                    PlaySound(null, IntPtr.Zero, PlaySoundFlags.SND_ASYNC);
                    buttonPlayMusic.Text = "🎵";
                }
                //如果显示是音乐,就重新播放背景乐
                else
                {
                    m_bgm.PlayLooping();
                    buttonPlayMusic.Text = "🈲";
                }
            }
    
            public FormMain()
            {
                InitializeComponent();
    
                //设置label和picture的Parent属性为pictureHole,显示更自然
                labelIntroduction.Parent = pictureBoxHole;
                labelScore.Parent = pictureBoxHole;
                labelGameover.Parent = pictureBox1;
                pictureBox2.Parent = pictureBoxHole;
                pictureBox1.Parent = pictureBoxHole;
                buttonPlayMusic.Parent = pictureBoxHole;
    
                pictureBox1.Focus();
    
                m_canvas = new Canvas();
    
                m_picture = pictureBox1.CreateGraphics();
                m_nextpic = pictureBox2.CreateGraphics();
    
                m_x = pictureBox1.Width / m_canvas.m_Columns;
                m_y = pictureBox1.Height / m_canvas.m_Rows;
    
                timer1.Enabled = false;
            }
    
            private void timer1_Tick(object sender, EventArgs e)
            {
                //如果有些还没结束
                //错误:无法将方法组“Run”转换为非委托类型“bool”。
                //改正:在后面加个括号就好了
                if (m_canvas.Run() == true)
                {
                    Draw();
                    DrawNext();
                    DrawScore();
                }
                else
                {
                    timer1.Enabled = false;
                    if (m_canvas.m_Score >= 100)
                    {
                        //MessageBox.Show("游戏结束!胜利!");
                    }
                    else
                    {
                        Graphics g = CreateGraphics();
                        labelGameover.Visible = true;
                        m_gameover.Play();
                        buttonStop.Enabled = false;
                    }
                }
            }
    
            //自定义方法:创建画布
            private void Draw()
            {
                Bitmap canvas = new Bitmap(pictureBox1.Width, pictureBox1.Height);
                
                //从canvas创建新的graphics
                Graphics g = Graphics.FromImage(canvas);
    
                for (int i = 0; i < m_canvas.m_Rows; i++)
                {
                    for (int j = 0; j < m_canvas.m_Columns; j++)
                    {
                        if (m_canvas.m_Arr[i, j] == 0)
                        {
                            continue;
                        }
                        else
                        {
                            DrawItem(g, i, j);
                        }
                    }
                }
                pictureBox1.BackgroundImage = canvas;
                pictureBox1.Refresh();
            }
    
            //自定义方法:显示游戏窗口
            private void DrawItem(Graphics g, int row, int column)
            {
                float xpos = column * m_x - 1;
                float ypos = row * m_y - 1;
                g.FillRectangle(Brushes.Orange, xpos, ypos, m_x - 2, m_y - 2);
            }
    
            //自定义方法:显示下一个砖块
            private void DrawNext()
            {
                pictureBox2.Refresh();
                m_canvas.DrawNewxBrick(m_nextpic, m_x, m_y);
            }
    
            //自定义方法:显示当前得分
            private void DrawScore()
            {
                string temp = "当前得分:" + (m_canvas.m_Score*10).ToString() + "分";
                labelScore.Text = temp;
            }
    
            protected override bool ProcessDialogKey(Keys keyData)
            {
                if (keyData == Keys.Up || keyData == Keys.Down || keyData == Keys.Left || keyData == Keys.Right)
                {
                    return false;
                }
                return base.ProcessDialogKey(keyData);
            }
    
            //键盘响应事件:
            private void FormMain_KeyDown(object sender, KeyEventArgs e)
            {
                Keys key = e.KeyCode;
                if (m_isrun == true)
                {
                    if (key == Keys.Up)
                    {
                        pictureBox1.Refresh();
                        m_canvas.BrickUp();
                        Draw();
                    }
                    if (key == Keys.Left)
                    {
                        pictureBox1.Refresh();
                        m_canvas.BrickLeft();
                        Draw();
                    }
                    if (key == Keys.Right)
                    {
                        pictureBox1.Refresh();
                        m_canvas.BrickRight();
                        Draw();
                    }
                    if (key == Keys.Down)
                    {
                        pictureBox1.Refresh();
                        m_canvas.BrickDown();
                        Draw();
                    }
                }
            }
    
            //开始事件:
            private void buttonBegin_Click(object sender, EventArgs e)
            {
                if (buttonBegin.Text == "开   始")
                {
                    buttonBegin.Text = "重新开始";
                }
                else 
                {
                    m_isrun = false;
                    timer1.Enabled = false;
                }
                m_canvas = new Canvas();
                buttonStop.Enabled = true;
                labelGameover.Visible = false;
                m_bgm.PlayLooping();
                m_isrun = true;
                timer1.Enabled = true;
            }
    
            //暂停继续事件:
            private void buttonStop_Click(object sender, EventArgs e)
            {
                if (buttonStop.Text == "暂   停")
                {
                    m_isrun = false;
                    timer1.Enabled = false;
                    PlaySound(null, IntPtr.Zero, PlaySoundFlags.SND_ASYNC);
                    buttonStop.Text = "继   续";
                }
                else
                {
                    m_isrun = true;
                    timer1.Enabled = true;
                    m_bgm.PlayLooping();
                    buttonStop.Text = "暂   停";
                }
            }
    
            //退出事件:
            private void buttonExit_Click(object sender, EventArgs e)
            {
                this.Close();
            }
    
        }
    }
    
    

    Program.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Windows.Forms;
    
    namespace OhMyTetris
    {
        static class Program
        {
            /// <summary>
            /// 应用程序的主入口点。
            /// </summary>
            [STAThread]
            static void Main()
            {
                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);
                Application.Run(new FormMain());
            }
        }
    }
    
    

    Brick.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Drawing;
    
    namespace OhMyTetris
    {
        public abstract class Brick
        {
            #region 私有属性
            //当前变形次序
            private int m_curTransforIndex;
    
            //必要的行数、列数
            private int m_needfulRows;
            private int m_needfulColumns;
            
            //变形范围
            private int[,] m_range;
    
            //中心点
            private Point m_center;
    
            //中心点的位置
            private Point m_pos;
    
            #endregion
            
            #region 公有属性
    
            public int m_CurTransforIndex
            {
                get { return m_curTransforIndex; }
                set { m_curTransforIndex = value; }
            }
    
            public int m_NeedfulRows
            {
                get { return m_needfulRows; }
                set { m_needfulRows = value; }
            }
            public int m_NeedfulColumns
            {
                get { return m_needfulColumns; }
                set { m_needfulColumns = value; }
            }
    
            public int[,] m_Range
            {
                get { return m_range; }
                set { m_range = value; }
            }
    
            public Point m_Center
            {
                get { return m_center; }
                set { m_center = value; }
            }
            public Point m_Pos
            {
                get { return m_pos; }
                set { m_pos = value; }
            }
            #endregion
    
            //自定义方法:判断能否变形
            public abstract bool CanTransform(int[,] arr, int rows, int columns);
    
            //自定义方法:变形
            public abstract void Transform();
    
            //自定义方法:判断能否左移
            public abstract bool CanLeftMove(int[,] arr, int rows, int columns);
    
            //自定义方法:左移
            public void LeftMove()
            {
                m_pos.Y -= 1;
            }
    
            //自定义方法:判断能否右移
            public abstract bool CanRightMove(int[,] arr, int rows, int columns);
    
            //自定义方法:右移
            public void RightMove()
            {
                m_pos.Y += 1;
            }
    
            //自定义方法:判断能否下移
            public abstract bool CanDropMove(int[,] arr, int rows, int columns);
    
            //自定义方法:下移
            public void DropMove()
            {
                m_pos.X += 1;
            }
    
            //自定义方法:随机生成形状
            public void RandomShape()
            {
                Random random = new Random();
                this.m_curTransforIndex = random.Next(4);
                this.Transform();
            }
    
            //自定义方法:设置中心点在画布的位置
            public void SetCenterPos(int x, int y)
            {
                this.m_pos = new Point(x, y);
            }
    
            //自定义方法:获取砖块出现时y的坐标
            public abstract int Appear();
        }
    }
    
    

    Brick1.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Drawing;
    
    namespace OhMyTetris
    {
        //田字砖
        class Brick1:Brick
        {
            //定义新砖块的各个值
            public Brick1() 
            {
                this.m_CurTransforIndex = 0;
                this.m_NeedfulRows = 2;
                this.m_NeedfulColumns = 2;
                m_Range = new int[2, 2]{{1,1},
                                        {1,1}};
                this.m_Center = new Point(0, 0);
                this.m_Pos = new Point();
            }
    
            //重写判断能否变形的方法
            public override bool CanTransform(int[,] arr, int rows, int columns)
            {
                return false;
            }
    
            //重写变形的方法
            public override void Transform()
            {
                return;
            }
    
            //重写判断是否可以左移的方法
            public override bool CanLeftMove(int[,] arr, int rows, int columns)
            {
                if (m_Pos.X < 0)
                {
                    if (m_Pos.Y == 0 || arr[m_Pos.X + 1, m_Pos.Y - 1] == 1)
                    {
                        return false;
                    }
                    else
                    {
                        return true;
                    }
                }
                if (m_Pos.Y == 0 || arr[m_Pos.X, m_Pos.Y - 1] == 1 || arr[m_Pos.X + 1, m_Pos.Y - 1] == 1)
                    return false;
                else
                    return true;
            }
    
            //重写判断是否可以右移的方法
            public override bool CanRightMove(int[,] arr, int rows, int columns)
            {
                if (m_Pos.X < 0)
                {
                    if (m_Pos.Y == columns - 2 || arr[m_Pos.X + 1, m_Pos.Y + 2] == 1)
                    {
                        return false;
                    }
                    else
                    {
                        return true;
                    }
                }
                if (m_Pos.Y == columns - 2 || arr[m_Pos.X, m_Pos.Y + 2] == 1 || arr[m_Pos.X + 1, m_Pos.Y + 2] == 1)
                    return false;
                else
                    return true;
            }
    
            //重写判断是否可以下移的方法
            public override bool CanDropMove(int[,] arr, int rows, int columns)
            {
                if (m_Pos.X < rows - 2 && arr[m_Pos.X + 2, m_Pos.Y] == 0 && arr[m_Pos.X + 2, m_Pos.Y + 1] == 0)
                    return true;
                return false;
            }
    
            //重写获取砖块出现时y的坐标方法
            public override int Appear()
            {
                return -1;
            }
        }
    }
    
    

    Brick2.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Drawing;
    
    namespace OhMyTetris
    {
        class Brick2:Brick
        {
            //定义新砖块的各个值
            public Brick2() 
            {
                this.m_CurTransforIndex = 0;
                this.m_NeedfulColumns = 5;
                this.m_NeedfulRows = 5;
                m_Range = new int[5, 5] { { 0, 0, 0, 0, 0 },
                                          { 0, 0, 0, 0, 0 },
                                          { 0, 1, 1, 1, 1 },
                                          { 0, 0, 0, 0, 0 },
                                          { 0, 0, 0, 0, 0 }};
                this.m_Center = new Point(2, 2);
                this.m_Pos = new Point();
            }
    
            //重写判断能否变形的方法
            public override bool CanTransform(int[,] arr, int rows, int columns)
            {
                bool result = false;
                if (m_Pos.X - 2 >= 0 && m_Pos.X + 2 <= rows - 1 && m_Pos.Y - 2 >= 0 && m_Pos.Y + 2 <= columns - 1)
                {
                    switch (m_CurTransforIndex)
                    {
                        case 0:
                            arr[m_Pos.X, m_Pos.Y - 1] = 0;
                            arr[m_Pos.X, m_Pos.Y] = 0;
                            arr[m_Pos.X, m_Pos.Y + 1] = 0;
                            arr[m_Pos.X, m_Pos.Y + 2] = 0;
                            break;
                        case 1:
                            arr[m_Pos.X - 1, m_Pos.Y] = 0;
                            arr[m_Pos.X, m_Pos.Y] = 0;
                            arr[m_Pos.X + 1, m_Pos.Y] = 0;
                            arr[m_Pos.X + 2, m_Pos.Y] = 0;
                            break;
                        case 2:
                            arr[m_Pos.X, m_Pos.Y - 2] = 0;
                            arr[m_Pos.X, m_Pos.Y - 1] = 0;
                            arr[m_Pos.X, m_Pos.Y] = 0;
                            arr[m_Pos.X, m_Pos.Y + 1] = 0;
                            break;
                        case 3:
                            arr[m_Pos.X - 2, m_Pos.Y] = 0;
                            arr[m_Pos.X - 1, m_Pos.Y] = 0;
                            arr[m_Pos.X, m_Pos.Y] = 0;
                            arr[m_Pos.X + 1, m_Pos.Y] = 0;
                            break;
                        default:
                            break;
                    }
                    bool temp = true;
                    for (int i = -2; i < 3; i++)
                    {
                        for (int j = -2; j < 3; j++)
                        {
                            if (arr[m_Pos.X + i, m_Pos.Y + j] == 1)
                            {
                                temp = false;
                                goto break2;
                            }
                        }
                    }
                break2:
                    result = temp;
                    switch (m_CurTransforIndex)
                    {
                        case 0:
                            arr[m_Pos.X, m_Pos.Y - 1] = 1;
                            arr[m_Pos.X, m_Pos.Y] = 1;
                            arr[m_Pos.X, m_Pos.Y + 1] = 1;
                            arr[m_Pos.X, m_Pos.Y + 2] = 1;
                            break;
                        case 1:
                            arr[m_Pos.X - 1, m_Pos.Y] = 1;
                            arr[m_Pos.X, m_Pos.Y] = 1;
                            arr[m_Pos.X + 1, m_Pos.Y] = 1;
                            arr[m_Pos.X + 2, m_Pos.Y] = 1;
                            break;
                        case 2:
                            arr[m_Pos.X, m_Pos.Y - 2] = 1;
                            arr[m_Pos.X, m_Pos.Y - 1] = 1;
                            arr[m_Pos.X, m_Pos.Y] = 1;
                            arr[m_Pos.X, m_Pos.Y + 1] = 1;
                            break;
                        case 3:
                            arr[m_Pos.X - 2, m_Pos.Y] = 1;
                            arr[m_Pos.X - 1, m_Pos.Y] = 1;
                            arr[m_Pos.X, m_Pos.Y] = 1;
                            arr[m_Pos.X + 1, m_Pos.Y] = 1;
                            break;
                        default:
                            break;
                    }
                }
                return result;
            }
    
            //重写变形的方法
            public override void Transform()
            {
                switch (m_CurTransforIndex)
                {
                    case 0:
                        m_Range = new int[5, 5]{{0,0,0,0,0},
                                                {0,0,1,0,0},
                                                {0,0,1,0,0},
                                                {0,0,1,0,0},
                                                {0,0,1,0,0}};
                        m_CurTransforIndex = 1;
                        break;
                    case 1:
                        m_Range = new int[5, 5]{{0,0,0,0,0},
                                                {0,0,0,0,0},
                                                {1,1,1,1,0},
                                                {0,0,0,0,0},
                                                {0,0,0,0,0}};
                        m_CurTransforIndex = 2;
                        break;
                    case 2:
                        m_Range = new int[5, 5]{{0,0,1,0,0},
                                                {0,0,1,0,0},
                                                {0,0,1,0,0},
                                                {0,0,1,0,0},
                                                {0,0,0,0,0}};
                        m_CurTransforIndex = 3;
                        break;
                    case 3:
                        m_Range = new int[5, 5]{{0,0,0,0,0},
                                                {0,0,0,0,0},
                                                {0,1,1,1,1},
                                                {0,0,0,0,0},
                                                {0,0,0,0,0}};
                        m_CurTransforIndex = 0;
                        break;
                    default:
                        break;
                }
            }
    
            //重写判断是否可以左移的方法
            public override bool CanLeftMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.Y > 1)
                        {
                            if (arr[m_Pos.X, m_Pos.Y - 2] == 0)
                            {
                                result = true;
                            }
                            else
                            {
                                result = false;
                            }
                        }
                        break;
                    case 1:
                        if (m_Pos.Y > 0)
                        {
                            bool temp = true;
                            for (int i = -1; i < 3; i++)
                            {
                                if (m_Pos.X + i < 0)
                                {
                                    continue;
                                }
                                else
                                {
                                    if (arr[m_Pos.X + i, m_Pos.Y - 1] == 1)
                                    {
                                        temp = false;
                                        break;
                                    }
                                }
                            }
                            result = temp;
                        }
                        break;
                    case 2:
                        if (m_Pos.Y > 2)
                        {
                            if (arr[m_Pos.X, m_Pos.Y - 3] == 0)
                            {
                                result = true;
                            }
                            else
                            {
                                result = false;
                            }
                        }
                        break;
                    case 3:
                        if (m_Pos.Y > 0)
                        {
                            bool temp = true;
                            for (int i = -2; i < 2; i++)
                            {
                                if (m_Pos.X + i < 0)
                                {
                                    continue;
                                }
                                else
                                {
                                    if (arr[m_Pos.X + i, m_Pos.Y - 1] == 1)
                                    {
                                        temp = false;
                                        break;
                                    }
                                }
                            }
                            result = temp;
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写判断是否可以右移的方法
            public override bool CanRightMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.Y < columns - 3)
                        {
                            if (arr[m_Pos.X, m_Pos.Y + 3] == 0)
                            {
                                result = true;
                            }
                            else
                            {
                                result = false;
                            }
                        }
                        break;
                    case 1:
                        if (m_Pos.Y < columns - 1)
                        {
                            bool temp = true;
                            for (int i = -1; i < 3; i++)
                            {
                                if (m_Pos.X + i < 0)
                                {
                                    continue;
                                }
                                else
                                {
                                    if (arr[m_Pos.X + i, m_Pos.Y + 1] == 1)
                                    {
                                        temp = false;
                                        break;
                                    }
                                }
                            }
                            result = temp;
                        }
                        break;
                    case 2:
                        if (m_Pos.Y < columns - 2)
                        {
                            if (arr[m_Pos.X, m_Pos.Y + 2] == 0)
                            {
                                result = true;
                            }
                            else
                            {
                                result = false;
                            }
                        }
                        break;
                    case 3:
                        if (m_Pos.Y < columns - 1)
                        {
                            bool temp = true;
                            for (int i = -2; i < 2; i++)
                            {
                                if (m_Pos.X + i < 0)
                                {
                                    continue;
                                }
                                else
                                {
                                    if (arr[m_Pos.X + i, m_Pos.Y + 1] == 1)
                                    {
                                        temp = false;
                                        break;
                                    }
                                }
                            }
                            result = temp;
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写判断是否可以下移的方法
            public override bool CanDropMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.X != rows - 1)
                        {
                            if (arr[m_Pos.X + 1, m_Pos.Y] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 2] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                            {
                                result = true;
                            }
                            else
                            {
                                result = false;
                            }
                        }
                        break;
                    case 1:
                        if (m_Pos.X != rows - 3)
                        {
                            if (arr[m_Pos.X + 3, m_Pos.Y] == 0)
                            {
                                result = true;
                            }
                            else
                            {
                                result = false;
                            }
                        }
                        break;
                    case 2:
                        if (m_Pos.X != rows - 1)
                        {
                            if (arr[m_Pos.X + 1, m_Pos.Y - 2] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                            {
                                result = true;
                            }
                            else
                            {
                                result = false;
                            }
                        }
                        break;
                    case 3:
                        if (m_Pos.X != rows - 2)
                        {
                            if (arr[m_Pos.X + 2, m_Pos.Y] == 0)
                            {
                                result = true;
                            }
                            else
                            {
                                result = false;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写获取砖块出现时y的坐标方法
            public override int Appear()
            {
                int result = 0;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        result = 0;
                        break;
                    case 1:
                        result = -2;
                        break;
                    case 2:
                        result = 0;
                        break;
                    case 3:
                        result = -1;
                        break;
                    default:
                        break;
                }
                return result;
            }
        }
    }
    
    

    Brick3.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Drawing;
    
    namespace OhMyTetris
    {
        class Brick3:Brick
        {
            //定义新砖块的各个值
            public Brick3() 
            {
                this.m_CurTransforIndex = 0;
                this.m_NeedfulColumns = 3;
                this.m_NeedfulRows = 3;
                m_Range = new int[3, 3] { { 0, 1, 0 },
                                          { 1, 1, 1 },
                                          { 0, 0, 0 }};
                this.m_Center = new Point(1, 1);
                this.m_Pos = new Point();
            }
    
            //重写判断能否变形的方法
            public override bool CanTransform(int[,] arr, int rows, int columns)
            {
                bool result = true;
                if (m_Pos.X - 1 >= 0 && m_Pos.X + 1 <= rows - 1 && m_Pos.Y - 1 >= 0 && m_Pos.Y + 1 <= columns - 1)
                {
                    for (int i = -1; i < 2; i++)
                    {
                        for (int j = -1; j < 2; j++)
                        {
                            switch (m_CurTransforIndex)
                            {
                                case 0:
                                    if (i == -1 && j == 0 || i == 0 && j == -1 || i == 0 && j == 0 || i == 0 && j == 1)
                                    {
                                        continue;
                                    }
                                    break;
                                case 1:
                                    if (i == -1 && j == 0 || i == 0 && j == 0 || i == 0 && j == 1 || i == 1 && j == 0)
                                    {
                                        continue;
                                    }
                                    break;
                                case 2:
                                    if (i == 0 && j == -1 || i == 0 && j == 0 || i == 0 && j == 1 || i == 1 && j == 0)
                                    {
                                        continue;
                                    }
                                    break;
                                case 3:
                                    if (i == -1 && j == 0 || i == 0 && j == -1 || i == 0 && j == 0 || i == 1 && j == 0)
                                    {
                                        continue;
                                    }
                                    break;
                                default:
                                    break;
                            }
                            if (arr[m_Pos.X + i, m_Pos.Y + j] == 1)
                            {
                                result = false;
                            }
                        }
                    }
                }
                return result;
            }
    
            //重写变形的方法
            public override void Transform()
            {
                switch (m_CurTransforIndex)
                {
                    case 0:
                        m_Range = new int[3, 3]{{0,1,0},
                                                {0,1,1},
                                                {0,1,0}};
                        m_CurTransforIndex = 1;
                        break;
                    case 1:
                        m_Range = new int[3, 3]{{0,0,0},
                                                {1,1,1},
                                                {0,1,0}};
                        m_CurTransforIndex = 2;
                        break;
                    case 2:
                        m_Range = new int[3, 3]{{0,1,0},
                                               {1,1,0},
                                               {0,1,0}};
                        m_CurTransforIndex = 3;
                        break;
                    case 3:
                        m_Range = new int[3, 3]{{0,1,0},
                                                {1,1,1},
                                                {0,0,0}};
                        m_CurTransforIndex = 0;
                        break;
                    default:
                        break;
                }
            }
    
            //重写判断是否可以左移的方法
            public override bool CanLeftMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.Y - 1 != 0)
                        {
                            if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 2] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X - 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X, m_Pos.Y - 2] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 1:
                        if (m_Pos.Y != 0)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X - 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 2:
                        if (m_Pos.Y - 1 != 0)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 2] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 3:
                        if (m_Pos.Y - 1 != 0)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 2] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X - 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X, m_Pos.Y - 2] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写判断是否可以右移的方法
            public override bool CanRightMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.Y + 1 < columns - 1)
                        {
                            if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 2] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X - 1, m_Pos.Y + 1] == 0 && arr[m_Pos.X, m_Pos.Y + 2] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 1:
                        if (m_Pos.Y + 1 < columns - 1)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 2] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X - 1, m_Pos.Y + 1] == 0 && arr[m_Pos.X, m_Pos.Y + 2] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 2:
                        if (m_Pos.Y + 1 < columns - 1)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 2] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 3:
                        if (m_Pos.Y < columns - 1)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X - 1, m_Pos.Y + 1] == 0 && arr[m_Pos.X, m_Pos.Y + 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写判断是否可以下移的方法
            public override bool CanDropMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.X != rows - 1)
                        {
                            if (arr[m_Pos.X + 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                result = true;
                        }
                        break;
                    case 1:
                        if (m_Pos.X + 1 != rows - 1)
                        {
                            if (arr[m_Pos.X + 2, m_Pos.Y] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                result = true;
                        }
                        break;
                    case 2:
                        if (m_Pos.X + 1 != rows - 1)
                        {
                            if (arr[m_Pos.X + 2, m_Pos.Y] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                result = true;
                        }
                        break;
                    case 3:
                        if (m_Pos.X + 1 != rows - 1)
                        {
                            if (arr[m_Pos.X + 2, m_Pos.Y] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                result = true;
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写获取砖块出现时y的坐标方法
            public override int Appear()
            {
                int result = 0;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        result = 0;
                        break;
                    case 1:
                        result = -1;
                        break;
                    case 2:
                        result = -1;
                        break;
                    case 3:
                        result = -1;
                        break;
                    default:
                        break;
                }
                return result;
            }
        }
    }
    
    

    Brick4.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Drawing;
    
    namespace OhMyTetris
    {
        class Brick4:Brick
        {
            //定义新砖块的各个值
            public Brick4() 
            {
                this.m_CurTransforIndex = 0;
                this.m_NeedfulColumns = 3;
                this.m_NeedfulRows = 3;
                m_Range = new int[3, 3] { { 0, 0, 0 },
                                          { 1, 1, 0 },
                                          { 0, 1, 1 }};
                this.m_Center = new Point(1, 1);
                this.m_Pos = new Point();
            }
    
            //重写判断能否变形的方法
            public override bool CanTransform(int[,] arr, int rows, int columns)
            {
                bool result = true;
                if (m_Pos.X - 1 >= 0 && m_Pos.X + 1 <= rows - 1 && m_Pos.Y - 1 >= 0 && m_Pos.Y + 1 <= columns - 1)
                {
                    for (int i = -1; i < 2; i++)
                    {
                        for (int j = -1; j < 2; j++)
                        {
                            switch (m_CurTransforIndex)
                            {
                                case 0:
                                    if (i == 0 && j == -1 || i == 0 && j == 0 || i == 1 && j == 0 || i == 1 && j == 1)
                                        continue;
                                    break;
                                case 1:
                                    if (i == -1 && j == 0 || i == 0 && j == 0 || i == 0 && j == -1 || i == 1 && j == -1)
                                        continue;
                                    break;
                                case 2:
                                    if (i == -1 && j == -1 || i == -1 && j == 0 || i == 0 && j == 0 || i == 0 && j == 1)
                                        continue;
                                    break;
                                case 3:
                                    if (i == -1 && j == 1 || i == 0 && j == 0 || i == 0 && j == 1 || i == 1 && j == 0)
                                        continue;
                                    break;
                                default:
                                    break;
                            }
                            if (arr[m_Pos.X + i, m_Pos.Y + j] == 1)
                            {
                                result = false;
                                goto break1;
                            }
                        }
                    }
                }
                break1: return result;
            }
    
            //重写变形的方法
            public override void Transform()
            {
                switch (m_CurTransforIndex)
                {
                    case 0:
                        m_Range = new int[3, 3]{{0,1,0},
                                                {1,1,0},
                                                {1,0,0}};
                        m_CurTransforIndex = 1;
                        break;
                    case 1:
                        m_Range = new int[3, 3]{{1,1,0},
                                                {0,1,1},
                                                {0,0,0}};
                        m_CurTransforIndex = 2;
                        break;
                    case 2:
                        m_Range = new int[3, 3]{{0,0,1},
                                                {0,1,1},
                                                {0,1,0}};
                        m_CurTransforIndex = 3;
                        break;
                    case 3:
                        m_Range = new int[3, 3]{{0,0,0},
                                               {1,1,0},
                                               {0,1,1}};
                        m_CurTransforIndex = 0;
                        break;
                    default:
                        break;
                }
            }
    
            //重写判断是否可以左移的方法
            public override bool CanLeftMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.Y - 1 > 0)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 2] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 1:
                        if (m_Pos.Y - 1 > 0)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y - 2] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 2] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 2] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 2] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 2] == 0 && arr[m_Pos.X - 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 2:
                        if (m_Pos.Y - 1 > 0)
                        {
                            if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 1] == 0 && arr[m_Pos.X - 1, m_Pos.Y - 2] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 3:
                        if (m_Pos.Y > 0)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X - 1, m_Pos.Y] == 0)
                                    result = true;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写判断是否可以右移的方法
            public override bool CanRightMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.Y + 1 < columns - 1)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 2] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 2] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 1:
                        if (m_Pos.Y < columns - 1)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y] == 0 && arr[m_Pos.X, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y] == 0 && arr[m_Pos.X, m_Pos.Y + 1] == 0 && arr[m_Pos.X - 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 2:
                        if (m_Pos.Y + 1 < columns - 1)
                        {
                            if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 2] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 2] == 0 && arr[m_Pos.X - 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 3:
                        if (m_Pos.Y + 1 < columns - 1)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 1] == 0 && arr[m_Pos.X, m_Pos.Y + 2] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 1] == 0 && arr[m_Pos.X, m_Pos.Y + 2] == 0 && arr[m_Pos.X - 1, m_Pos.Y + 2] == 0)
                                    result = true;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写判断是否可以下移的方法
            public override bool CanDropMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
    
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.X + 1 < rows - 1)
                        {
                            if (arr[m_Pos.X + 2, m_Pos.Y] == 0 && arr[m_Pos.X + 2, m_Pos.Y + 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                result = true;
                        }
                        break;
                    case 1:
                        if (m_Pos.X + 1 < rows - 1)
                        {
                            if (arr[m_Pos.X + 2, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y] == 0)
                                result = true;
                        }
                        break;
                    case 2:
                        if (m_Pos.X < rows - 1)
                        {
                            if (arr[m_Pos.X + 1, m_Pos.Y] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0 && arr[m_Pos.X, m_Pos.Y - 1] == 0)
                                result = true;
                        }
                        break;
                    case 3:
                        if (m_Pos.X + 1 < rows - 1)
                        {
                            if (arr[m_Pos.X + 2, m_Pos.Y] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                result = true;
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写获取砖块出现时y的坐标方法
            public override int Appear()
            {
                int result = 0;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        result = -1;
                        break;
                    case 1:
                        result = -1;
                        break;
                    case 2:
                        result = 0;
                        break;
                    case 3:
                        result = -1;
                        break;
                    default:
                        break;
                }
                return result;
            }
        }
    }
    
    

    Brick5.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Drawing;
    
    namespace OhMyTetris
    {
        class Brick5:Brick
        {
            //定义新砖块的各个值
            public Brick5() 
            {
                this.m_CurTransforIndex = 0;
                this.m_NeedfulColumns = 3;
                this.m_NeedfulRows = 3;
                m_Range = new int[3, 3] { { 0, 0, 0 },
                                          { 1, 1, 0 },
                                          { 0, 1, 1 }};
                this.m_Center = new Point(1, 1);
                this.m_Pos = new Point();
            }
    
            //重写判断能否变形的方法
            public override bool CanTransform(int[,] arr, int rows, int columns)
            {
                bool result = true;
                if (m_Pos.X - 1 >= 0 && m_Pos.X + 1 <= rows - 1 && m_Pos.Y - 1 >= 0 && m_Pos.Y + 1 <= columns - 1)
                {
                    for (int i = -1; i < 2; i++)
                    {
                        for (int j = -1; j < 2; j++)
                        {
                            switch (m_CurTransforIndex)
                            {
                                case 0:
                                    if (i == 0 && j == 0 || i == 0 && j == 1 || i == 1 && j == -1 || i == 1 && j == 0)
                                        continue;
                                    break;
                                case 1:
                                    if (i == -1 && j == -1 || i == 0 && j == -1 || i == 0 && j == 0 || i == 1 && j == 0)
                                        continue;
                                    break;
                                case 2:
                                    if (i == -1 && j == 0 || i == -1 && j == 1 || i == 0 && j == -1 || i == 0 && j == 0)
                                        continue;
                                    break;
                                case 3:
                                    if (i == -1 && j == 0 || i == 0 && j == 0 || i == 0 && j == 1 || i == 1 && j == 1)
                                        continue;
                                    break;
                                default:
                                    break;
                            }
                            if (arr[m_Pos.X + i, m_Pos.Y + j] == 1)
                            {
                                result = false;
                                goto break1;
                            }
                        }
                    }
                }
                break1: return result;
            }
    
            //重写变形的方法
            public override void Transform()
            {
                switch (m_CurTransforIndex)
                {
                    case 0:
                        m_Range = new int[3, 3]{{1,0,0},
                                                {1,1,0},
                                                {0,1,0}};
                        m_CurTransforIndex = 1;
                        break;
                    case 1:
                        m_Range = new int[3, 3]{{0,1,1},
                                                {1,1,0},
                                                {0,0,0}};
                        m_CurTransforIndex = 2;
                        break;
                    case 2:
                        m_Range = new int[3, 3]{{0,1,0},
                                                {0,1,1},
                                                {0,0,1}};
                        m_CurTransforIndex = 3;
                        break;
                    case 3:
                        m_Range = new int[3, 3]{{0,0,0},
                                               {0,1,1},
                                               {1,1,0}};
                        m_CurTransforIndex = 0;
                        break;
                    default:
                        break;
                }
            }
    
            //重写判断是否可以左移的方法
            public override bool CanLeftMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.Y - 1 > 0)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y - 2] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 2] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 1:
                        if (m_Pos.Y - 1 > 0)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 2] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 2] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X - 1, m_Pos.Y - 2] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 2:
                        if (m_Pos.Y - 1 > 0)
                        {
                            if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 2] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 2] == 0 && arr[m_Pos.X - 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 3:
                        if (m_Pos.Y > 0)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y] == 0 && arr[m_Pos.X, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y] == 0 && arr[m_Pos.X, m_Pos.Y - 1] == 0 && arr[m_Pos.X - 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写判断是否可以右移的方法
            public override bool CanRightMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.Y + 1 < columns - 1)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 2] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 1:
                        if (m_Pos.Y < columns - 1)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 1] == 0 && arr[m_Pos.X, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 1] == 0 && arr[m_Pos.X, m_Pos.Y + 1] == 0 && arr[m_Pos.X - 1, m_Pos.Y] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 2:
                        if (m_Pos.Y + 1 < columns - 1)
                        {
                            if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 1] == 0 && arr[m_Pos.X - 1, m_Pos.Y + 2] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 3:
                        if (m_Pos.Y + 1 < columns - 1)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 2] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 2] == 0 && arr[m_Pos.X, m_Pos.Y + 2] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 2] == 0 && arr[m_Pos.X, m_Pos.Y + 2] == 0 && arr[m_Pos.X - 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写判断是否可以下移的方法
            public override bool CanDropMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.X + 1 < rows - 1)
                        {
                            if (arr[m_Pos.X + 2, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 2, m_Pos.Y] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                result = true;
                        }
                        break;
                    case 1:
                        if (m_Pos.X + 1 < rows - 1)
                        {
                            if (arr[m_Pos.X + 2, m_Pos.Y] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                result = true;
                        }
                        break;
                    case 2:
                        if (m_Pos.X < rows - 1)
                        {
                            if (arr[m_Pos.X + 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y] == 0 && arr[m_Pos.X, m_Pos.Y + 1] == 0)
                                result = true;
                        }
                        break;
                    case 3:
                        if (m_Pos.X + 1 < rows - 1)
                        {
                            if (arr[m_Pos.X + 1, m_Pos.Y] == 0 && arr[m_Pos.X + 2, m_Pos.Y + 1] == 0)
                                result = true;
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写获取砖块出现时y的坐标方法
            public override int Appear()
            {
                int result = 0;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        result = -1;
                        break;
                    case 1:
                        result = -1;
                        break;
                    case 2:
                        result = 0;
                        break;
                    case 3:
                        result = -1;
                        break;
                    default:
                        break;
                }
                return result;
            }
        }
    }
    
    

    Brick6.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Drawing;
    
    namespace OhMyTetris
    {
        class Brick6:Brick
        {
            //定义新砖块的各个值
            public Brick6() 
            {
                this.m_CurTransforIndex = 0;
                this.m_NeedfulColumns = 5;
                this.m_NeedfulRows = 5;
                m_Range = new int[5, 5] { { 0, 0, 0, 0, 0 },
                                          { 0, 0, 1, 0, 0 },
                                          { 0, 0, 1, 1, 1 },
                                          { 0, 0, 0, 0, 0 },
                                          { 0, 0, 0, 0, 0 }};
                this.m_Center = new Point(2, 2);
                this.m_Pos = new Point();
            }
    
            //重写判断能否变形的方法
            public override bool CanTransform(int[,] arr, int rows, int columns)
            {
                if (m_Pos.X - 2 >= 0 && m_Pos.X + 2 <= rows - 1 && m_Pos.Y - 2 >= 0 && m_Pos.Y + 2 <= columns - 1)
                {
                    bool result = true;
                    switch (m_CurTransforIndex)
                    {
                        case 0:
                            for (int i = -2; i < 3; i++)
                            {
                                for (int j = -2; j < 3; j++)
                                {
                                    if (i == -1 && j == 0 || i == 0 && j == 0 || i == 0 && j == 1 || i == 0 && j == 2)
                                        continue;
                                    if (arr[m_Pos.X + i, m_Pos.Y + j] == 1)
                                    {
                                        result = false;
                                        goto break1;
                                    }
                                }
                            }
                            break;
                        case 1:
                            for (int i = -2; i < 3; i++)
                            {
                                for (int j = -2; j < 3; j++)
                                {
                                    if (i == 0 && j == 0 || i == 0 && j == 1 || i == 1 && j == 0 || i == 2 && j == 0)
                                        continue;
                                    if (arr[m_Pos.X + i, m_Pos.Y + j] == 1)
                                    {
                                        result = false;
                                        goto break1;
                                    }
                                }
                            }
                            break;
                        case 2:
                            for (int i = -2; i < 3; i++)
                            {
                                for (int j = -2; j < 3; j++)
                                {
                                    if (i == 0 && j == -2 || i == 0 && j == -1 || i == 0 && j == 0 || i == 1 && j == 0)
                                        continue;
                                    if (arr[m_Pos.X + i, m_Pos.Y + j] == 1)
                                    {
                                        result = false;
                                        goto break1;
                                    }
                                }
                            }
                            break;
                        case 3:
                            for (int i = -2; i < 3; i++)
                            {
                                for (int j = -2; j < 3; j++)
                                {
                                    if (i == -2 && j == 0 || i == -1 && j == 0 || i == 0 && j == -1 || i == 0 && j == 0)
                                        continue;
                                    if (arr[m_Pos.X + i, m_Pos.Y + j] == 1)
                                    {
                                        result = false;
                                        goto break1;
                                    }
                                }
                            }
                            break;
                        default:
                            break;
                    }
                break1: return result;
                }
                else
                {
                    return false;
                }
            }
    
            //重写变形的方法
            public override void Transform()
            {
                switch (m_CurTransforIndex)
                {
                    case 0:
                        m_Range = new int[5, 5]{{0,0,0,0,0},
                                                {0,0,0,0,0},
                                                {0,0,1,1,0},
                                                {0,0,1,0,0},
                                                {0,0,1,0,0}};
                        m_CurTransforIndex = 1;
                        break;
                    case 1:
                        m_Range = new int[5, 5]{{0,0,0,0,0},
                                                {0,0,0,0,0},
                                                {1,1,1,0,0},
                                                {0,0,1,0,0},
                                                {0,0,0,0,0}};
                        m_CurTransforIndex = 2;
                        break;
                    case 2:
                        m_Range = new int[5, 5]{{0,0,1,0,0},
                                                {0,0,1,0,0},
                                                {0,1,1,0,0},
                                                {0,0,0,0,0},
                                                {0,0,0,0,0}};
                        m_CurTransforIndex = 3;
                        break;
                    case 3:
                        m_Range = new int[5, 5]{{0,0,0,0,0},
                                                {0,0,1,0,0},
                                                {0,0,1,1,1},
                                                {0,0,0,0,0},
                                                {0,0,0,0,0}};
                        m_CurTransforIndex = 0;
                        break;
                    default:
                        break;
                }
            }
    
            //重写判断是否可以左移的方法
            public override bool CanLeftMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.Y > 0)
                        {
                            if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 1] == 0 && arr[m_Pos.X - 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 1:
                        if (m_Pos.Y > 0)
                        {
                            if (m_Pos.X == -2)
                            {
                                if (arr[m_Pos.X + 2, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 2, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X + 2, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 2:
                        if (m_Pos.Y > 2)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X, m_Pos.Y - 3] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 3:
                        if (m_Pos.Y > 1)
                        {
                            if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 2] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == 1)
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 2] == 0 && arr[m_Pos.X - 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 2] == 0 && arr[m_Pos.X - 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X - 2, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写判断是否可以右移的方法
            public override bool CanRightMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.Y + 2 < columns - 1)
                        {
                            if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 3] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 3] == 0 && arr[m_Pos.X - 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 1:
                        if (m_Pos.Y + 1 < columns - 1)
                        {
                            if (m_Pos.X == -2)
                            {
                                if (arr[m_Pos.X + 2, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 2, m_Pos.Y + 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X + 2, m_Pos.Y + 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0 && arr[m_Pos.X, m_Pos.Y + 2] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 2:
                        if (m_Pos.Y < columns - 1)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 1] == 0 && arr[m_Pos.X, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 3:
                        if (m_Pos.Y < columns - 1)
                        {
                            if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == 1)
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 1] == 0 && arr[m_Pos.X - 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 1] == 0 && arr[m_Pos.X - 1, m_Pos.Y + 1] == 0 && arr[m_Pos.X - 2, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写判断是否可以下移的方法
            public override bool CanDropMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.X < rows - 1)
                        {
                            if (arr[m_Pos.X + 1, m_Pos.Y] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 2] == 0)
                                result = true;
                        }
                        break;
                    case 1:
                        if (m_Pos.X + 2 < rows - 1)
                        {
                            if (m_Pos.X == -2)
                            {
                                if (arr[m_Pos.X + 3, m_Pos.Y] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X + 3, m_Pos.Y] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 2:
                        if (m_Pos.X + 1 < rows - 1)
                        {
                            if (arr[m_Pos.X + 1, m_Pos.Y - 2] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 2, m_Pos.Y] == 0)
                                result = true;
                        }
                        break;
                    case 3:
                        if (m_Pos.X < rows - 1)
                        {
                            if (arr[m_Pos.X + 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y] == 0)
                                result = true;
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写获取砖块出现时y的坐标方法
            public override int Appear()
            {
                int result = 0;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        result = 0;
                        break;
                    case 1:
                        result = -2;
                        break;
                    case 2:
                        result = -1;
                        break;
                    case 3:
                        result = -0;
                        break;
                    default:
                        break;
                }
                return result;
            }
        }
    }
    
    

    Brick7.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Drawing;
    
    namespace OhMyTetris
    {
        class Brick7:Brick
        {
            //定义新砖块的各个值
            public Brick7() 
            {
                this.m_CurTransforIndex = 0;
                this.m_NeedfulColumns = 5;
                this.m_NeedfulRows = 5;
                m_Range = new int[5, 5] { { 0, 0, 0, 0, 0 },
                                          { 0, 0, 1, 0, 0 },
                                          { 1, 1, 1, 0, 0 },
                                          { 0, 0, 0, 0, 0 },
                                          { 0, 0, 0, 0, 0 }};
                this.m_Center = new Point(2, 2);
                this.m_Pos = new Point();
            }
    
            //重写判断能否变形的方法
            public override bool CanTransform(int[,] arr, int rows, int columns)
            {
                if (m_Pos.X - 2 >= 0 && m_Pos.X + 2 <= rows - 1 && m_Pos.Y - 2 >= 0 && m_Pos.Y + 2 <= columns - 1)
                {
                    bool result = true;
                    switch (m_CurTransforIndex)
                    {
                        case 0:
                            for (int i = -2; i < 3; i++)
                            {
                                for (int j = -2; j < 3; j++)
                                {
                                    if (i == -1 && j == 0 || i == 0 && j == -2 || i == 0 && j == -1 || i == 0 && j == 0)
                                        continue;
                                    if (arr[m_Pos.X + i, m_Pos.Y + j] == 1)
                                    {
                                        result = false;
                                        goto break1;
                                    }
                                }
                            }
                            break;
                        case 1:
                            for (int i = -2; i < 3; i++)
                            {
                                for (int j = -2; j < 3; j++)
                                {
                                    if (i == -2 && j == 0 || i == -1 && j == 0 || i == 0 && j == 0 || i == 0 && j == 1)
                                        continue;
                                    if (arr[m_Pos.X + i, m_Pos.Y + j] == 1)
                                    {
                                        result = false;
                                        goto break1;
                                    }
                                }
                            }
                            break;
                        case 2:
                            for (int i = -2; i < 3; i++)
                            {
                                for (int j = -2; j < 3; j++)
                                {
                                    if (i == 0 && j == 0 || i == 0 && j == 1 || i == 0 && j == 2 || i == 1 && j == 0)
                                        continue;
                                    if (arr[m_Pos.X + i, m_Pos.Y + j] == 1)
                                    {
                                        result = false;
                                        goto break1;
                                    }
                                }
                            }
                            break;
                        case 3:
                            for (int i = -2; i < 3; i++)
                            {
                                for (int j = -2; j < 3; j++)
                                {
                                    if (i == 0 && j == -1 || i == 0 && j == 0 || i == 1 && j == 0 || i == 2 && j == 0)
                                        continue;
                                    if (arr[m_Pos.X + i, m_Pos.Y + j] == 1)
                                    {
                                        result = false;
                                        goto break1;
                                    }
                                }
                            }
                            break;
                        default:
                            break;
                    }
                break1: return result;
                }
                else
                {
                    return false;
                }
            }
    
            //重写变形的方法
            public override void Transform()
            {
                switch (m_CurTransforIndex)
                {
                    case 0:
                        m_Range = new int[5, 5]{{0,0,1,0,0},
                                                {0,0,1,0,0},
                                                {0,0,1,1,0},
                                                {0,0,0,0,0},
                                                {0,0,0,0,0}};
                        m_CurTransforIndex = 1;
                        break;
                    case 1:
                        m_Range = new int[5, 5]{{0,0,0,0,0},
                                                {0,0,0,0,0},
                                                {0,0,1,1,1},
                                                {0,0,1,0,0},
                                                {0,0,0,0,0}};
                        m_CurTransforIndex = 2;
                        break;
                    case 2:
                        m_Range = new int[5, 5]{{0,0,0,0,0},
                                                {0,0,0,0,0},
                                                {0,1,1,0,0},
                                                {0,0,1,0,0},
                                                {0,0,1,0,0}};
                        m_CurTransforIndex = 3;
                        break;
                    case 3:
                        m_Range = new int[5, 5]{{0,0,0,0,0},
                                                {0,0,1,0,0},
                                                {1,1,1,0,0},
                                                {0,0,0,0,0},
                                                {0,0,0,0,0}};
                        m_CurTransforIndex = 0;
                        break;
                    default:
                        break;
                }
            }
    
            //重写判断是否可以左移的方法
            public override bool CanLeftMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.Y - 2 > 0)
                        {
                            if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 3] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 3] == 0 && arr[m_Pos.X - 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 1:
                        if (m_Pos.Y > 0)
                        {
                            if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == 1)
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 1] == 0 && arr[m_Pos.X - 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y - 1] == 0 && arr[m_Pos.X - 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X - 2, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 2:
                        if (m_Pos.Y > 0)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 3:
                        if (m_Pos.Y > 1)
                        {
                            if (m_Pos.X == -2)
                            {
                                if (arr[m_Pos.X + 2, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 2, m_Pos.Y - 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 2, m_Pos.Y - 1] == 0 && arr[m_Pos.X, m_Pos.Y - 2] == 0)
                                    result = true;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写判断是否可以右移的方法
            public override bool CanRightMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.Y < columns - 1)
                        {
                            if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 1] == 0 && arr[m_Pos.X - 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 1:
                        if (m_Pos.Y + 1 < columns - 1)
                        {
                            if (m_Pos.X == 0)
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 2] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == 1)
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 2] == 0 && arr[m_Pos.X - 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X, m_Pos.Y + 2] == 0 && arr[m_Pos.X - 1, m_Pos.Y + 1] == 0 && arr[m_Pos.X - 2, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 2:
                        if (m_Pos.Y + 2 < columns - 1)
                        {
                            if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y + 1] == 0 && arr[m_Pos.X, m_Pos.Y + 3] == 0)
                                    result = true;
                            }
                        }
                        break;
                    case 3:
                        if (m_Pos.Y < columns - 1)
                        {
                            if (m_Pos.X == -2)
                            {
                                if (arr[m_Pos.X + 2, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else if (m_Pos.X == -1)
                            {
                                if (arr[m_Pos.X + 2, m_Pos.Y + 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X + 2, m_Pos.Y + 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0 && arr[m_Pos.X, m_Pos.Y + 1] == 0)
                                    result = true;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写判断是否可以下移的方法
            public override bool CanDropMove(int[,] arr, int rows, int columns)
            {
                bool result = false;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        if (m_Pos.X < rows - 1)
                        {
                            if (arr[m_Pos.X + 1, m_Pos.Y] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 1, m_Pos.Y - 2] == 0)
                                result = true;
                        }
                        break;
                    case 1:
                        if (m_Pos.X < rows - 1)
                        {
                            if (arr[m_Pos.X + 1, m_Pos.Y] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0)
                                result = true;
                        }
                        break;
                    case 2:
                        if (m_Pos.X + 1 < rows - 1)
                        {
                            if (arr[m_Pos.X + 1, m_Pos.Y + 2] == 0 && arr[m_Pos.X + 1, m_Pos.Y + 1] == 0 && arr[m_Pos.X + 2, m_Pos.Y] == 0)
                                result = true;
                        }
                        break;
                    case 3:
                        if (m_Pos.X + 2 < rows - 1)
                        {
                            if (m_Pos.X == -2)
                            {
                                if (arr[m_Pos.X + 3, m_Pos.Y] == 0)
                                    result = true;
                            }
                            else
                            {
                                if (arr[m_Pos.X + 1, m_Pos.Y - 1] == 0 && arr[m_Pos.X + 3, m_Pos.Y] == 0)
                                    result = true;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return result;
            }
    
            //重写获取砖块出现时y的坐标方法
            public override int Appear()
            {
                int result = 0;
                switch (m_CurTransforIndex)
                {
                    case 0:
                        result = 0;
                        break;
                    case 1:
                        result = 0;
                        break;
                    case 2:
                        result = -1;
                        break;
                    case 3:
                        result = -2;
                        break;
                    default:
                        break;
                }
                return result;
            }
        }
    }
    
    

    Bricks.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Drawing;
    using System.Collections;
    
    namespace OhMyTetris
    {
        class Bricks
        {
            //lock线程锁,所以方法和属性都要用静态的
            public static ArrayList _brickList = new ArrayList();
    
            //静态方法:随机获取一个砖块
            //非静态的字段、方法或属性“member”要求对象引用
            public static Brick GetBrick()
            {
                Random random = new Random(DateTime.Now.Second);
                int index = random.Next(7);
                Brick brick;
                switch (index)
                {
                    case 0:
                        brick = new Brick1(); break;
                    case 1:
                        brick = new Brick2(); break;
                    case 2:
                        brick = new Brick3(); break;
                    case 3:
                        brick = new Brick4(); break;
                    case 4:
                        brick = new Brick5(); break;
                    case 5:
                        brick = new Brick6(); break;
                    case 6:
                        brick = new Brick7(); break;
                    //default:
                        //brick = new Brick1(); break;
                }
                return brick;
            }
        }
    }
    
    

    Canvas.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Drawing;
    using System.Windows.Forms;
    using System.Threading;
    using System.Media;
    
    namespace OhMyTetris
    {
        class Canvas
        {
            #region 私有属性
            private int m_rows;
            private int m_columns;
            private int[,] m_arr;
    
            //装载声音文件
            private SoundPlayer m_bgm = new SoundPlayer("bgm.wav");
            private SoundPlayer m_disappear = new SoundPlayer("disappear.wav");
    
            //分数
            private int m_score;
    
            //当前砖块
            private Brick m_curBrick = null;
            
            //下一个砖块
            private Brick m_nextBrick = null;
    
            //判断是否消除行
            private bool m_flag = false;
    
            //当前高度
            private int m_height;
    
            private System.Windows.Forms.Timer m_timer = new System.Windows.Forms.Timer();
    
            #endregion 
    
            #region 公有属性
    
            public int m_Rows
            {
                get { return m_rows; }
                set { m_rows = value; }
            }
    
            public int m_Columns
            {
                get { return m_columns; }
                set { m_columns = value; }
            }
    
            public int[,] m_Arr
            {
                get { return m_arr; }
                set { m_arr = value; }
            }
    
            public int m_Score
            {
                get { return m_score; }
                set { m_score = value; }
            }
            #endregion
    
            //构造方法
            public Canvas()
            {
                m_rows = 20;
                m_columns = 20;
                m_arr = new int[m_rows, m_columns];
                for (int i = 0; i < m_rows; i++)
                {
                    for (int j = 0; j < m_columns; j++)
                    {
                        m_arr[i, j] = 0;
                    }
                }
                m_score = 0;
                m_height = 0;
    
                m_timer.Interval = 2400;
                m_timer.Enabled = false;
                m_timer.Tick += new EventHandler(m_timer_Tick);
    
            }
    
            #region 移动
            //左移
            public void BrickLeft()
            {
                lock (m_arr)
                {
                    if (m_curBrick != null && m_curBrick.CanLeftMove(m_arr, m_rows, m_columns) == true)
                    {
                        ClearCurBrick();
                        m_curBrick.LeftMove();
                        SetArrayValue();
                    }
                }
            }
    
            //右移
            public void BrickRight()
            {
                lock (m_arr)
                {
                    if (m_curBrick != null && m_curBrick.CanRightMove(m_arr, m_rows, m_columns) == true)
                    {
                        ClearCurBrick();
                        m_curBrick.RightMove();
                        SetArrayValue();
                    }
                }
            }
    
            //下移
            public void BrickDown()
            {
                lock (m_arr)
                {
                    if (m_curBrick != null && m_curBrick.CanDropMove(m_arr, m_rows, m_columns) == true)
                    {
                        ClearCurBrick();
                        m_curBrick.DropMove();
                        SetArrayValue();
                    }
                }
            }
    
            #endregion
    
            //自定义方法:变形
            public void BrickUp()
            {
                lock (m_arr)
                {
                    if (m_curBrick != null && m_curBrick.CanTransform(m_arr, m_rows, m_columns) == true)
                    {
                        ClearCurBrick();
                        m_curBrick.Transform();
                        SetArrayValue();
                    }
                }
            }
    
            //自定义方法:计算当期高度
            private void SetCurHeight()
            {
                for (int i = 0; i < m_rows; i++)
                {
                    for (int j = 0; j < m_columns; j++)
                    {
                        if (m_arr[i, j] == 1)
                        {
                            m_height = m_rows - i;
                            return;
                        }
                    }
                }
            }
    
            //自定义方法:定时器 判断砖块定时下降或无法下降时生成下一个新砖块
            public bool Run()
            {
                //lock 关键字可确保当一个线程位于代码的临界区时,另一个线程不会进入该临界区。
                //如果其他线程试图进入锁定的代码,则它将一直等待(即被阻止),直到该对象被释放。
                //lock 应避免锁定 public 类型,否则实例将超出代码的控制范围。
                lock (m_arr)
                {
                    if (m_flag == true)
                    {
                        m_bgm.PlayLooping();
                        m_flag = false;
                    }
                    if (m_curBrick == null && m_nextBrick == null)
                    {
                        m_curBrick = Bricks.GetBrick();
                        m_nextBrick = Bricks.GetBrick();
                        m_nextBrick.RandomShape();
                        m_curBrick.SetCenterPos(m_curBrick.Appear(), m_columns / 2 - 1);
                        SetArrayValue();
                    }
                    else if (m_curBrick == null)
                    {
                        m_curBrick = m_nextBrick;
                        m_nextBrick = Bricks.GetBrick();
                        m_nextBrick.RandomShape();
                        m_curBrick.SetCenterPos(m_curBrick.Appear(), m_columns / 2 - 1);
                        SetArrayValue();
                    }
                    else
                    {
                        if (m_curBrick.CanDropMove(m_arr, m_rows, m_columns) == true)
                        {
                            ClearCurBrick();
                            m_curBrick.DropMove();
                            SetArrayValue();
                        }
                        else
                        {
                            m_curBrick = null;
                            SetCurHeight();
                            ClearRow();
                        }
                    }
                    if (m_score >= 100)
                        return false;
                    if (m_height < m_rows)
                        return true;
                    else
                        return false;
                }
            }
    
            //自定义方法:根据清除当前砖块在m_arr中的值
            private void ClearCurBrick()
            {
                int centerX = m_curBrick.m_Center.X;
                int centerY = m_curBrick.m_Center.Y;
                for (int i = 0; i < m_curBrick.m_NeedfulRows; i++)
                {
                    for (int j = 0; j < m_curBrick.m_NeedfulColumns; j++)
                    {
                        int realX = m_curBrick.m_Pos.X - (centerX - i);
                        int realY = m_curBrick.m_Pos.Y - (centerY - j);
                        if (realX < 0 || realX >= m_columns || realY < 0 || realY >= m_rows)
                        {
                            continue;
                        }
                        else
                        {
                            if (m_curBrick.m_Range[i, j] == 0)
                            {
                                continue;
                            }
                            else
                            {
                                m_arr[realX, realY] = 0;
                            }
                        }
                    }
                }
            }
    
            //自定义方法:判断当前砖块设置m_arr的值
            public void SetArrayValue()
            {
                int centerX = m_curBrick.m_Center.X;
                int centerY = m_curBrick.m_Center.Y;
                for (int i = 0; i < m_curBrick.m_NeedfulRows; i++)
                {
                    for (int j = 0; j < m_curBrick.m_NeedfulColumns; j++)
                    {
                        int realX = m_curBrick.m_Pos.X - (centerX - i);
                        int realY = m_curBrick.m_Pos.Y - (centerY - j);
                        if (realX < 0 || realX >= m_columns || realY < 0 || realY >= m_rows)
                        {
                            continue;
                        }
                        else
                        {
                            if (m_curBrick.m_Range[i, j] == 0)
                            {
                                continue;
                            }
                            else
                            {
                                m_arr[realX, realY] = 1;
                            }
                        }
                    }
                }
            }
    
            //自定义方法:画出下一个砖块
            public void DrawNewxBrick(Graphics gra, float width, float heigth)
            {
                int[,] arr = new int[5, 5]{{0,0,0,0,0},
                                             {0,0,0,0,0},
                                             {0,0,0,0,0},
                                             {0,0,0,0,0},
                                             {0,0,0,0,0,}};
                switch (m_nextBrick.m_NeedfulColumns)
                {
                    case 2:
                        arr[2, 2] = 1;
                        arr[2, 3] = 1;
                        arr[3, 2] = 1;
                        arr[3, 3] = 1;
                        break;
                    case 3:
                        for (int i = 1, m = 0; i < 4; i++, m++)
                        {
                            for (int j = 1, n = 0; j < 4; j++, n++)
                            {
                                arr[i, j] = m_nextBrick.m_Range[m, n];
                            }
                        }
                        break;
                    case 5:
                        arr = m_nextBrick.m_Range;
                        break;
                    default:
                        return;
                }
    
                for (int i = 0; i < 5; i++)
                {
                    for (int j = 0; j < 5; j++)
                    {
                        if (arr[i, j] == 1)
                        {
                            gra.FillRectangle(Brushes.Orange, j * width, i * heigth, width - 2, heigth - 2);
                        }
                    }
                }
            }
    
            //自定义方法:播放声音文件
            private void PlaySound(SoundPlayer soundFile)
            {
                //使用新线程播放声音
                soundFile.Play();
            }
            //自定义方法:消除音乐的计时器
            void m_timer_Tick(object sender, EventArgs e)
            {
                m_flag = true;
                m_timer.Enabled = false;
            }
    
            //自定义方法:判断有没有填满的行,有就消除,更新得分
            private void ClearRow()
            {
                int clearrows = 0;
                for (int i = m_rows - m_height; i < m_rows; i++)
                {
                    bool isfull = true;
                    for (int j = 0; j < m_columns; j++)
                    {
                        if (m_arr[i, j] == 0)
                        {
                            isfull = false;
                            break;
                        }
                    }
                    if (isfull == true)
                    {
                        m_timer.Enabled = true;
                        m_disappear.Play();
                        clearrows++;
                        m_score++;
                        for (int k = 0; k < m_columns; k++)
                        {
                            m_arr[i, k] = 0;
                        }
                    }
                }
                for (int i = m_rows - 1; i > m_rows - m_height - 1; i--)
                {
                    bool isfull = true;
                    for (int j = 0; j < m_columns; j++)
                    {
                        if (m_arr[i, j] == 1)
                        {
                            isfull = false;
                            break;
                        }
                    }
                    if (isfull == true)
                    {
                        
                        int n = i;
                        for (int m = n - 1; m > m_rows - m_height - 2; m--)
                        {
                            if (n == 0)
                            {
                                for (int k = 0; k < m_columns; k++)
                                {
                                    m_arr[n, k] = 0;
                                }
                            }
                            else
                            {
                                for (int k = 0; k < m_columns; k++)
                                {
                                    m_arr[n, k] = m_arr[m, k];
                                }
                                n--;
                            }
                        }
                    }
                }
                m_height -= clearrows;
            }
    
        }
    }
    
    

    现存bug

    ……
    关了背景音乐但关不掉特效T-T(有时间打算暑假弄一个音乐播放器,因为soundplayer只能播放wav文件我也是疯了,mp3到wav文件的转码弄得我,,,后来才发现有直接转码的网站)
    https://www.aconvert.com/cn/audio/wav-to-mp3/
    我用的是这个
    特效和背景音乐不能同时播放(百度到的解决方案行不通…)
    那个判断是否满行的方法有问题,后来直接弄了两个for循环,如果连消两行砖块的话,,,,就会报错,所以不能实现消除的行数越多,所获得的分数越高的玩家需求- -

    展开全文
  • C#语言程序设计-C#期末作业课程管理系统源代码。基于vs+Sql Server环境 使用C#语言 实现了学生对开课的课程查询 选课 退课 学生对个人信息的增删改查 对老师信息的查询 实现了老师对学生课程的打分 实现了管理...
  • C#期末作业教学课堂考勤管理系统源代码。C#的期末大作业,前端使用C# winform窗体开发,后端使用C#,数据库使用Sql Server。 登录窗口 组件 用户名:TextBox1 密码:TextBox2 验证码:TextBox3、PictureBox 生成...
  • 学生信息管理系 统 期末作业C# c++
  • C#期末作业银行管理系统源码+文档报告,已获得老师指导的高分项目。 本银行账户管理信息系统能实现的主要功能有:登录页面;开户、存款、取款;当日汇总,汇总查询,存款查询;职员管理,工资调整;更改账户密码...
  • C#期末作业----飞机大战小游戏,已获通过的高分项目 2. 项目概述 玩家将操作飞机,在空中进行战斗。游戏画面清晰,操作流畅。 3. 游戏策划 3.1游戏基本描述 3.1.1游戏名称 飞机大战 3.1.2游戏主题 飞机对抗 ...
  • 基于C#和SQLServer开发的一款鲜花管理系统,可以实现鲜花的基本管理以及售卖记录等功能。已获老师指导的高分项目。 基于C#和SQLServer开发的一款鲜花管理系统,可以实现鲜花的基本管理以及售卖记录等功能。已获老师...
  • 本人C#期末作业,程序写的比较菜,有点繁琐,但是初学xml和数据库操作的人可以看看。。。
  • C#期末作业—影院售票系统源码+数据库+开发文档 C#课程设计—影院售票系统源码+数据库+开发文档,老师指导通过的最终版本,纯手打高分项目。 系统主要分为三大模块:系统前台模块、系统后台模块和数据库。 系统...
  • C#期末作业课程设计图书管理系统源码+数据库+文档报告。 配置 运行此程序需要安装 vs2019 或更高版本的 vs,或者安装了.net framework 建立此数据库,数据库建立文件见附件 library-sql,其中数据库版本为为 mysql...
  • 期末作业C#实现学生宿舍管理系统

    千次阅读 多人点赞 2022-06-12 18:30:20
    由于快期末考了,需要提交一份C#开发的管理系统,这里选择可视化开发,管理系统无非就是增、删、查、改,可以使用接口完成查询、删除等等…这里直接用自带的封装方法进行增删查改,本文做一个记录,也作为一次开发...

    🚀开发背景

    完整代码下载地址:点我下载

    优化移步:
    《c#中在datagridview的表格动态增加一个按钮方法》
    《C#实现多窗口切换:Panel详细教程(亲测)》


    文章还在更新,上次更新时间2022/06/20 20:49
    由于快期末考了,需要提交一份C#开发的管理系统,这里选择可视化开发,管理系统无非就是增、删、查、改,可以使用接口完成查询、删除等等…这里直接用自带的封装方法进行增删查改,本文做一个记录,也作为一次开发经历,需要完整项目的可以选择付费支持,文末会放出链接

    成品:
    在这里插入图片描述



    🚀 工具准备

    工具名称说明
    phpstudy 包含Mysql5.7.26点我下载
    Microsoft Visual Studio 2010
    icon生成工具http://www.51tool.com/ico/
    需要引用数据库MySql.data点我下载

    🚀 数据库添加引用

    由于本项目使用的是MySql进行连接,C#需要下载一个dll文件来进行引用,才可以在代码中使用,通上网搜索或者 点我下载

    下载文件如图所示:
    在这里插入图片描述
    将该文件丢入项目文件夹中,然后在Microsoft Visual Studio 2010的解决方案资源管理器中的引用右键点击添加
    在这里插入图片描述

    (选择MySql.Data所在的路径添加即可,引用成功后如下图所示)
    在这里插入图片描述

    在后面的代码中我们只需引用即可:

    using System.Data.SqlClient;
    using MySql.Data.MySqlClient;
    using MySql.Data;
    

    数据库环境配置

    首先下载好phpstudy,在上文部分工具可以下载,安装略过

    1、打开phpstudy
    在这里插入图片描述
    2、开启数据库和ApaChe
    在这里插入图片描述
    3、在软件管理中下载phpmyadmin
    在这里插入图片描述
    4、打开数据库并建立数据表
    打开首页的数据库工具(选择phpmyadmin)
    在这里插入图片描述
    输入账号密码登陆进去(默认root root 我这里因为改过所以我的是123456,大家可以去左侧数据库修改)
    在这里插入图片描述
    [2022/06/14]由于文章是在一点点更新的,后面增加的数据表就在对应文章中写入,下面的是用户登录、注册以及供用户列表显示
    新建demo数据库,并在该数据库建立两个数据表:admin、user
    在这里插入图片描述
    admin表字段设计如下:
    在这里插入图片描述
    user表字段设计如下:
    在这里插入图片描述
    这里仅仅放入两个表,完整项目请下载代码


    登录设计

    登录页面设计

    这里我们通过可视化工具进行设计,新建一个窗口为FORM1这是设计出来的样子
    在这里插入图片描述

    更换窗口图标方法

    现在更换左上角图标,首先打开我们需要用的icon网站,生成后下载转换文件保存到本地
    在这里插入图片描述
    对窗体右键属性更换默认图标

    在这里插入图片描述
    更换好了之后
    在这里插入图片描述


    登录功能设计

    双击登录按钮
    在这里插入图片描述
    在该点击事件中,加入代码(代码中有注释自己看哈)

     //登录
                var db_name = "admin";
    
                //数据插入
                //MySqlCommand mycmd = new MySqlCommand("INSERT INTO `admin` (`id`, `username`, `password`) VALUES (NULL, 'www', 'wwww');", mycon);
                //if (mycmd.ExecuteNonQuery() > 0)
                //{
                //    MessageBox.Show("修改成功!");
               // }
    
                //检查
                if (textBox1.Text == "" || textBox2.Text == "")
                {
                    MessageBox.Show("请检查输入是否完整!");
                }
               
                else { 
                //配置数据库
                   // string constr = "Database=cshap;Data Source=49.234.42.125;port=888;User Id=cshap;Password=123456";
                
                    string constr = "server=127.0.0.1;port=3306;User Id=root;password=123456;Database=demo";
                    //连接数据库
                    MySqlConnection mycon = new MySqlConnection(constr);
                    mycon.Open();
                    //输入数据命令;
                    //数据插入
    
                    if (radioButton1.Checked == false)
                    {
                        db_name = "user";
                    }
    
                    MySqlCommand mycmd = new MySqlCommand("SELECT * FROM `" + db_name + "` WHERE `username`='" + textBox1.Text + "' and password='" + textBox2.Text + "'", mycon);
    
                    if (Convert.ToInt32(mycmd.ExecuteScalar()) > 0)
                    {
                        //MessageBox.Show("登陆成功!");
                        //判断跳转界面
    
                        if (db_name == "admin")
                        {
                            //管理端
                            Form2 f = new Form2();
                            this.Hide();
                            f.ShowDialog();
                            this.Show();
                        }
                        else { 
                        //用户端
                        
                        }
                    }
                    else {
                        MessageBox.Show("账号或密码、登录身份错误!");
                    }
                    Console.ReadLine();
                    mycon.Close();
    
    
    
                //       
    

    窗体之间相互跳转方法

                    Form2 f = new Form2();  //实例化跳转窗口
                    this.Hide(); 
                    f.ShowDialog();
                    this.Show();
    

    注册设计

    新建FORM3窗口设计如下
    在这里插入图片描述
    双击注册添加代码:

      //注册操作
                //检查
                if (textBox1.Text == "" || textBox2.Text == "" || textBox3.Text == "" || textBox4.Text == "")
                {
                    MessageBox.Show("请检查输入是否完整!");
                }
                else if(textBox2.Text != textBox3.Text)
                {
                    MessageBox.Show("两次密码不一致");
                
                }
                else
                {
                    //配置数据库
                    string constr = "server=localhost;User Id=root;password=123456;Database=demo";
                    //连接数据库
                    MySqlConnection mycon = new MySqlConnection(constr);
                    mycon.Open();
                    //输入数据命令;
                    //数据插入
    
                    MySqlCommand mycmd = new MySqlCommand("INSERT INTO `user` (`id`, `username`, `password`, `room_num`) VALUES (NULL, '" + textBox1.Text + "', '" + textBox2.Text + "', '" + textBox4.Text + "');", mycon);
                if (mycmd.ExecuteNonQuery()> 0)
                {
                    MessageBox.Show("注册成功!");
                    Form1 f = new Form1();
                    this.Hide();
                    f.ShowDialog();
                    this.Show();
                }
                   
                    else
                    {
                        MessageBox.Show("账号或密码、登录身份错误!");
                    }
                    Console.ReadLine();
                    mycon.Close();
                }
    

    项目功能设计

    后台管理界面

    在这里插入图片描述


    用户管理

    创建一个dataGridView1视图,添加字段后如下所示

    注意:在新的优化界面中我将该部分窗体重新放到了用户控件中去了,通过panel完成跳转交互,优化用户体验,如果需要更改优化的同学,可以看优化部分(2022/06/14修改)

    在这里插入图片描述


    添加用户

    在这里插入图片描述
    在添加用户方法中添加代码(双击“添加用户添加代码”),即从账号、密码、宿舍号获取值,再通过语句进行插入到数据库,具体操作方法:添加记录到本地后,添加进数据库,
    本地假数据的添加代码为:

     //添加数据到本地dataGridView1
    //本地
    int index = this.dataGridView1.Rows.Add();
    this.dataGridView1.Rows[index].Cells[0].Value = "NULL";
    this.dataGridView1.Rows[index].Cells[1].Value = "1111";
    this.dataGridView1.Rows[index].Cells[2].Value = "222";
    this.dataGridView1.Rows[index].Cells[3].Value = "333";
    

    可以先通过假数据测试按钮是否加入了数据,加入了的话我们在通过连接数据库来进行一个遍历插入,即下方的代码
    完整代码:

    //添加用户
    //修改本地 和数据库
    //本地
    int index = this.dataGridView1.Rows.Add();
    this.dataGridView1.Rows[index].Cells[0].Value = "NULL";
    this.dataGridView1.Rows[index].Cells[1].Value = textBox1.Text;
    this.dataGridView1.Rows[index].Cells[2].Value = textBox2.Text;
    this.dataGridView1.Rows[index].Cells[3].Value = textBox3.Text;
    
                //修改方法
                //dataGridViewInfo.Rows[i].Cells[0].Value = name;//更新名称
                //dataGridViewInfo.Rows[i].Cells[1].Value = status;//更新状态
    
                //   dataGridView.Rows.Remove(dataGridView.SelectedRows[0]);  //删除一行
    
                //插入数据库同步
    
                //配置数据库
                string constr = "server=localhost;User Id=root;password=123456;Database=demo";
                //连接数据库
                MySqlConnection mycon = new MySqlConnection(constr);
                mycon.Open();
                //输入数据命令;
                //数据插入
    
                MySqlCommand mycmd = new MySqlCommand("INSERT INTO `user` (`id`, `username`, `password`,`room_num`) VALUES (NULL, '" + textBox1.Text + "', '" + textBox2.Text + "', '" + textBox3.Text + "');", mycon);
                if (mycmd.ExecuteNonQuery() > 0)
                {
                    MessageBox.Show("添加成功!");
                    this.dataGridView1.Refresh();  
                    //刷新显示
                }
    
                else
                {
                    MessageBox.Show("添加失败!");
                }
                Console.ReadLine();
                mycon.Close();
    

    删除

    与插入不同,这里需要对dataGridView1做一个获取,需要获取id值,来进行删除,首先新建一个“删除”按钮
    在这里插入图片描述
    双击在该方法中加入代码(这部分代码很关键,建议看懂,在开发中我找到另外一个方法不过他存在bug,这个无论有没有值不会报错)

     //删除
    int index = dataGridView1.SelectedCells[0].RowIndex;
    //获取所在行
    var aa = dataGridView1.Rows[index].Cells[0].Value;
    //获取所在行第一列的元素
    dataGridView1.Rows.RemoveAt(index);
    MessageBox.Show(aa.ToString());
    

    这一步的作用是获取到鼠标选中所在行的第一列元素的值,也就是id值,并删除当前行
    我们测试下:
    在这里插入图片描述
    接下来,只需要把获取到的id => 6 进行sql语句操作即可
    完整代码:

      //删除
    int index = dataGridView1.SelectedCells[0].RowIndex;
    //获取所在行
    var aa = dataGridView1.Rows[index].Cells[0].Value;
    //获取所在行第一列的元素
    dataGridView1.Rows.RemoveAt(index);
    //MessageBox.Show(aa.ToString());
    //本地删除
    //联网删除
    //配置数据库
    string constr = "server=localhost;User Id=root;password=123456;Database=demo";
                //连接数据库
                MySqlConnection mycon = new MySqlConnection(constr);
                mycon.Open();
                //输入数据命令;
                //数据插入
    
                MySqlCommand mycmd = new MySqlCommand("DELETE FROM `user` WHERE `id` = '"+aa+"'", mycon);
                if (mycmd.ExecuteNonQuery() > 0)
                {
                    MessageBox.Show("删除成功!");
                    this.dataGridView1.Refresh();  
                    //刷新显示
                }
    
                else
                {
                    MessageBox.Show("删除失败!");
                }
                Console.ReadLine();
                mycon.Close();
    

    修改

    新建一个窗口(在资源管理器右键),命名为FORM5,用于点击修改时,弹出一个窗口供用户修改,设计图如下:
    在这里插入图片描述
    设计好后,回到Form4中,刚刚不是设计了删除嘛,修改和删除一样,先获取id值就可以,所以步骤是一样的,新建一个修改按钮,如下图所示:
    在这里插入图片描述
    双击后我们在该点击事件加入获取id的代码(和刚刚的一样):

     //修改
    int index = dataGridView1.SelectedCells[0].RowIndex;
    //获取所在行
    var aa = dataGridView1.Rows[index].Cells[0].Value;
    //获取所在行第一列的元素
    MessageBox.Show(aa.ToString());
    

    接下来需要把id传给Form5窗口,我们在这里了解下通过构造函数传值

    特点:传值是单向的(不可以互相传值),实现简单

    接收窗体需要如下代码:
    (这里的id为string是因为我们在dataGridView1获取到的值类型为string所以这里我们用字符串接收,搞错类型就会报错红)

    在这里插入图片描述

     		string id;
            public Form5(string value1)
            {
                InitializeComponent();
                this.id = value1;
                MessageBox.Show(id.ToString());
            }
    

    传递窗体调用即可
    new Form5(aa.ToString()).Show();

    根据传过来的id进行查询最后显示到控件上去
    这里接收到参数后演示图如下:
    在这里插入图片描述

    完整From5代码如下(注意上方代码举例需要全部写完才不会报错):

    public Form5(string value1)
            {
                InitializeComponent();
                this.id = value1;
                //MessageBox.Show(id.ToString());
                //配置数据库
                string constr = "server=localhost;User Id=root;password=123456;Database=demo";
                //连接数据库
                MySqlConnection mycon = new MySqlConnection(constr);
                mycon.Open();
                //输入数据命令;
                MySqlCommand mycmd = new MySqlCommand("SELECT * FROM `user` where id=" + id + "", mycon);
                MySqlDataReader rec = mycmd.ExecuteReader();
                while (rec.Read())
                {
    
                    label5.Text = rec[0].ToString();
                    textBox1.Text = rec[1].ToString();
                    textBox2.Text = rec[2].ToString();
                    textBox3.Text = rec[3].ToString();
    
                }
               
            }
    

    成功截图
    在这里插入图片描述

    实现保存

    在From5中新建保存按钮,双击后,在该按钮中添加点击事件
    在这里插入图片描述
    首先获取id、账号、密码、宿舍号

     			var id = label5.Text;
                var zh = textBox1.Text;
                var mm = textBox2.Text;
                var ss = textBox3.Text;
    

    建立sql语句

    MySqlCommand mycmd = new MySqlCommand("UPDATE `user` SET `username` = '', `password` = '', `room_num` = '' WHERE `id` = 1;", mycon);
    

    完整代码:

    
                var id = label5.Text;
                var zh = textBox1.Text;
                var mm = textBox2.Text;
                var ss = textBox3.Text;
                //配置数据库
                string constr = "server=localhost;User Id=root;password=123456;Database=demo";
                //连接数据库
                MySqlConnection mycon = new MySqlConnection(constr);
                mycon.Open();
                //输入数据命令;
                //数据插入
    
                MySqlCommand mycmd = new MySqlCommand("UPDATE `user` SET `username` = '"+zh+"', `password` = '"+mm+"', `room_num` = '"+ss+"' WHERE `id` = '"+id+"';", mycon);
                if (mycmd.ExecuteNonQuery() > 0)
                {
                    MessageBox.Show("修改成功!");
                  
                    //刷新显示
                }
    
                else
                {
                    MessageBox.Show("修改失败!");
                }
                Console.ReadLine();
                mycon.Close();
    

    成功截图
    在这里插入图片描述

    △钥匙借出登记

    [2022/06/14] 在完成设计之前我们需要分析下,钥匙借出登记需要些什么字段:

    borrow表:

    字段说明类型
    id自增int(11)
    user_id对应User表中的id绑定,为了识别用户方便进行连表查询varchar(20)
    d_time钥匙借出时间datetime
    is_give是否归还,0未归还1归还int(11)

    我们将钥匙借阅登记表在数据库新建为borrow

    流程:在管理员点击钥匙借出登记时,显示出借阅登记id、学生姓名、宿舍号、借出时间、是否归还,我们只需要通过user_id去user表中查询其他信息即可,所以borrow表中的user_id需要和user表中的id对应绑定(很多同学在设计时会将多个重复信息放在同一个表中,如果在borrow表中加入了room_num字段这样的话就不方便修改了,因为这时同一个字段会在多个表中,不利于修改,大家一定要明白这点,可以配合下图参照理解这句话)

    user表:
    在这里插入图片描述

    ok分析完毕,我们来设计数据库

    1、打开phpmyadmin我们新建数据表borrow,并按照下图第三步完成修改后保存

    在这里插入图片描述

    2、设计好后我们查看下

    在这里插入图片描述

    3、我们在数据中运行语句

    INSERT INTO `borrow` (`id`, `user_id`, `d_time`, `is_give`) VALUES (NULL, '1', CURRENT_TIMESTAMP, '0');
    

    (上面的user_id为1是因为我的user表中有一个id为1的用户,我们先用假数据显示,后面再通过前端完成借阅操作)

    4、设计用户控件

    ①打开【解决方案资源管理器】在项目中右键【添加】 【用户控件】
    在这里插入图片描述
    ②然后修改下窗体大小和之前的一样,这样在切换过程中就不会感觉框的变化在这里插入图片描述
    ③设计可视化窗体(根据自己的需求自己来)
    我们添加一个datagridview,然后对图中阴影部分右键【编辑列】
    在这里插入图片描述
    编辑列在添加id、学生姓名、宿舍号、借出时间、是否归还在这里插入图片描述
    设计好后如下图
    在这里插入图片描述

    5、绑定主页面实现跳转(从Form2)

    实现图:
    在这里插入图片描述
    ①首先打开Form2的视图,双击【钥匙借阅登记】按钮
    ②双击后在本页面添加代码

    在窗体部分输入:

    public UserControl4 f4; //钥匙借阅登记
    

    在窗体加载处输入:

      f4 = new UserControl4();    //钥匙借阅登记
    

    添加后如图所示:
    在这里插入图片描述

    在【钥匙借阅登记】按钮处添加

     			f4.Show();   //将窗体一进行显示
                panel2.Controls.Clear();    //清空原容器上的控件
                panel2.Controls.Add(f4);    //将窗体一加入容器panel2
    

    添加后如图所示:
    在这里插入图片描述
    编译运行代码成功截图:
    在这里插入图片描述

    6、显示数据

    我们找到刚刚创建好的UserControl4.cs文件,双击此处

    在这里插入图片描述

    在UserControl4_Load方法处添加如下代码:

     //配置数据库
                string constr = "server=localhost;User Id=root;password=123456;Database=demo";
                //连接数据库
                MySqlConnection mycon = new MySqlConnection(constr);
                mycon.Open();
                //输入数据命令;
                //数据插入
    
    
    
                MySqlCommand mycmd = new MySqlCommand("SELECT * FROM `borrow`", mycon);
                MySqlDataReader rec = mycmd.ExecuteReader();
                while (rec.Read())
                {
    
                    int index = this.dataGridView1.Rows.Add();
                    this.dataGridView1.Rows[index].Cells[0].Value = rec.GetInt32(0);
                    this.dataGridView1.Rows[index].Cells[1].Value = rec[1];
                    this.dataGridView1.Rows[index].Cells[2].Value = rec[2];
                    this.dataGridView1.Rows[index].Cells[3].Value = rec[3];
                    this.dataGridView1.Rows[index].Cells[4].Value = rec[4];
    
                }
    

    写好以后,这里出现了报红的错误,遇到报红不要慌
    在这里插入图片描述

    解决办法:引用mysql数据库文件

    using System.Data.SqlClient;
    using MySql.Data.MySqlClient;
    using MySql.Data;
    

    添加后如图:
    在这里插入图片描述

    我们运行看结果
    在这里插入图片描述

    7、关联表查询

    为了解决上面图片蓝色字体[上面的学生姓名和宿舍号,需要用user_id去user表里面查询]
    所以我们需要用到sql语法使两个表关联起来(user_id对应id)
    对这个SQL语句不懂的同学看这个:
    在这里插入图片描述

    我门再将之前的数据表拿出来对照
    User表
    在这里插入图片描述
    borrow表
    在这里插入图片描述

    手写SQL语句:

    SELECT b.id,u.username,u.room_num,b.d_time,b.is_give from demo.borrow b inner join demo.user u on b.user_id=u.id
    

    在sql运行成功:
    在这里插入图片描述


    宿舍卫生打分

    与上面一样,不做赘述


    电梯保修记录

    与上面一样,不做赘述


    优化

    这部分是对项目进行个优化

    窗体优化

    在整个项目中窗体太多不美观,如果能实现点击按钮直接显示就能提升用户体验性,可参考这篇文章
    C#实现多窗口切换:Panel详细教程(亲测)

    对项目完成优化后效果如下:

    20220613_215754


    重点难点讲解

    这部分对全文做一个归纳,防止有的地方遗漏了,如果你有疑问可以看这里!

    如果做到修改删除? 答:通过表单传值记录id在新的一个窗口查询一次数据,更新则是用了update

    如果做到删除? 答:通过表单传值获取到的id进行数据库语句删除,删除本地的再删除数据库里面的

    窗口如何传值:
    本次通过构造函数,特点:传值是单向的(不可以互相传值),实现简单

    实现代码如下:

    在目标窗体中

    int value1;
    
    string value2;
    
    public Form2 ( int value1 , string value2 )
    
    {
    
        InitializeComponent ( );
    
        this.value1 = value1;
    
        this.value2 = value2;
    
    }
    

    在父级窗体中(跳转前)这样调用

    new Form2 ( 111 , "222" ).Show ();  //这样就把111,"222",这2个值传送给了Form2
    

    数据库部分视图以及需要用到的语句

    在这里插入图片描述
    admin表
    在这里插入图片描述
    用户表
    在这里插入图片描述

    连接数据库(注意修改以下配置)

     string constr = "server=127.0.0.1;port=3306;User Id=root;password=123456;Database=demo";
          //连接数据库
      MySqlConnection mycon = new MySqlConnection(constr);
      mycon.Open();
    

    查询语句

     MySqlCommand mycmd = new MySqlCommand("SELECT * FROM `user`", mycon);
                MySqlDataReader rec = mycmd.ExecuteReader();
    

    插入语句

     MySqlCommand mycmd = new MySqlCommand("INSERT INTO `表名` (`id`, `username`, `password`,`room_num`) VALUES (NULL, '', '', '');", mycon);
    

    删除语句

     MySqlCommand mycmd = new MySqlCommand("DELETE FROM `user` WHERE `id` = ''", mycon);
    

    结合文中所给的来看,明天在更新!

    展开全文
  • C#程序设计》期末作业复习答案

    千次阅读 2020-12-25 13:12:25
    C#程序设计简述C#语言的特点简述C#的主要应用领域简述类的定义及类的声明形式简述代码书写的主要规则简述类和对象的关系简述标识符的定义及标识符命名规则。编程题: 简述C#语言的特点 1、简洁的语法 2、与Web的...

    简述C#语言的特点

    1、简洁的语法
    2、与Web的紧密结合
    3、可靠的安全性与错误处理
    4、版本处理技术
    5、灵活性和兼容性
    6、C#语言不在存在全局函数、全局变量,所有的函数、变量和常量都必须定义在类中,避免了命名冲突。
    7、C#语言不支持指针。一切对内存的访问都必须通过对象的引用变量实现,只允许访问内存中允许访问的内容,防止病毒程序使用非法指针访问私有成员,也避免指针误操作产生的错误。

    简述C#的主要应用领域

    桌面、网络、嵌入式三个方面

    简述类的定义及类的声明形式

    类的额定义:在C#中必须先声明类,然后才能在程序中使用。

    类的声明形式:

    [类的属性] [访问修饰符] class 类名称 [: 父类名]
    {
        [成员修饰符] 类的成员变量或者成员函数
    }
    

    简述代码书写的主要规则

    1、编写C#程序是,统一代码缩进样式,比如统一缩进两个字符或者4个字符位置。
    2、每编写完一行C#代码后都应该换行编写下一行代码。
    3、在编写C#代码时,应该合理使用空格,以便使代码结构更加清晰。
    4、尽量使用接口,然后使用类实现接口,以提高程序的灵活性。
    5、关键的语句(包括声明关键的变量)必须要写注释。
    6、局部变量在最接近使用它的地方声明。
    7、不要使用goto系列语句,除非是用在跳出深层循环时。
    8、避免编写超过5个参数的方法,如果要传递多个参数,则使用结构。
    9、避免书写代码量过大的try…catch语句块。避免在同一个文件中编写多个类。
    10、生成和构建一个长的字符串时,一定要使用StringBuilder类型,而不用string类型。
    11、对于if语句,应该使用一对大括号“{ }”把语句块括起来。
    12、swich语句一定要有default语句来处理意外情况

    简述类和对象的关系

    类:一种数据类型,定义了存储哪些数据(成员变量)以及如何处理这些数据的行为(成员函数); 对象:也叫实例,是类的具体个案;
    同一个类的对象都具有相同的存储结构和行为功能,但具体每个对象存储的数据可以不同。

    简述标识符的定义及标识符命名规则。

    1、标识符首字母可由 (a-z,A-Z, _ ,@),后续字符可由(a-z,A-Z, _ , 0-9)组成
    数字不能放在首位
    字母 下划线 可以用在任何位置
    @字符只能存在标识符首位

    2、C#命名规范

    Camel命名法
        首个字母小写,其余首字母大写(enemyHp)
    
    Pascal命名规范
        每个首字母大写(EnemyHp)
        如果用到英文单词缩写,则使用大写字母(PHP,PI,MP,HP)
        变量使用Camel命名,方法和类使用Pascal命名规范。
    

    3、不能使用关键字命名,关键字是对编译器具有特殊意义的预定义保留标识符。

    编程题:

    采用C#编写一个简易计算器,主要包含下列功能

    (1)可实现加减乘除运算

    (2)具有开根号功能

    (3)具有求模功能

    (4)可实现进制相互转换:二进制、10进制、16进制转换

    (5)具有计算Sin和Cos功能

    (6)界面要显示学号和姓名

    代码下载:https://download.csdn.net/download/qq_43581670/13779127请添加图片描述

    请添加图片描述
    请添加图片描述

    展开全文
  • C#期末作业—基于ASP.NET的智能停车场管理系统源码+数据库+开发文档。高分项目。 功能设计 3.1 网站功能 3.1.1 停车场、停车位监控页面 停车场分为立体停车场(多层)、平面停车场(可以存在多个分区)、道路两侧...
  • C#本科期末作业MVC三层架构亮灯的仓库管理系统源码。MVC+MYSQL+EasyuiC#本科期末作业MVC三层架构亮灯的仓库管理系统源码。MVC+MYSQL+EasyuiC#本科期末作业MVC三层架构亮灯的仓库管理系统源码。MVC+MYSQL+...
  • 软件构造期末作业-基于C#的虚拟派对软件,已获通过的高分项目。 软件构造期末作业-基于C#的虚拟派对软件,已获通过的高分项目。软件构造期末作业-基于C#的虚拟派对软件,已获通过的高分项目。软件构造期末大...
  • C#的本科期末作业上课管理系统源码。C#期末作业,前端使用C# winform窗体开发,后端使用C#,数据库使用Sql Server。功能介绍 点名、查询点名记录 3.1.1 点名 选中课程和人数(人数为0则点全班的名)之后 1....
  • C#课程设计大作业基于ASP.NET期末作业+四次日常作业大合集.net期末作业+四次日常作业大合集,包含期末作业公益管理系统,固定资产管理系统,个人记事本系统,计算器。.net期末作业+四次日常作业大合集,包含...
  • 自己参照博客上一些大佬做的,有一些功能尚未完善,压缩包里面有一个 《C#期末作业功能总结.txt》文件,里面有简单的工具和功能完善情况。
  • C#期末作业——学生成绩管理

    千次阅读 2017-06-13 03:11:39
    作业要求 学生成绩管理 (1)class Student { int id; string name; int score; Student next; } (2)用链表或系统List类实现。用数组实现也可(上限100条记录)? (3)增:检查学号无重复 (4)删:若输入整数则...
  • 数据库期末作业-C#图书管理系统源码+数据库+文档 安装教程 见使用说明使用setup安装 1.运行此程序需要安装vs2019或更高版本的vs,或者安装了.net framework 2.建立此数据库,数据库建立文件见附件library-sql...
  • 下载本资源后,如需提交成期末作业 只需修改帮助中的小组成员名,可在数据库中进行修改,这个网上教程随便一搜就可以查到,跟着做一遍就可以修改 本篇资源也提供完整课程设计报告,自行添加小组成员名即可 课程...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 828
精华内容 331
关键字:

c#期末作业

c# 订阅