用C#实现的两个试验编程（txt文本数据的导入，和数据导出为TXT）

1. 文件的存取

数据文件1.txt为学生成绩统计表，要对它做一个统计工作。文件中若一个人有多个成绩，则取他们的最好成绩来统计，然后计算全班平均成绩；统计0-69、70-79、80-89、90-100分的人数；若不要85分以下的成绩，求一下平均成绩是多少；将学生名字和成绩另存为一个文件2.txt，注意，多个成绩取最好一个保存。

说明：1.txt的格式是这样的：序号    学号    姓名    选修/必修    成绩

设计数据库：如图

aaarticlea/png;base64,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" alt="" />aaarticlea/png;base64,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" alt="" />

其实在设计数据库时候应该让StudentScore为int字段，我设计成了string类型的，所以在后面的统计部分需要将某些字段转换为int，使用Convert(int,数据库字段名)

第一步，新建一个项目SAMSys

新建一个SqlHelp.cs的类，代码如下：

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

namespace SAMSys
{
   static class SqlHelper  //只在DAL层调用，所以设置为static
    {
        //每个实例都需要查看是否修改连接字符串
        private static string connStr = ConfigurationManager.ConnectionStrings["dbStudentScoreStr"].ConnectionString;
        //封装方法的原则是：把不变的放到方法里，变化的方法参数中
        public static int ExecuteNonQuery(string sql)
        {
            using (SqlConnection conn = new SqlConnection(connStr))
            {
                conn.Open();
                using (SqlCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = sql;
                    return cmd.ExecuteNonQuery();
                }
            }
        }
        public static void ExecuteNonQuery(string sql, params SqlParameter[] parameters)
        {
            using (SqlConnection conn = new SqlConnection(connStr))
            {
                conn.Open();
                using (SqlCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = sql;
                    cmd.Parameters.AddRange(parameters);
                    cmd.ExecuteNonQuery();
                }
            }
        }
        public static object ExecuteScalar(string sql)
        {
            using (SqlConnection conn = new SqlConnection(connStr))
            {
                conn.Open();
                using (SqlCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = sql;
                    return cmd.ExecuteScalar();
                }
            }
        }
        public static DataSet ExecuteDataSet(string sql)
        {

            using (SqlConnection conn = new SqlConnection(connStr))
            {
                conn.Open();
                using (SqlCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = sql;
                    SqlDataAdapter adapter = new SqlDataAdapter(cmd);
                    DataSet dataset = new DataSet();
                    adapter.Fill(dataset);
                    return dataset;
                 }
            }
        }
        public static DataTable ExecuteDataTable(string sql, params SqlParameter[] parameters)
        {
            using (SqlConnection conn = new SqlConnection(connStr))
            {
                conn.Open();
                using (SqlCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = sql;
                    cmd.Parameters.AddRange(parameters);
                    SqlDataAdapter adapter = new SqlDataAdapter(cmd);
                    DataSet ds = new DataSet();
                    adapter.Fill(ds);
                    return ds.Tables[];
                }
            }
         }

         public static object FromDbValue(object value)
        {
            if (value == DBNull.Value)
            {
                return  null;
            }
            else
            {
                return value;
            }
        }
         public static object ToDbValue(object value)//private是类内部的方法，现在需要变成公用的，所以修改private为public
         {
             if (value == null)
             {
                 return DBNull.Value;
             }
             else
             {
                 return value;
             }

         }
      }
}

新建一个Student的类，代码如下：

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

namespace SAMSys
{
    public class Student
    {
      public  int Id { get; set; }
      public   string StudentId { get; set; }
      public  string StudentName { get; set; }
      public  string Category { get; set; }
      public  string StudentScore { get; set; }
    }
}

新建一个StudentADL的类，代码如下：

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

namespace SAMSys
{
    public class StudentDAL
    {
        public Student ToStudent(DataRow row)
        {
            Student student = new Student();
            student.Id = Convert.ToInt32(row["Id"]);
            student.StudentId = (string)row["StudentId"];
            student.StudentName = (string)row["StudentName"];
            student.StudentScore = (string)row["StudentScore"];
            student.Category=(string)row["Category"];
            return student;
        }
        //显示所有
        public Student[] ListAll()
        {
            DataTable dt = SqlHelper.ExecuteDataTable("Select * from T_StudentScores");
            Student[] students = new Student[dt.Rows.Count];
            for (int i = ; i < dt.Rows.Count; i++)
            {
                students[i] = ToStudent(dt.Rows[i]);
            }
            return students;
        }
        /// <summary>
        /// 筛选学生分数
        /// </summary>
        /// <returns></returns>

        public Student[] ListStudentMaxScore()
        {
           // DataTable view = SqlHelper.ExecuteDataTable("CREATE VIEW temp AS select  StudentId, MAX(StudentScore) as M_Score from T_StudentScores group by StudentId");
            DataTable dt = SqlHelper.ExecuteDataTable(@"select * from T_StudentScores inner join  temp
on temp.StudentId=T_StudentScores.StudentId and T_StudentScores.StudentScore=temp.M_Score");
            Student[] students = new Student[dt.Rows.Count];
            for (int i = ; i < dt.Rows.Count; i++)
            {
                students[i] = ToStudent(dt.Rows[i]);
            }
            return students;

        }
       //筛选分数的人

        public int Count0()
        {
            int Number0 =(int) SqlHelper.ExecuteScalar("select count(*) from  temp where M_Score<=69");
            return Number0;
        }
        public int Count7()
        {
            int Number7 = (int)SqlHelper.ExecuteScalar("select count(*) from temp where M_Score>=70 and M_Score<=79");
            return Number7;
        }
        public int Count8()
        {
            int Number8 = (int)SqlHelper.ExecuteScalar("select count(*) from temp where M_Score>=80 and M_Score<=89");
            return Number8;
        }
        public int Count9()
        {
            int Number9 = (int)SqlHelper.ExecuteScalar("select count(*) from temp where M_Score>=90 and M_Score<=99");
            return Number9;
        }
        public int AveScort()
        {
            int avgScore = (int)SqlHelper.ExecuteScalar("select avg(Convert(int,M_Score)) from temp");
            return avgScore;
        }
        public int AveScore1()
        {
            int avgScore1 = (int) SqlHelper.ExecuteScalar("select avg(Convert(int,M_Score)) from temp where Convert(int,M_Score)>=85");
            return avgScore1;
        }

        }
    }

新建一个程序的配置文件，App.config，连接数据库的字符串添加进去，代码如下：

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <connectionStrings>
    <add name="dbStudentScoreStr" connectionString="Data Source=.; Initial Catalog=SAMSYSDB;Trusted_Connection=yes"/>

  </connectionStrings>
</configuration>

MainWindow.x

<Window x:Class="SAMSys.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="" Width="" WindowStartupLocation="CenterScreen" >
    <Grid>
        <Button Content="导入文本格式的学生成绩表" Height="" HorizontalAlignment="Left" Margin="12,12,0,0" Name="btnImport" VerticalAlignment="Top" Width="" Click="btnImport_Click" />
        <Button Content="显示全部数据查看是否导入成功" Height="" HorizontalAlignment="Right" Margin="0,12,64,0" Name="btnShowAll" VerticalAlignment="Top" Width="" Click="btnShowAll_Click" />
        <Button Content="统计显示学生的成绩(显示最高成绩)" Height="" HorizontalAlignment="Left" Margin="12,61,0,0" Name="btnScore" VerticalAlignment="Top" Width="" Click="btnScore_Click" />
        <Button Content="区间统计人数" Height="" HorizontalAlignment="Left" Margin="185,61,0,0" Name="button1" VerticalAlignment="Top" Width="" Click="button1_Click" />
    </Grid>
</Window>

aaarticlea/png;base64,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" alt="" />

为按钮“导入文本格式的学生成绩表”，即btnImport添加Click事件。代码如下：

/// <summary>
        /// 导入数据
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
         private void btnImport_Click(object sender, RoutedEventArgs e)
        {
            string connStr = ConfigurationManager.ConnectionStrings["dbStudentScoreStr"].ConnectionString;
            OpenFileDialog ofd = new OpenFileDialog();
            ofd.Filter = "文本文件|*.txt";
            if (ofd.ShowDialog() == false)
            {
                return;
            }
            string[] lines = File.ReadLines(ofd.FileName, Encoding.Default).ToArray();

            DataTable table = new DataTable();
            table.Columns.Add("Id");
            table.Columns.Add("StudentId");
            table.Columns.Add("StudentName");
            table.Columns.Add("Category");
            table.Columns.Add("StudentScore");
            //查看文件的编码格式，可以在文件->另存为->编码中查看，若是ANSI使用参数DEFAULT编码即可，
            //若是UTF-8不使用参数，或是指定UTF-8即可
            //使用如下的方式将其变成string数组

            for (int i = ; i < lines.Count(); i++)
            {
                string line = lines[i];
                //注意文件里是按制表符来分割的，不是字符串
                string[] strs = line.Split('\t');//‘\t’为制表符
                int id = Convert.ToInt32(strs[]);
                string studentId = strs[];
                string studentName = strs[];
                string category = strs[];
                string studentScore = strs[];

                DataRow row = table.NewRow();//创建一个DataRow对象
                row["Id"] = id;//一定要在一开始创建table.Columns添加列
                row["StudentId"] = studentId;
                row["StudentName"] = studentName;
                row["Category"] = category;
                row["StudentScore"] = studentScore;
                table.Rows.Add(row);//NewRow只是创建，没有插入
            }
                using (SqlBulkCopy bulkCope = new SqlBulkCopy(connStr))
                {
                    bulkCope.DestinationTableName = "T_StudentScores";
                    //添加dataTable中列名与数据库表中列名的映射
                    bulkCope.ColumnMappings.Add("Id", "Id");
                    bulkCope.ColumnMappings.Add("StudentId", "StudentId");
                    bulkCope.ColumnMappings.Add("StudentName", "StudentName");//dataTable中与数据库表的对应关系（datatable中的名字，数据库中的名字）
                    bulkCope.ColumnMappings.Add("Category", "Category");
                    bulkCope.ColumnMappings.Add("StudentScore", "StudentScore");
                    bulkCope.WriteToServer(table);
                }

            MessageBox.Show("导入成功");
        }

再次新建一个StudentScoreShow.xaml，设计的代码如下：

<Window x:Class="SAMSys.StudentScoreShow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="StudentScoreShow" Height="" Width="" WindowStartupLocation="CenterScreen" ResizeMode="NoResize" Loaded="Window_Loaded">
    <Grid Name="gridStudentScore" >
        <DockPanel Height="" HorizontalAlignment="Left" Margin="0,9,0,0" Name="dockPanel1" VerticalAlignment="Top" >
            <DataGrid DockPanel.Dock="Top" IsReadOnly="True" Name="dgStudent" AutoGenerateColumns="False" Width="">
                <DataGrid.Columns>
                    <DataGridTextColumn Header="序号" Binding="{Binding Id}" Width=""></DataGridTextColumn>
                    <DataGridTextColumn Header="学号" Binding="{Binding StudentId}" Width=""></DataGridTextColumn>
                    <DataGridTextColumn Header="姓名" Binding="{Binding StudentName}" Width=""></DataGridTextColumn>
                    <DataGridTextColumn Header="类别" Binding="{Binding Category}" Width=""></DataGridTextColumn>
                    <DataGridTextColumn Header="成绩" Binding="{Binding StudentScore}" Width=""></DataGridTextColumn>
                </DataGrid.Columns>
            </DataGrid>
        </DockPanel>
        <Button Content="导出学生成绩（显示最高成绩）" Height="" Name="btnOutput" Width="" Click="btnOutput_Click" Margin="12,423,691,115" />
    </Grid>
</Window>

为显示全部数据查看是否导入成功的按钮添加Click事件即按钮btnShowAll

private void btnShowAll_Click(object sender, RoutedEventArgs e)
        {
            StudentScoreShow scoreShow = new StudentScoreShow();
            scoreShow.IsAll = true;
            scoreShow.ShowDialog();

        }

为统计的学生成绩，即如有两个成绩，则显示高成绩统计，就是按钮btnScore添加事件，代码如下：

        private void btnScore_Click(object sender, RoutedEventArgs e)
        {
            StudentScoreShow scoreShow = new StudentScoreShow();
            scoreShow.IsSelect = true;
            scoreShow.ShowDialog();

        }

为区间统计成绩的按钮添加Click事件，代码如下：

  private void button1_Click(object sender, RoutedEventArgs e)
        {
            StatisticsNumber sn = new StatisticsNumber();
            sn.ShowDialog();
        }

同时新建一个窗体StatisticsNumber.xaml,设计和代码如下：

aaarticlea/png;base64,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" alt="" />

<Window x:Class="SAMSys.StatisticsNumber"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="学生统计" Height="" Width="" Loaded="Window_Loaded">
    <Grid>
        <TextBlock Height="" HorizontalAlignment="Left" Margin="101,143,0,0" Name="textBlock1" Text="0-69" VerticalAlignment="Top" />
        <TextBox Height="" HorizontalAlignment="Left" Margin="186,143,0,0" Name="txt0" VerticalAlignment="Top" Width="" />
        <TextBlock Height="" HorizontalAlignment="Left" Margin="95,185,0,0" Name="textBlock2" Text="70-79" VerticalAlignment="Top" />
        <TextBlock Height="" HorizontalAlignment="Left" Margin="95,227,0,0" Name="textBlock3" Text="80-89" VerticalAlignment="Top" />
        <TextBlock Height="" HorizontalAlignment="Left" Margin="95,269,0,0" Name="textBlock4" Text="90-100" VerticalAlignment="Top" Width="" />
        <TextBox HorizontalAlignment="Left" Margin="185,182,0,0" Name="txt7" Width="" Height="" VerticalAlignment="Top" />
        <TextBox Height="" HorizontalAlignment="Left" Margin="185,222,0,0" Name="txt8" VerticalAlignment="Top" Width="" />
        <TextBox Height="" HorizontalAlignment="Left" Margin="186,266,0,0" Name="txt9" VerticalAlignment="Top" Width="" />
        <TextBlock Height="" HorizontalAlignment="Left" Margin="113,34,0,0" Name="textBlock5" Text="平均分" VerticalAlignment="Top" />
        <TextBlock Height="" HorizontalAlignment="Left" Margin="80,85,0,0" Name="textBlock6" Text="除去85以下的平均分" VerticalAlignment="Top" Width="" />
        <TextBox Height="" HorizontalAlignment="Left" Margin="196,30,0,0" Name="txtAve" VerticalAlignment="Top" Width="" />
        <TextBox Height="" HorizontalAlignment="Left" Margin="197,87,0,0" Name="txtAve85" VerticalAlignment="Top" Width="" />
    </Grid>
</Window>

为StudentScoreShow.xaml.cs添加代码如下：来区分是显示全部还是显示部分，因为他们在加载数据时候有区别

//判断是选择全部数据还是相同的人选择最高成绩.
        public bool IsAll { get; set; }
        public bool IsSelect { get; set; }

StudentScoreShow.xaml在加载时候的事件代码如下：

private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            if (IsAll)
            {
                StudentDAL dal = new StudentDAL();
                //dgStudent.ItemsSource = dal.ListStudentMaxScore();
                dgStudent.ItemsSource = dal.ListAll();
            }
            else if (IsSelect)
            {
                StudentDAL dal = new StudentDAL();
                dgStudent.ItemsSource = dal.ListStudentMaxScore();
            }
            else
            {
                return;
            }
        }

为导出数据成为TXT文本格式的按钮添加Click事件，代码如下：因为涉及字符串的拼接，所以先写一个方法如下：

 public  string strcat(string s1, string s2)
        {
            string s;
           return  s = s1 + s2;

         }

        private void btnOutput_Click(object sender, RoutedEventArgs e)
        {
            string str;
            StudentDAL dal = new StudentDAL();
            Student[] students = dal.ListStudentMaxScore();
            StreamWriter sw = new StreamWriter(@"C:/Documents and Settings/Administrator/桌面/3.txt", false, Encoding.Default);

            for(int i=;i<students.Length;i++)
            {
                Student student = new Student();
                student =students[i];
                string stName=student.StudentName;
                string tab="\t";
                string stScort=student.StudentScore;
                str = strcat(strcat(stName, tab), stScort);

                sw.WriteLine(str);

            }
            sw.Close();
            MessageBox.Show("成功导出！");

        }

统计时候StatisticsNumber.xaml加载页面的代码如下：

private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            string n0=new StudentDAL().Count0().ToString();
            string n7=new StudentDAL().Count7().ToString();
            string n8 = new StudentDAL().Count8().ToString();
            string n9 = new StudentDAL().Count9().ToString();
            string n1 = new StudentDAL().AveScort().ToString();
            string n2 = new StudentDAL().AveScore1().ToString();

            txt0.Text = n0;
            txt7.Text = n7;
            txt8.Text = n8;
            txt9.Text = n9;
            txtAve.Text = n1;
            txtAve85.Text = n2;

        }

以上完成

--------------------------------------------------------------------------------------------------------------------------------------------------

第二部分：

2. 对话框的编制

编一个对话框，如下图所示。要求从文件中读取8个数据和网格化算法设置（文件格式自已定义），并显示在对话框中，在对话框中编辑，8个参数不是完全独立的，它们的关系是：X方向间隔=（最大X-最小X）/（列数M-1），Y方向间隔=（最大Y-最小Y）/（行数N-1），也就是说，当修改了列数M，则X方向的间隔会自动根据上面公式改变；当修改了X方向的间隔，则列数M也会自动改变，触发事件是按下TAB键。网格化算法与前面是独立的，它包含有克里金法、最小曲面法、滑动平均法和其它方法。若按回车键，则表示按了确定键；若按了ESC键，则表示按了取消并退出键，不保存数据，若点右上角的叉叉，则表示取消，并不保存数据。若点击“使用数据范围”，则将弹出一个对话框，如图2所示，请入四个数字后，将数字返回给此对话框的前四个数值：最小X、最大X、最小Y、最大Y，同时，最下面2个数：X方向间隔和Y方向间隔，也会根据上面6个值做重新计算后，填入最底部2个框内。按确定，则保存对话框中的数据至文件中，并退出；若按取消，则不保存并退出。

aaarticlea/png;base64,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" alt="" />aaarticlea/png;base64,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" alt="" />

第一步。新建网格化参数的窗体和输入四个数的窗体，分别为：网格化窗体.xaml和importWindow.xaml。

然后将App.xaml中的StartupUri=属性修改为："网格化窗体"。设计代码如下：

<Window   x:Class="SAMSys.网格化窗体"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="网格化窗体" Height="" Width="" Loaded="Window_Loaded" KeyDown="Window_KeyDown">
    <Grid Name="gridXY" >
        <TextBox   Height="" HorizontalAlignment="Left" Margin="86,90,0,0" Name="txtMinX" VerticalAlignment="Top" Width="" />
        <TextBlock HorizontalAlignment="Left" Margin="36,96,0,448" Name="tb" Text="最小X" Width="" />
        <TextBlock HorizontalAlignment="Left" Margin="38,130,0,414" Name="textBlock2" Text="最大X" />
        <TextBlock HorizontalAlignment="Left" Margin="39,229,0,0" Name="textBlock3" Text="列数M" Height="" VerticalAlignment="Top" />
        <TextBlock Height="" HorizontalAlignment="Left" Margin="39,268,0,0" Name="textBlock4" Text="行数N" VerticalAlignment="Top" />
        <TextBlock Height="" HorizontalAlignment="Left" Margin="39,331,0,0" Name="textBlock5" Text="Y方向间隔" VerticalAlignment="Top" />
        <TextBlock Height="" HorizontalAlignment="Left" Margin="38,297,0,0" Name="textBlock6" Text="X方向间隔" VerticalAlignment="Top" />
        <TextBlock Height="" HorizontalAlignment="Left" Margin="39,196,0,0" Name="textBlock7" Text="最大Y" VerticalAlignment="Top" />
        <TextBlock HorizontalAlignment="Left" Margin="36,157,0,381" Name="textBlock8" Text="最小Y" />
        <TextBlock Height="" HorizontalAlignment="Left" Margin="38,359,0,0" Name="textBlock1" Text="网格化算法" VerticalAlignment="Top" />
        <TextBox Height="" HorizontalAlignment="Left" Margin="88,124,0,0" Name="txtMaxX" VerticalAlignment="Top" Width="" />
        <TextBox Height="" HorizontalAlignment="Left" Margin="91,157,0,0" Name="txtMinY" VerticalAlignment="Top" Width="" />
        <TextBox Height="" HorizontalAlignment="Left" Margin="90,189,0,0" Name="txtMaxY" VerticalAlignment="Top" Width=""  />
        <TextBox Height="" HorizontalAlignment="Left" Margin="92,223,0,0" Name="txtCoulNum" VerticalAlignment="Top" Width="" TextChanged="txtCoulNum_TextChanged" />
        <TextBox Height="" HorizontalAlignment="Left" Margin="98,260,0,0" Name="txtRowNum" VerticalAlignment="Top" Width="" TextChanged="txtRowNum_TextChanged" />
        <TextBox Height="" HorizontalAlignment="Left" Margin="101,292,0,0" Name="txtXdirectionSpacing" VerticalAlignment="Top" Width="" TextChanged="txtXdirectionSpacing_TextChanged" />
        <TextBox Height="" HorizontalAlignment="Left" Margin="103,328,0,0" Name="txtYdirectionSpacing" VerticalAlignment="Top" Width="" SelectionChanged="txtYdirectionSpacing_SelectionChanged" />
        <ListBox Height="" HorizontalAlignment="Left" Margin="103,359,0,0" Name="lbGriddingAlgorithm" VerticalAlignment="Top" Width="" >
            <ListBoxItem Content="克里金法" IsSelected="True"></ListBoxItem>
            <ListBoxItem Content="最小曲面法"></ListBoxItem>
            <ListBoxItem Content="滑动平均法"></ListBoxItem>
            <ListBoxItem Content="其它方法"></ListBoxItem>
        </ListBox>
        <Button Content="使用数据范围" Height="" HorizontalAlignment="Left" Margin="19,440,0,0" Name="btnRange" VerticalAlignment="Top" Width="" Click="btnRange_Click" />
        <Button Content="确认" Height="" HorizontalAlignment="Left" Margin="133,440,0,0" Name="btnOk" VerticalAlignment="Top" Width="" Click="btnOk_Click" />
        <Button Content="取消" Height="" HorizontalAlignment="Left" Margin="235,440,0,0" Name="btnCancel" VerticalAlignment="Top" Width="" Click="btnCancel_Click" />
    </Grid>
</Window>

因为涉及到按下键盘中的ESC和ENter和Tab键的相关操作，所以为Window添加KeyDown事件，和相应文本框数值改变时候的Change事件。代码如下：

        bool IsColTab=false;
        bool IsXSpaceTab = false;
        bool IsRowTab = false;
        bool IsYSpaceTab = false;

private void txtCoulNum_TextChanged(object sender, TextChangedEventArgs e)
        {
            IsColTab = true;
        }

        private void txtXdirectionSpacing_TextChanged(object sender, TextChangedEventArgs e)
        {
            IsXSpaceTab = true;
        }

        private void txtRowNum_TextChanged(object sender, TextChangedEventArgs e)
        {
            IsRowTab = true;

        }

        private void txtYdirectionSpacing_SelectionChanged(object sender, RoutedEventArgs e)
        {
            IsYSpaceTab = true;
        }

 private void Window_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Tab&&IsRowTab ==true)
            {
                   double a = Convert.ToInt32(txtMaxY.Text) - Convert.ToInt32(txtMinY.Text);
                    double b = Convert.ToInt32(txtRowNum.Text) - ;
                    txtYdirectionSpacing.Text = (a / b).ToString();
             }
             else if (e.Key == Key.Tab&&IsYSpaceTab ==true)
             {
                    double a = Convert.ToInt32(txtMaxY.Text) - Convert.ToInt32(txtMinY.Text);
                    double x = Convert.ToInt32(txtYdirectionSpacing.Text);
                    double n = (a / x) + ;
                    txtRowNum.Text = n.ToString();
              }
            else  if (IsColTab == true)
             {
                    double a = Convert.ToInt32(txtMaxX.Text) - Convert.ToInt32(txtMinX.Text);
                    double b = Convert.ToInt32(txtCoulNum.Text) - ;
                    txtXdirectionSpacing.Text = (a /b).ToString();
             }
              else if (IsXSpaceTab== true)
              {
                    double a = Convert.ToInt32(txtMaxX.Text) - Convert.ToInt32(txtMinX.Text);
                    double x = Convert.ToInt32(txtXdirectionSpacing.Text);
                    double n = (a / x) + ;
                    txtCoulNum.Text = n.ToString();
                }
            else if (e.Key == Key.Enter)
            {
                Save_Quit();
            }
            else if (e.Key == Key.Escape)
            {
                this.Close();
            }
            else
            {
                return;
            }
        }

取消按钮的Click事件如下：

 private void btnCancel_Click(object sender, RoutedEventArgs e)
        {
            this.Close();
        }

确定键的Click事件，代码如下：

/// <summary>
        /// 确定键控制
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>

        private void btnOk_Click(object sender, RoutedEventArgs e)
        {
            //string[] str = { txtMinX.Text, txtMaxX.Text, txtMaxY.Text, txtMinY.Text };
            //StreamWriter sw = new StreamWriter(@"C:/Documents and Settings/Administrator/桌面/2.txt",false,Encoding.Default);
            //string str1;
            //for(int i=0;i<str.Length;i++)
            //{
            //    str1 = str[i];
            //   sw.WriteLine(str1);

            //}
            //sw.Close();
            //this.Close();
            Save_Quit();

        }

将保存并退出写成一个方法Save_Quit()代码如下：

 /// <summary>
        /// 保存并退出
        /// </summary>
        public void Save_Quit()
        {
            string[] str = { txtMinX.Text, txtMaxX.Text, txtMaxY.Text, txtMinY.Text };
            StreamWriter sw = new StreamWriter(@"C:/Documents and Settings/Administrator/桌面/2.txt", false, Encoding.Default);
            string str1;
            for (int i = ; i < str.Length; i++)
            {
                str1 = str[i];
                sw.WriteLine(str1);

            }
            sw.Close();
            this.Close();

        }
        

网格化窗体加载时候的代码如下：

 private void Window_Loaded(object sender, RoutedEventArgs e)
        {            

            string[] lines = File.ReadAllLines("C:/Documents and Settings/Administrator/桌面/12.txt");  //读取所有这样的代码
            foreach (var line in lines)
            {
                string[] str = line.Split('\t');
                txtMinX.Text = str[];
                txtMaxX.Text = str[];
                txtMinY.Text = str[];
                txtMaxY.Text = str[];
                txtCoulNum.Text = str[];
                txtRowNum.Text = str[];
                double a = Convert.ToInt32(txtMaxX.Text) - Convert.ToInt32(txtMinX.Text);
                double b = Convert.ToInt32(txtCoulNum.Text) - ;
                txtXdirectionSpacing.Text = (a / b).ToString();
                double c = Convert.ToInt32(txtMaxY.Text) - Convert.ToInt32(txtMinY.Text);
                double d = Convert.ToInt32(txtRowNum.Text) - ;
                txtYdirectionSpacing.Text = (c / d).ToString();

            }

          }
        

使用范围数据的设置按钮的Click事件，代码如下：

/// <summary>
        /// 使用数据范围按钮
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>

        private void btnRange_Click(object sender, RoutedEventArgs e)
        {
            ImportWindow impWin = new ImportWindow(this);
            impWin.ShowDialog();
        }

在ImportWindow.xaml.cs中，因为需要网格化窗体和ImportWindow中相应控件产生关联，所以需要在ImportWindow.xaml.cs中添加一部分这样的代码。同时在声明时候传递参数再打开。代码如下：

 /// <summary>
        /// 窗体间相互关联
        /// </summary>
        网格化窗体 showWin = new 网格化窗体();
        public ImportWindow(网格化窗体 showWin)
        {
            InitializeComponent();
            this.showWin = showWin;

        }

aaarticlea/png;base64,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" alt="" />aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAksAAADcCAIAAADvI3KHAAAV2ElEQVR4nO3dy5GrOheGYYIjH1JwFArCETByBP/EIwLoGDhVu7uq+x9w0ZK0BNhcJb9Puc7xtrkIkPUhTFtFCwBAjoqzCwAAwC5IOABAnkg4AECeSDgAQJ5IOABAnkg4AECeSDgAQJ5IOABAnuIJ97zf7s/3XwQA4FTRhHsY8/h6/0Xd18PcFk98tOf9umUDALwsknA7dOCe99tNRsjXw9w6d2Puz36C+3OY9GYe/TzG3G63+6Ob/v5UX7SruPXzytXezONppxxe+pLv2yLRHwWALOgJ97wrvZnlL/q05LAzPu/jew8zTvS8m0c79PrGzl83l/pi27bP53NcoSyWDdd+UieWvU3wkxgAkCYt4b5E0LzxoisaGLbDZdNGTbi+W2cebWsTLnzRXeTNTTi/ALbgse2iMwcAiVMSbuMOXNsFRjwuvh5muKi4KuFkx8wtmVZOPx2dt+jDAUD6goQTefPOizF+V07EkZNw/SQP0383tjzh5JVJ74YWNYm/Hub+8DeBzhsAZMNPuF3/RuBhxpiTFxSd78SGa4wP94pjfxuKmM170Ty+2vHelf4+lKe8n8W/dOl8AdgOUy7PbADAtbkJt1MH7qL6LiAAIEsf+ZsmomPHF24AkKuPTDgAwAcg4QAAeSLhAAB5IuEAAHki4QAAeSLhAAB5IuF8xa1Qn4+vxB7eLN0T+V91RbHlrC/PxIyza5koDwCkgvbLEUudMMBmn8fmCicLX4yVYXl5JooUW458ZbrkAJCE9NuvTX9n7NW+TvhcjZCJf+7Uh2sjqRZb+ETQqjsKAK4v+fZrw7HIpxNITjObTGo3S02RiSxZki4v9eGWr4iEA5CBxNuv7TpwXr9Hvqg+mX0+e8Vv4npjuNhYmk501LzJpqM0Ni8JByBdabdfmw9ltz7hvCdqcLYL+ovqchaWISzJkr6pV7bYhU0ASEXK7demY5F3NrxKqS42/OfsVcrZhJvOyIm1THQQ6cMByEDC7df2Y5FP9py8CWLPl3SSvFUsSUpv4tkyTL8Vlmd6vQCQomTbr32Gspu46Dc9wXScqEuToaXOu/AKZGyBs90+tTATyweAtKTafu00Fvl0H27in+FbYQdOnWZiOe8l3PLZw9ibXj4ApCXN9mu3scjVy4BqFLUiJ7wwm00OdZbZK5Cxi58Tj7D8s0kWWw4AJIfGCwCQJxIOAJAnEg4AkCcSDgCQJxIOAJAnEg4AkCcSDgCQJxIOAJAnEg4AkKf0E26n3+9auCIAwFUln3AbjvFtfT3MzZ/4hdlP8LwHBQaAD5d4wu3QgXveb7cwLbzZvx7m1rkbc3/2c92fw/w38+gXZMztdrs/uunvT/VFu95bP68sy808nnbK4aUv+b4tEr1MABiknXAbDxEXDwlvdvvP532cQYyy+rybRzt0BcceYTeX+mLbts/ncyyFXJlN3H5SJ2yDgmnxDAAfKeWE23SM76lsCGe3HS6bNmrC9d0682hbm3Dhi+4ib27C+aWyxYltLJ05AEg64bYf4/vrYbRkmJpdjM6zKuFkx8xdn7Z2Px2dt+jDAUDbtgkn3E5DxIVdOWV2EUdOwvXzPUz/3djyhJNXJr27XNR8/XqY+8MvGJ03AJBSTbhd/0bgYZybOYLZ5QVF5zux4Rrjw73i2N+GImbzXjSPr3a8d6W/D+Up72fxL106XwC2w5SvjPUKANlLM+F2G+N749l31HcBAQAxaSbcJxMdO75wA4AJJBwAIE8kHAAgTyQcACBPJBwAIE8kHAAgTyQcACBPJBwAIE8kHAAgT+kn3GFjfGdt+E1LO87dht5b6GZF4rgDnyr5hDtsjO/M9b9z+bzv81Mp88MXLSrS3MgJVxmcnREegEtIPOF2HuO7GyVg/MVkMb7NovG4lSnjY3yHvh5mmNb5ia7ly3zhF76GX+B0BhAKhjJXlxkrZyt23CM+e2zXTRVJH6VW20xx3A89mgz0AFxA2gm3/xjf8hKZPTFfPB63MmVsjO/IBg5rFy310mXKn40enrvDFbgtvbL2YChzbZl6OcVge3YnRmZXd90EP8yWDs5+9NFkyHXgXCkn3BFjfLtdv7GlWzwedzhlbIzvSKlER0fGyYJlBmH2elMbDGUeW2ZYTneX97txokhLR6kdOV/TLRyc/YyjSWcOOE/CCXfIGN/uIDXdgpaPx61NuTbhli9TW/RLfThntmHtanEXJtzE1r6YcO4XXUsHZz/+aPKFHHCmZBPuoDG+nTsvXh2PW51yZcK9ssyVNxGqQ5nry1SSWEacerE1uoQZeqdo6eDsxx1NOm/A6VJNuKPG+H7ezcN2e+Q9C92lqrnxuP0p7/fhfX+M79CwyP5+wrEALywzMhr5MjNDmY8vx8opr3Ea49yd4Sx1aihzbY/Ez1fmB2c/5mg+GXIduIQ0E+6wMb6961pIhX7cOZrAZ0kz4Y5ib5bnWlP6OJrApyHhAAB5IuEAAHki4QAAeSLhAAB5IuEAAHki4QAAeSLhAAB5IuEAAHlKP+EY43sLywfUZuhtAKlIPuEY43sby8f4ZuhtAIlIPOEY43tymSvH+NZnZ+htAIlIO+EY43vHMb7j43FPlZahtwFcRsoJxxjfe47x/ebsDL0N4DISTjjG+J5Z5soxvl8cdXvYYIbeBnAVySYcY3wfOcb3Agy9DeBqUk04xvhetMxVY3wvnp2htwFcUpoJxxjfiWLobQAHSjPhjsKo0AdgJwPYCQkHAMgTCQcAyBMJBwDIEwkHAMgTCQcAyBMJBwDIEwkHAMgTCQcAyBMJBwDIEwkHAMgTCQcAyBMJBwDIEwkHAMgTCQcAyBMJBwDIEwkHAMgTCQcAyBMJBwDIEwkHAMgTCQcAyBMJBwDIEwkHAMgTCQcAyBMJBwDIEwkHAMgTCQcAyNNnJFzzXRY/9dmlmBcvZ139FfFNMGVRlObt1dZVIVRn7KixCKUxVWka8VJQnsaU84Wsq8lNaUzZrUVlyr+i/I4v+u+UffSGmb2wwcKPrjbjFrlr37MAjSnHyhmtMnuqq5NWnIPPSLg1mu+y+nd2Idq2bU05EdJ1pSZcY8plH/xxukXxsbG6Gtunpgtr+3leugGhqW2vq5mN/FfFE+59Z9Sl93fgKwt/s9osrp/qSuXMm21mpEiNKavqrKSZra6ISjLhulPsuvorir+iGE+o/1XFX1H8mvq7LGyPZ5hsjIdusv4kXb47LtCev9c//SvdY2ieGvM7vPgbr/PRFbVNV0Jn9qCcbgGqf7MJN55rVsOWh+e4XYKUpX9OKj7WNiztAoZXYrPbSat67FDac9/pk9/JU1SvvYl07GwXsKqqfmFDU9W/J88AvBZDORz/qvJ7PMpDKz5O5hymSGUYjn7xW1U/ponWJZ3dd1UpU8Tdn8sOR3T2YbrS1N17LzejarUJOz22Kzms0Cmke0j1aqNtUfdEVJ9hotK0blVZuusiRRrWJc8jI7tO+yCoR1MV+8jU1Vn9x+QlmXB989G3Ef8qPyd+uwalNP+NM3jxIP85Pq9rG2B23vC8u/kuxwiUzzXaikSBg8uSTjnFu9NXKfsPVv/xEx8H7YTU9phEQy/bQdtg1LbRcVoRb3ZxAm/bssaUssmLX0SdPo9X3/RetKtvTBlse2Mqr3Fw2wv1cPyr7ImOU8GGV4ZjEakMppS5KJa/rA9nW+1xd0f25/rD0Ved5p2rYVq1catf4aTRuHG2JN7hVcupblF3cT4IA6Vjt3zXqUUSL3p7yN91kXIqR1M18ZGhF/eudBNONPcizOpK71T5HaBxFmdee4o9kXDinH22G6etyI3exvzKqivL6b7lbnKwGucTMH6k9IQTaTV8iuS5o1xoEZxSKrPXlbNu/6xZaYaktQkXm78xpTyPdmYXO0s/HNEK1rbOu3pliCXZ8quUYtfb2NL2Z3g43P0xfzjWfMujVBt3cWNhFiacWk51i1qlD+cWYHiyfNepRXJec1cWrlotZ3g0VVMfmbpa80X7J0s24WTP6Y2EGxop+3r9Yy8cyRYtbJX89m6uqMGKLplwY6shzjedRum1hHuh4XzlKqXy4kTCRZqUDRNOrwzrE05uxbCT1b20MOEmdvK6hFOqzZqEU0sznXCBfgL77uJdpxdJBrl/Crgs4eSWTATVxJEg4d6VbMKJbpZMtcUJ1zbmt6ps8ySvTJrS7cPZq1V/SvM3x1uRF88Tl0+dBrH+mb1KOX48bHNjP1HyksxUwo1XWuSVSXHtT5tdfG4bU2qXfmbIGxu92ZZdpXRmd9Jdaxr8q5TK4XAqmCnjVykjlUHOUlfDopS6pBL7wDmCyhz64RBpMns41HZ14U2YYbVx0kKLQKdXrdTPSDAoW+RUA7kVwV0hi3edWiQ/YOPd39kPwnTCTXxkuEr5rmQTrvw2pfulvXMjwNg8jV/4q/cCeOkyzFv+ihtY7NVLm1LOXQOzaeevSF7ami6nuHD6U8ZvYe9aDfWmZnEbvrxi07X9/VPx7Xjbig+nXWBZdu+qs4vFdsVQLs7MNJfyAo38IsO/YqO+GJ/dL6bYKU4n0D8c3a1Mtj74vTS/h6dUBlkbRb9NqUuKyI4LXo4dDnlVrBwTJVxq43VO3Ps65prUWLWRS3VOPYYKIhfu1c/Y1odbFPy1gFfr3dIv3nV+kdzbt+xG1Pqu0z4Iyz8GU0eegHtPwgl3dhmgivzdwrWsbDFyr37yhh28acMPAgH3viQTbjy55rBfhThvT+KgTP/Fd2Qe2y1LYhvfR4v6tj0+CPzF9wpJJhySFNwrllAiAkgRCQcAyBMJBwDIEwkHAMgTCQcAyBMJBwDIEwkHAMgTCQcAyFPaCSd+/A0AAEfaCbfr+MUAgKSRcACAPJFwAIA8kXAAgDwlnHDuOJZAVuRogTs9zt5EYHdp13L6cEjX6fFzegGAvaVdj0k4XF+iEZJosQEp7fpKwuFqso+E7DcQOUm7dvIX3zgdzT17AJdFdQReRoM+gZ2D66AKAovQcL+BnYZzUe2AKBroDbEzcTyqGqCgId4VuxfHoJIBFp2MI7G3sTfqFkBTezL2P3ZClcJHo2G9FA4HtkVlwoeiMb0sDg22QjWyTFlYpTlwzXUlVmr/0f2sdGPKV/6qva6KLf8K/sW1O6XYaIs293YDSg3p1jbxi+d19VcUP/rCm+8y9pa7iG755BzWowL5jvglsCZYyfCpHieoVgybcIkfM9t0iza0vtH87BpSVzIdm++y+hcsfEGMLV4FIYc1qD0+++Gvq6IoyrIsiqIy3el7VXcn8qUZzqPFZ7EZT/HHtqibqjS1nX08A3fm79uvYUSgoTkbpvVW0hVKrkgstqrtJvhFGsrTyHejjZ2/9pd2yPotWqExv0XxW5ZdN+C3W2b3j+Gehu7Ff5WYoG2+yyLeBRl8dA2R6VP/OD/XNUSdKX+qytnzbd+3C/Ztv8P/iuKnFLnoDYzVTdGVhQGz8BISzidPbxtTFqXp/9e4rcrYkNumQb9q1DWDslVSztC7V+qqLMvSNN773tR1ZVu9/olYoyicViSvK+D9c8MdsnKLNI1zldBr2H11NbS59U9R/fsrirb5LsvvYVnD8/qnNP+J2dx/brhDsqgh/qCMeh/O2fPuWz9uOYcIrH+c8NOqwd+GZ0D4GCScz2u/xg9965w3O2e1sm1zZ2xbNUTC9qubypSVMWX3ZKr9Ej2A0gTLG4qnFmloKLtGbkHAvbtD1m3Rerb1bP91V7oa8+v+RPCvaYY2uv4pir+qlnNFfXIN8b/xm7lK+a8aTyn8t7qC2F6gH9FaNeCKJV5FjfEtar/kx2+79qt71ZRV5Tcr27VfsqGUV6s23yHrtkj1Yh/OXpys1O5a719VfjfmtzLfZfVvyXdIn1xDNk44uRw5ZSThWkIOL6K6+JadoRdOExI0anIhevvVT2yvJ3Vf3rTakEDzeeC2l/Krm3AhdVWVZWma1lTlkhsO3t0h67ZotS7h/opCtLP/Ku07trr6Kctf07Sm+g3b69An1xDlKqXdt39DORcmnDgcYcIFNXO8lkvIYTnqiuXfC95/M1+apr9kM3zGurNpvxshexj22xRnkc73Gd6L/Tc5rfctSuEtYFjkcCGpCO9OqEqnKfRX1H91NHfbt7J289oOWblFa3QXJP+Kou7vJRHfDNmrlH3z2pjfovzunkx/CUcNCbNnuIXkr9t1/T/L79bZ88Nz5TYf5SplLODGwhByWIiK8obN+hm5uOIOObURvOIO2cjkvUD7rSK4bknIYQlqycvGs969P+ipuOYOObEFvOYO2cpc13+1Jbc/kXBYhlqCPNEC5o3jiyWoJcgQzd8n4ChjFlUEGaLt+wQcZcyiiiBDp7R9f+7fk/M463H8ocdlURuQoeObudObdR7ycfDRx2VRFZCnI5u50xt0HuHjsKOPK6MeIE9HtnGnt+Y8wsdhRx9XRj1Ano5s405vzXmEj8OOPq6MeuC62pDWYviu7qcC1w7h7f7Mk/sruovKudUvazl/OLzsj3xfdWQzd3qDzkM+DjvuuDiqwkb2GdLapkBjf5Vw5RjT4jd4/d/RfaVgKxPO+2WmvX4L6sjG7vRmnUf3OOyI4/qoDdYFh7RWfyDJlFVVBbMvHqy50X7WXu2Z2f5e8CuLfsIpo1eL+at6/F18+9b0j9aLpa7s3tHk5YSjiZdQXXzXGdJ6KIGfHHbsFDv7C4M1N9roL3o5a/uj+F7MuFNqa9cHlQ5nEC8Fu2KThGtpFnPBccSrqDG+iw5pLQLDGzvTW6ItdmSw5hcSTnxnN5Vw6trrShly084exFl80MtN0DimjiOIN1BpfNcZ0tojRhZdlnCRwZrVq5RKOWUqBXeCJJdw7fA92a6rwB44cHgb9cZ34pDW3UU5Z/XaEMxKwr0yWHPjzR9JYnll0t7lom+RtnZR+HCHLLxKOQ7rvCHayrRwvLAGtWd0/pDWSsJ5M49LLI13d8jSwZq9EslvyoJLkvIvFYpwpGgxZXTt47707kzR7jSZHtZ5Q/QJksBhwnpUoDdkPILzTsI9tuCvBfb/Zo4G9Jo4NNgK1ehleY/gvKUm7Og6b+79F99L0JheCocD26IyAS1/LHwu9j92QpUCLJraI7G3sTfqFqCg5d0VuxfHoJIBUfza4YbYmTgeVQ1YhAb6Dew0nItqB7yMhnsCOwfXQRUEVmHoFvYALovqCGwp++HKst9A5CTd2rnXTzoB20p0oM5Eiw1ISddXfj0LCTt9oOrTCwDsLel6TMIhW9Pxs8nj7E0Edpd0LSfhAABRiSccv34MAIhIOuGOGBgaAJCopBOOPhwAICrxhKMDBwCIIOEAAHlKN+HqimG2AQBx6SYcAABTSDgAQJ5IOABAnkg4AECeSDgAQJ5IOABAnkg4AECeSDgAQJ5IOABAnkg4AECeSDgAQJ5IOABAnkg4AECeSDgAQJ5IOABAnkg4AECeSDgAQJ5IOABAnor/AQCQo+IPAIAckXAAgDz9H5wDTApEFcC9AAAAAElFTkSuQmCC" alt="" />

确定和取消按钮的事件，代码如下：

 private void btnOk_Click(object sender, RoutedEventArgs e)
        {

           showWin.txtMaxX.Text= txtMaxX.Text;
           showWin.txtMinX.Text = txtMinX.Text;
           showWin.txtMaxY.Text = txtMaxY.Text;
           showWin.txtMinY.Text = txtMinY.Text;
           this.Close();
        }

        private void btnCancel_Click(object sender, RoutedEventArgs e)
        {
            this.Close();
        }

----------------------------------------------------------------------------------------------------------------------------------

以上完成。