自学笔记C#

问题及解决方法

1、解决语音播报时间过长导致 WinForm UI 假死的问题

await Task.Run(() => {
                for (var i = 0; i < 3; i++)
                {
                    Console.WriteLine("voice");
                    reader.Speak(i.ToString() + "号测试生产任务");

​                }
​            });

如果你不想使用线程来解决语音播报时间过长导致 WinForm UI 假死的问题，你可以考虑使用异步操作来执行语音播报。

使用异步操作可以避免在 UI 线程上执行长时间的操作，从而保持 UI 界面的响应。你可以使用 C# 的异步关键字 async 和 await 来简化异步编程。

以下是一个示例代码，展示如何使用异步方法来执行语音播报：

using System;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WinFormApp
{
    public partial class MainForm : Form
    {
        public MainForm()
        {
            InitializeComponent();
        }

        private async void btnStart_Click(object sender, EventArgs e)
        {
            lblStatus.Text = "Speech in progress...";
            btnStart.Enabled = false;

            // 执行语音播报的异步方法
            await SpeechTask();

            lblStatus.Text = "Speech completed";
            btnStart.Enabled = true;
        }

        private async Task SpeechTask()
        {
            // 模拟长时间的语音播报
            for (int i = 0; i < 10; i++)
            {
                await Task.Delay(1000); // 模拟语音播报耗时

                // 更新 UI
                lblStatus.Text = $"Speech in progress: {i}/10";
            }
        }
    }
}

在上面的示例代码中，btnStart_Click事件处理程序使用 async 关键字修饰，表示这是一个异步方法。在方法内部，我们使用 await 操作符来等待 SpeechTask 方法的完成。

在 SpeechTask 方法中，我们使用 Task.Delay 方法来模拟语音播报的耗时。Task.Delay 方法会创建一个延迟指定时间后完成的Task对象，这样我们可以使用 await 等待这个延迟操作。

通过使用异步操作，语音播报将在后台执行，不会阻塞 UI 线程，使你的 WinForm 应用程序保持响应。当语音播报完成时，将更新 UI 界面来通知用户。

2、设置程序开机自启动

方法一

win+R 输入shell:startup

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q3tzqpfn-1689217005189)(C:\Users\HNZL\AppData\Roaming\Typora\typora-user-images\image-20230705084621737.png)]

需要设置开机自启动的项目快捷方式放在该目录下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LTil7sGN-1689217005191)(C:\Users\HNZL\AppData\Roaming\Typora\typora-user-images\image-20230705084650977.png)]

方法二

注册表结合bat脚本方式

先写一个bat脚本，执行你的exe文件：（新建记事本，复制以下代码，保存，修改后缀为bat）

​ @echo off

​ start exe路径

开始→运行→“regdeit”,打开路径HKEY_LOCAL_MACHINE – SOFTWARE – Microsoft – Windows – CurrentVersion – Run

新建字符串值，数值名称自己定义，数值数据填bat路径，重启即可

方法四：使用系统任务计划程序

开始→搜索（任务计划程序），新建计划任务即可

(14条消息) Windows设置exe或者bat文件开机启动的几种方法汇总_bat文件开机自启动_xiangshangdemayi的博客-CSDN博客

兴业三号线逻辑

首先，编写一个C#类库，用于处理数据同步的逻辑。这个类库应该包含以下几个功能：

1. 将本地Access数据库中的数据读取到内存中，保存为一个DataTable或List等数据结构。
2. 将内存中的数据通过Http请求发送到远程服务器，可以使用HttpClient类库实现。
3. 在远程服务器上，将接收到的数据存储到mysql数据库中。

接下来，编写一个接口，用于提供数据同步的API服务。这个接口应该包含以下几个方法：

1. GetDataTable()：用于获取本地Access数据库中的数据，并将其转换为DataTable对象。
2. SendDataToRemoteServer()：用于将本地Access数据库中的数据发送到远程服务器，并返回一个bool值，表示数据是否成功发送。
3. SyncDataFromRemoteServer()：用于从远程服务器上获取数据，并将其存储到mysql数据库中。

最后，编写一个控制台应用程序，用于调用接口中的方法，实现数据同步的功能。这个应用程序应该包含以下几个步骤：

1. 读取本地Access数据库中的数据，并将其转换为DataTable对象。

2. 调用接口中的SendDataToRemoteServer()方法，将数据发送到远程服务器。

3. 调用接口中的SyncDataFromRemoteServer()方法，从远程服务器上获取数据，并将其存储到mysql数据库中。

   接口

1、仓位材料silo
http://home.hnzl.top:9916/api/zhuji/getMaterial
2、获取配比信息Api
http://home.hnzl.top:9916/api/zhuji/getFormula
3、获取调度信息信息Api
http://home.hnzl.top:9916/api/zhuji/getDispatchList
4、判断调度信息是否已作废Api 获取调度信息
http://home.hnzl.top:9916/api/zhuji/getIsDel
5、修改任务单下发状态Api
http://home.hnzl.top:9916/api/zhuji/upTaskStatus
6、消耗wastage
http://home.hnzl.top:9916/api/zhuji/getWastageTime
http://home.hnzl.top:9916/api/zhuji/getWastageData
7、上传日志Api
http://home.hnzl.top:9916/api/zhuji/getLog

using System.Data;
using System.Data.OleDb;

// 连接字符串，指定本地Access数据库的路径和其他相关信息
string connectionString = @"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\Path\To\Your\Database.accdb;";

// SQL查询语句，用于从表中检索数据
string query = "SELECT * FROM YourTableName";

// 创建连接对象
using (OleDbConnection connection = new OleDbConnection(connectionString))
{
    // 创建DataAdapter和DataTable
    using (OleDbDataAdapter adapter = new OleDbDataAdapter(query, connection))
    {
        DataTable dataTable = new DataTable();
        

```c#
    // 打开数据库连接
    connection.Open();
    
    // 使用DataAdapter填充DataTable
    adapter.Fill(dataTable);
    
    // 关闭数据库连接
    connection.Close();
    
    // 现在你可以在内存中使用dataTable了
    // ...

    // 打印DataTable
    foreach (DataRow row in dataTable.Rows)
    {
        foreach (DataColumn col in dataTable.Columns)
        {
            Console.Write("{0} = {1}; ", col.ColumnName, row[col]);
        }
        Console.WriteLine();
    }
}
}
```

using System.Data;
using System.Data.OleDb;

string connectionString = @"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\path\to\your\database.accdb;";
string query = "SELECT * FROM YourTableName";

using (OleDbConnection connection = new OleDbConnection(connectionString))
{
    using (OleDbDataAdapter adapter = new OleDbDataAdapter(query, connection))
    {
        DataTable dataTable = new DataTable();

        connection.Open();
        
        adapter.Fill(dataTable);
        
        connection.Close();
        
        // 现在你可以在内存中使用dataTable了
       // ...
    }
}

数据同步问题

本地Access数据库和云端Mysql数据库中的信息进行同步

本地数据库与云端数据库通过 API 接口同步的方法逻辑通常包括以下几个步骤：

1. 创建 API 接口：首先需要创建 API 接口，以便本地和云端数据库可以通过该接口进行数据同步。接口应该包括用于读取本地数据库和写入云端数据库的必要方法。
2. 同步数据：接下来，需要编写代码来同步本地和云端数据库的数据。这通常包括读取本地数据库中的数据，将其写入云端数据库，以及从云端数据库读取数据并将其写入本地数据库。
3. 错误处理：在同步数据的过程中，可能会出现各种错误，例如网络连接问题、数据库错误等。因此，需要编写错误处理代码，以便在出现错误时能够及时处理并恢复同步。
4. 测试和优化：在完成同步代码后，需要进行测试和优化，以确保同步过程能够高效地运行，并且不会出现错误。测试可以包括手动测试和自动化测试，优化可以包括调整代码和配置参数等。
5. 部署和监控：最后，需要将同步代码部署到本地和云端数据库，并监控同步过程。这可以通过编写监控代码来实现，以便及时发现和解决问题。

需要注意的是，本地数据库和云端数据库之间的同步方法可能因数据库类型和平台而异。因此，具体的实现方式可能会有所不同。

Api接口

API接口是指应用程序编程接口（API）中具体的端点或功能点，用于实现不同软件系统之间的通信和数据交互。 API接口定义了可用于与系统进行交互的请求和响应的数据格式、参数、约定和规则。

API接口通常是基于网络协议（例如HTTP）实现的，以便通过网络进行通信。开发人员可以根据系统的需求，利用API接口发送请求以获取数据、执行特定的操作或访问系统的功能。通过API接口，开发人员可以使用事先定义好的方法、函数或调用特定的URL来访问和操作不同系统的功能。

API接口的设计通常包括以下几个方面：

• 请求方法：常见的有GET、POST、PUT、DELETE等，用于指定请求的目的和操作类型。
• URL路径：指定API接口的访问路径，表示需要访问的具体资源或功能。
• 参数：用于传递与请求相关的数据或信息，以便API接口进行处理。
• 请求头：包含与请求相关的元数据或标识，如身份验证信息、数据格式等。
• 响应：API接口根据请求的操作和参数返回相应的结果或数据。

API接口的设计对于系统的稳定性、安全性和易用性至关重要。它应该具有明确定义的输入和输出，能够提供清晰的错误处理和状态码，以及合适的安全措施，以防止未经授权的访问和滥用。

总之，API接口是API中的具体功能点或服务端点，定义了请求和响应的格式、参数、规则和约定，用于实现不同软件系统之间的通信和数据交互。

创建Api接口

创建 API 接口通常需要以下步骤：

1. 确定 API 接口的需求和功能：在创建 API 接口之前，您需要确定您的应用程序需要哪些功能，以及这些功能如何与 API 接口交互。
2. 选择合适的编程语言和框架：选择适合您的应用程序的编程语言和框架，以便能够快速开发 API 接口。
3. 设计 API 接口的架构：设计 API 接口的架构，包括确定 API 接口的版本、API 接口的路由和请求/响应格式等。
4. 编写 API 接口代码：使用所选的编程语言和框架编写 API 接口代码，实现所需的功能。
5. 测试 API 接口：测试 API 接口是否能够正常运行，包括测试 API 接口的请求/响应格式、API 接口的错误处理等。
6. 部署 API 接口：将 API 接口部署到服务器上，以便其他应用程序可以使用它。
7. 维护 API 接口：定期维护 API 接口，以确保其正常运行，并修复任何错误或漏洞。

需要注意的是，创建 API 接口需要一定的编程知识和技能。如果您不熟悉编程或没有足够的时间和资源来开发 API 接口，可以考虑使用现有的 API 接口服务，如 AWS API Gateway、Azure API Management 或 Google Cloud Endpoints 等。

使用C#创建API接口

需要使用.NET Framework或.NET Core框架提供的API开发工具包（APIPad或APISig）。以下是一些基本步骤：

1. 安装APIPad或APISig：在Microsoft的NuGet包管理器中搜索APIPad或APISig，并安装它们。
2. 创建API接口：使用APIPad或APISig创建一个新的API接口。这通常包括定义输入和输出参数，以及指定使用哪种HTTP方法（GET、POST、PUT、DELETE等）来调用API。
3. 编写API实现：根据API接口定义，编写代码来提供所需的功能。这可能包括从数据库中读取或写入数据、执行计算、与外部服务交互等。
4. 配置API路由：在APIPad或APISig中配置API路由，以便在请求时将请求路由到相应的API实现。
5. 测试API：使用测试框架（如NUnit或xUnit）编写测试代码，以确保API实现能够正确地工作。
6. 部署API：将API实现部署到生产环境，以便其他应用程序可以使用它。

需要注意的是，API开发工具包只是API开发的一部分，还需要了解如何编写API实现、如何处理API请求和响应、如何使用HTTP客户端等。因此，建议学习C#和API开发的基础知识，以便更好地理解和使用API开发工具包。

如何根据Api接口返回的json数据来写ApiRequset和ApiReponse

在C#中，你可以使用类来定义API请求（ApiRequest）和API响应（ApiResponse），以便根据接口返回的JSON数据字段来进行数据交互。

首先，你需要根据API返回的JSON数据字段，创建对应的类来表示请求和响应的数据结构。这些类应该具有与JSON数据字段相匹配的属性。

下面是一个示例，假设你的API返回的JSON数据字段为：

{
  "id": 1,
  "name": "John Doe",
  "email": "johndoe@example.com"
}

针对该JSON数据，你可以定义以下类：

public class ApiRequest
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

public class ApiResponse
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

在这个例子中，ApiRequest类和ApiResponse类都有与JSON数据字段相匹配的属性。你可以根据你的实际需求，调整类的名称和属性。

接下来，你可以使用各种HTTP客户端库，例如HttpClient，以及Newtonsoft.Json库（用于处理JSON数据）来发送API请求并解析API响应。

using System;
using System.Net.Http;
using Newtonsoft.Json;

class Program
{
    static async void SendRequest()
    {
        string apiUrl = "http://example.com/api"; // 你的API接口URL

        using (HttpClient client = new HttpClient())
        {
            HttpResponseMessage response = await client.GetAsync(apiUrl);
            if (response.IsSuccessStatusCode)
            {
                string json = await response.Content.ReadAsStringAsync();
                ApiResponse apiResponse = JsonConvert.DeserializeObject<ApiResponse>(json);
                
                // 处理API响应数据
                Console.WriteLine("ID: " + apiResponse.Id);
                Console.WriteLine("Name: " + apiResponse.Name);
                Console.WriteLine("Email: " + apiResponse.Email);
            }
            else
            {
                Console.WriteLine("API request failed with status code: " + response.StatusCode);
            }
        }
    }

    static void Main(string[] args)
    {
        SendRequest();
    }
}

在此示例中，我们使用HttpClient的GetAsync方法发送HTTP GET请求，然后使用JsonConvert.DeserializeObject方法将返回的JSON数据反序列化为ApiResponse对象。最后，我们可以访问ApiResponse对象的属性来处理API响应数据。

请根据你的实际情况进行细化和调整，并根据你使用的HTTP客户端库和JSON处理库使用适当的代码。

可以按照以下步骤用C#实现本地Access数据库向远程MySQL数据库的同步：

1. 首先，确保你的项目中引入了需要的包，包括MySql.Data和System.Data.OleDb。

2. 创建本地Access数据库和远程MySQL数据库的连接对象。例如，使用OleDbConnection连接本地Access数据库，使用MySqlConnection连接远程MySQL数据库。你需要提供相应的连接字符串。

// 本地Access数据库连接
string accessConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=your_access_database_path.accdb";
OleDbConnection accessConnection = new OleDbConnection(accessConnectionString);

// 远程MySQL数据库连接
string mysqlConnectionString = "Server=mysql_server_address;Database=your_database;Uid=your_username;Pwd=your_password";
MySqlConnection mysqlConnection = new MySqlConnection(mysqlConnectionString);

3. 在需要进行数据同步的时候，从本地Access数据库中读取数据，然后将数据插入到远程MySQL数据库。

// 打开本地Access数据库连接
accessConnection.Open();

// 从本地Access数据库中查询数据
string selectQuery = "SELECT * FROM your_table";
OleDbCommand accessCommand = new OleDbCommand(selectQuery, accessConnection);
OleDbDataReader reader = accessCommand.ExecuteReader();

// 打开远程MySQL数据库连接
mysqlConnection.Open();

// 将数据插入到远程MySQL数据库
while (reader.Read())
{
    // 根据实际表结构，构建插入语句
    string insertQuery = "INSERT INTO your_table (column1, column2, ...) VALUES (@value1, @value2, ...)";
    MySqlCommand mysqlCommand = new MySqlCommand(insertQuery, mysqlConnection);

    // 设置参数值
    mysqlCommand.Parameters.AddWithValue("@value1", reader["column1"]);
    mysqlCommand.Parameters.AddWithValue("@value2", reader["column2"]);
    // ...

    // 执行插入语句
    mysqlCommand.ExecuteNonQuery();
}

// 关闭连接和释放资源
reader.Close();
accessConnection.Close();
mysqlConnection.Close();

4. 你可以使用定时器控件（如System.Windows.Forms.Timer或System.Timers.Timer）来定期执行这段同步代码。

// 创建一个计时器对象
System.Windows.Forms.Timer timer = new System.Windows.Forms.Timer();

// 设置定时器的间隔时间（单位毫秒）
timer.Interval = 60000; // 例如每隔60秒同步一次

// 当定时器触发时执行同步代码
timer.Tick += (sender, e) =>
{
    // 执行数据同步代码
    // ...
};

// 启动定时器
timer.Start();

这样，当定时器触发时，就会执行数据同步代码，将本地Access数据库中的数据同步到远程的MySQL数据库中。需要注意的是，你需要根据实际情况进行参数和表结构的调整。同时，本例使用的是Windows窗体应用程序的定时器，如果你是使用控制台应用程序或者其他类型的应用程序，需要选择相应的定时器类型和处理方法。

要使用C#以接口形式实现本地Access数据库向远程MySQL数据库进行同步，你可以按照以下步骤进行操作：

1. 创建一个名为IDataSync的接口，用于定义同步方法，如下所示：

public interface IDataSync
{
    void SyncData();
}

2. 创建一个名为AccessDataSync类，实现IDataSync接口，并在该类中编写同步方法，如下所示：

public class AccessDataSync : IDataSync
{
    public void SyncData()
    {
        // 连接本地Access数据库
        // 获取本地数据
        // 连接远程MySQL数据库
        // 将本地数据同步到远程MySQL数据库
    }
}

3. 创建一个名为MysqlDataSync类，也实现IDataSync接口，并在该类中编写同步方法，如下所示：

public class MysqlDataSync : IDataSync
{
    public void SyncData()
    {
        // 连接远程MySQL数据库
        // 获取远程数据
        // 连接本地Access数据库
        // 将远程数据同步到本地Access数据库
    }
}

4. 在你的主程序中，根据需要创建AccessDataSync和MysqlDataSync实例，并调用SyncData方法，如下所示：

static void Main(string[] args)
{
    IDataSync accessSync = new AccessDataSync();
    accessSync.SyncData();

    IDataSync mysqlSync = new MysqlDataSync();
    mysqlSync.SyncData();
}

通过上述方式，你可以根据需要选择将本地Access数据库数据同步到远程MySQL数据库，或者将远程MySQL数据库数据同步到本地Access数据库。

数据同步的工作原理

同步数据有多种方式，包括手动数据库更新、由源数据库更改触发的 python 脚本以及使用 ETL 的全自动数据管道进行同步。在所有情况下，该流程遵循如下步骤：

1. 触发更新事件

数据同步流程可通过多个方式检测对目标数据库中数据所做的更改，例如在表格中设置标记，或创建脚本定期检查最后修改文件的日期。

2. 识别和提取更改

同步并不意味着完全复制，该流程只要比较版本、检查更改日志或查看对新值的标记，以识别做过更改的实例。

3. 对其他源的更改

同步流程识别和提取更改后，通过如下方式安排数据移动：

• 异步：按规定的时间表传输更改，例如每小时一次或每天一次。这个方法可实现资源的高效利用，但意味着每次更新之间可能会出现数据差异。
• 同步：同步流程在每次更改后运行。这种方法对资源的消耗高，但可以实时更新数据。

数据可能通过网络或以文件方式传输。使用 ETL 平台进行同步时，它可以在后台自动处理更新，无需人工干预。

4. 解析传入的更改

两个数据实例不同时，传入的数据会通过转换层传递、净化和整合。

5. 更改应用到现有数据

同步流程通过如下方式将传入的更改写入目标数据，包括：

• 事务：按更改发生的顺序逐个应用更改，确保数据实例拥有类似的本地更改历史记录。
• 快照：整体应用更改，确保所有数据相同，只有原始版本保留完整的更改历史记录。
• 合并：如果源和目标端数据都出现更改，则合并全部更改，不标记任何版本为最终版。相反，它会更新两个数据实例以反映所有更改。

目的是更新全部数据实例，不丢失任何更改。

6. 确认更新成功

更新后的系统通过如下方式确认更新是否成功。如果应用程序编程接口 (API) 处理更新，则会返回一条确认更新成功的消息。如果不能发送此确认消息，则进程会试图重启更新或返回错误消息。

数据同步方法

数据同步方法有多种，具体请参见下文：

• 文件同步：用于 Home 备份、通过闪存更新可移动的数据或更新外部硬盘中的数据。它比人工复制技术更快，也不容易出错，并确保不同地点可共享相同的数据。此外，它还能防止相同的文件被自动复制。
• 版本控制：采用同步解决方案，有利于多个用户同时更改文件。
• 分布式文件系统 (DFS)：它仅适用于包含多个文件版本的互联设备。部分系统还允许设备短时间断开连接，只要能满足在同步前实施数据核对即可。
• 镜像计算：为不同来源提供精确的数据集副本。镜像计算适用于备份，因为它只在一个位置提供一份相同的副本。

文件同步和版本控制工具一次可以更改多个文件副本，而 DFS 和镜像工具则有特定的使用场合。

区分数据同步、集成、推送和复制

下文阐述了数据同步、集成、复制和推送的定义以及差别。

• 数据同步：一种维持数据库之间数据一致性的集成方式。它是一个连续的过程，保持数据库之间不断的沟通，在源和目标之间应用更改，确保它们始终一致。
• 数据集成：将来自不同源的软件或数据片段组合成一个统一视图或单一数据集。数据同步是一种集成类型，但并非所有的集成流程都会实现正确的数据同步。
• 数据推送：这是另一种类型的整合，最终的结果也不同。这个流程在数据创建后，立即将数据从指定“A”点带到“B”点。它可防止在 A 点创建数据后又在 B 点手动创建相同的数据。相反，B 点应自动接收来自 A 点的数据。数据同步可双向运行，但数据推送只能单向运行。
• 数据复制：这是将类似数据存储在多个地点的流程，可提高数据可用性和可访问性，防止数据丢失。这个流程是单向的，可完全镜像、备份或复制源数据到另一个实例，例如存储设备或服务器。

要实现上述功能，你可以按照以下步骤进行操作：

1. 获取生产任务信息及调度信息，并写入相应表格（生产任务单信息、小任务单表、生产配比表）：

   • 通过连接到本地的Access数据库，使用SQL查询语句从表格（diaodu、duilie、peibi）中获取相应的生产任务信息和调度信息。
   • 将获取到的数据写入到MySQL数据库中对应的表格中，可以使用SQL INSERT语句进行插入操作。

2. 回传消耗数据，将生产信息表数据同步回来：

   • 通过连接到MySQL数据库，使用SQL查询语句从表格（product）中获取消耗数据。
   • 将获取到的数据回传到本地的Access数据库中进行同步。可以使用SQL INSERT语句将数据插入到对应的表格中。

3. 修改生产线的仓位材料信息：

   • 通过连接到本地的Access数据库，使用SQL更新语句修改仓位材料信息表（可以根据需要使用SQL WHERE子句来指定要修改的记录）。
   • 更新的操作可以在用户界面上提供相应的界面和功能，让用户可以输入修改的信息进行保存。

以上步骤中，你需要使用C#与数据库进行交互。可以使用ADO.NET库来连接并操作Access和MySQL数据库。通过编写相应的SQL查询和更新语句，可以实现数据的读取、写入和修改。

1

以下是一个示例的C#代码片段，它演示了如何使用ADO.NET库连接到本地的Access数据库并执行SQL查询语句来获取生产任务信息和调度信息：

string connectionString = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\\path\\to\\your\\database.accdb";
using (OleDbConnection connection = new OleDbConnection(connectionString))
{
    connection.Open();
    
    // 获取生产任务信息
    string taskQuery = "SELECT * FROM diaodu";
    using (OleDbCommand command = new OleDbCommand(taskQuery, connection))
    using (OleDbDataReader reader = command.ExecuteReader())
    {
        while (reader.Read())
        {
            // 获取相应的字段值
            int taskId = reader.GetInt32(0);
            string taskName = reader.GetString(1);
            
            // 处理获取到的任务信息
            // 可以将数据写入到MySQL数据库或进行其他操作
        }
    }
    
    // 获取调度信息
    string scheduleQuery = "SELECT * FROM duilie INNER JOIN peibi ON duilie.ID=peibi.ID";
    using (OleDbCommand command = new OleDbCommand(scheduleQuery, connection))
    using (OleDbDataReader reader = command.ExecuteReader())
    {
        while (reader.Read())
        {
            // 获取相应的字段值
            int scheduleId = reader.GetInt32(0);
            int taskId = reader.GetInt32(1);
            DateTime startTime = reader.GetDateTime(2);
            DateTime endTime = reader.GetDateTime(3);
            // 其他字段...
            
            // 处理获取到的调度信息
            // 可以将数据写入到MySQL数据库或进行其他操作
        }
    }
}

请注意，在使用该代码之前，需要将相应的连接字符串（connectionString）中的参数更改为你的Access数据库文件的路径。 SQL查询语句（taskQuery和scheduleQuery）也需要根据你的数据库表格中的结构进行调整和修改。

C#中的CRUD（增删改查）操作可以通过使用ADO.NET、Entity Framework或其他ORM（对象关系映射）工具来实现。

以下是使用ADO.NET的示例：

1. 连接到数据库：

string connectionString = "YourConnectionString";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();
    // 连接成功后进行增删改查操作
}

2. 插入数据：

string sql = "INSERT INTO TableName (Column1, Column2) VALUES (@Value1, @Value2)";
using (SqlCommand command = new SqlCommand(sql, connection))
{
    command.Parameters.AddWithValue("@Value1", value1);
    command.Parameters.AddWithValue("@Value2", value2);
    command.ExecuteNonQuery();
}

3. 更新数据：

string sql = "UPDATE TableName SET Column1 = @NewValue1 WHERE Column2 = @Value2";
using (SqlCommand command = new SqlCommand(sql, connection))
{
    command.Parameters.AddWithValue("@NewValue1", newValue1);
    command.Parameters.AddWithValue("@Value2", value2);
    command.ExecuteNonQuery();
}

4. 删除数据：

string sql = "DELETE FROM TableName WHERE Column1 = @Value1";
using (SqlCommand command = new SqlCommand(sql, connection))
{
    command.Parameters.AddWithValue("@Value1", value1);
    command.ExecuteNonQuery();
}

5. 查询数据：

string sql = "SELECT Column1, Column2 FROM TableName";
using (SqlCommand command = new SqlCommand(sql, connection))
{
    using (SqlDataReader reader = command.ExecuteReader())
    {
        while (reader.Read())
        {
            // 处理查询结果
            var column1Value = reader["Column1"];
            var column2Value = reader["Column2"];
        }
    }
}

上述代码中的"TableName"需要替换成具体的表名，"@Value1"等为参数名，实际项目中需要根据要操作的数据库的结构和需要实现的功能来进行修改。

注意，ADO.NET提供了与数据库的直接交互，但需要手动编写SQL语句并处理参数和结果集。而使用Entity Framework或其他ORM工具可以更高级、更简化地进行CRUD操作，可以自动生成数据库对象和查询语句，具体用法可参考相关文档和教程。

为了实现这些功能，您可以使用以下步骤：

1. 获取生产任务信息：您可以使用一个API或查询数据库来获取生产任务单信息、调度信息和小任务单表信息。这些信息可以存储在一个数据结构中，例如一个字典或一个数据表中。
2. 写入生产任务单信息、调度信息和小任务单表信息：您可以使用另一个API或插入数据到数据库中，将生产任务单信息、调度信息和小任务单表信息写入生产任务单信息、调度信息和小任务单表信息。
3. 同步消耗数据：您可以使用一个API或查询数据库来获取生产信息表信息，并将其同步回来。这些信息可以存储在一个数据结构中，例如一个字典或一个数据表中。
4. 修改仓位材料信息：您可以使用一个API或更新数据库来修改仓位材料信息。这些信息可以存储在一个数据结构中，例如一个字典或一个数据表中。

需要注意的是，上述步骤中的API和数据库都是示例，您需要根据您的具体需求和数据结构进行相应的更改。同时，您需要确保在所有步骤中都使用了适当的数据结构和数据库操作，以避免数据丢失或损坏。

任务

一共三个主要功能，

1、获取生产任务信息即调度信息，并写入（生产任务单信息，调度信息，生产配比）。

2、回传消耗数据，将生产信息表信息同步回来。

3、修改生产线的仓位材料信息。

1、生产任务单信息 （diaodu）
2、小任务单表，也是调度任务，生产任务表（duilie）
3、生产配比表（peibi）
4、生产信息表（product）消耗数据，需要同步回来
5、仓位材料修改

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q7Dnzc51-1689217005193)(C:\Users\HNZL\AppData\Roaming\Typora\typora-user-images\image-20230711163534705.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-84zbtBja-1689217005194)(C:\Users\HNZL\AppData\Roaming\Typora\typora-user-images\image-20230711163545140.png)]

生产线仓位信息数据库有问题

以下是一个使用C#在WinForm中实现上述功能的示例代码：

1、获取生产任务信息和调度信息，并写入相应的表格：

csharp复制代码// 假设生产任务信息和调度信息存储在数据库中，使用ADO.NET连接数据库
string connectionString = "your_connection_string";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();

    // 获取生产任务信息
    string diaoduQuery = "SELECT * FROM diaodu";
    SqlCommand diaoduCommand = new SqlCommand(diaoduQuery, connection);
    SqlDataReader diaoduReader = diaoduCommand.ExecuteReader();
    while (diaoduReader.Read())
    {
        // 将生产任务信息写入生产任务单信息表
        string taskInfo = diaoduReader["task_info"].ToString();
        // 写入相应的表格
    }
    diaoduReader.Close();

    // 获取调度信息
    string duilieQuery = "SELECT * FROM duilie";
    SqlCommand duilieCommand = new SqlCommand(duilieQuery, connection);
    SqlDataReader duilieReader = duilieCommand.ExecuteReader();
    while (duilieReader.Read())
    {
        // 将调度信息写入小任务单表
        string scheduleInfo = duilieReader["schedule_info"].ToString();
        // 写入相应的表格
    }c
    duilieReader.Close();

    // 获取生产配比信息
    string peibiQuery = "SELECT * FROM peibi";
    SqlCommand peibiCommand = new SqlCommand(peibiQuery, connection);
    SqlDataReader peibiReader = peibiCommand.ExecuteReader();
    while (peibiReader.Read())
    {
        // 将生产配比信息写入生产配比表
        string ratioInfo = peibiReader["ratio_info"].ToString();
        // 写入相应的表格
    }
    peibiReader.Close();
}

2、回传消耗数据，将生产信息表信息同步回来：

csharp复制代码// 假设消耗数据存储在一个列表中
List<string> consumptionData = new List<string>();

// 将消耗数据同步回生产信息表
string updateQuery = "UPDATE product SET consumption = @consumption WHERE id = @id";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();

    foreach (string data in consumptionData)
    {
        SqlCommand updateCommand = new SqlCommand(updateQuery, connection);
        updateCommand.Parameters.AddWithValue("@consumption", data);
        updateCommand.Parameters.AddWithValue("@id", data.Id);
        updateCommand.ExecuteNonQuery();
    }
}

3、修改生产线的仓位材料信息：

csharp复制代码// 假设要修改的仓位材料信息存储在一个对象中
WarehouseMaterial material = new WarehouseMaterial();

// 修改仓位材料信息
string updateMaterialQuery = "UPDATE warehouse SET material_info = @materialInfo WHERE id = @id";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();

    SqlCommand updateMaterialCommand = new SqlCommand(updateMaterialQuery, connection);
    updateMaterialCommand.Parameters.AddWithValue("@materialInfo", material.Info);
    updateMaterialCommand.Parameters.AddWithValue("@id", material.Id);
    updateMaterialCommand.ExecuteNonQuery();
}

请注意，以上代码只是一个示例，具体的实现可能会因为数据库结构、表格设计等因素而有所不同。您需要根据具体情况进行适当的修改和调整。

线程

1、创建线程

线程是通过扩展 Thread 类创建的。扩展的 Thread 类调用 Start() 方法来开始子线程的执行。

下面的程序演示了这个概念：

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

namespace MultithreadingApplication
{
    class ThreadCreationProgram
    {
        public static void CallToChildThread()
        {
            Console.WriteLine("Child thread starts");
        }
        static void Main(string[] args)
        {
            ThreadStart childref = new ThreadStart(CallToChildThread);
            Console.WriteLine("In Main: Creating the Child thread");
            Thread childThread = new Thread(childref);
            childThread.Start();
            Console.ReadKey();
        }
    }
}

2、管理线程

Thread 类提供了各种管理线程的方法。

下面的实例演示了 sleep() 方法的使用，用于在一个特定的时间暂停线程。

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

namespace MultithreadingApplication
{
    class ThreadCreationProgram
    {
        public static void CallToChildThread()
        {
            Console.WriteLine("Child thread starts");
            //线程暂停5000毫秒
            int sleepfor = 5000;
            Console.WriteLine("Child Thread Paused for {0} seconds",sleepfor/1000);
            Thread.Sleep(sleepfor);
            Console.WriteLine("Child thread resumes");
        }
        static void Main(string[] args)
        {
            ThreadStart childref = new ThreadStart(CallToChildThread);
            Console.WriteLine("In Main: Creating the Child thread");
            Thread childThread = new Thread(childref);
            childThread.Start();
            Console.ReadKey();
        }
    }
}

3、销毁线程

Abort() 方法用于销毁线程。

通过抛出 threadabortexception 在运行时中止线程。这个异常不能被捕获，如果有 finally 块，控制会被送至 finally 块。

下面的程序说明了这点：

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

namespace MultithreadingApplication
{
    class ThreadCreationProgram
    {
        public static void CallToChildThread()
        {
            try
            {
                Console.WriteLine("Child thread starts");
                //计数到10
                for (int countre = 0; countre <= 10; countre++)
                {
                    Thread.Sleep(500);
                    Console.WriteLine(countre);
                }
                Console.WriteLine("Child Thread Completed");
            }
            catch (ThreadAbortException e)
            {
                Console.WriteLine("Thread Abort Exception");
            }
            finally
            {
                Console.WriteLine("Couldn't catch the Thread Exception");
            }
        }
        static void Main(string[] args)
        {
            ThreadStart childref = new ThreadStart(CallToChildThread);
            Console.WriteLine("In Main: Creating the Child thread");
            Thread childThread = new Thread(childref);
            childThread.Start();
            //停止主线程一段时间
            Thread.Sleep(10000);
            //现在中止子线程
            Console.WriteLine("In Main: Aborting the Child thread");
            childThread.Abort();
            Console.ReadKey();
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bRRWhDy3-1689217005195)(C:\Users\HNZL\AppData\Roaming\Typora\typora-user-images\image-20230712163142556.png)]

Task使用的注意事项和用法

在C#中，Task 类是用于表示异步操作的核心类型之一。它允许你执行耗时的操作，而无需阻塞主线程或其他工作线程。以下是关于Task的使用方法和注意事项：

1. 创建Task：
   • 使用 Task.Run 方法创建一个带有方法体的 Task，并立即开始执行。
   • 使用 Task.Factory.StartNew 方法创建一个带有委托的 Task，并立即开始执行。
2. 异步等待任务完成：
   • 使用 await 操作符等待异步任务完成。
   • 在非异步方法中使用 Task.Wait 或 Task.Result 等待任务完成。
3. 异常处理：
   • 使用 try-catch 块来捕获任务中的异常。如果你在异步方法中使用 await，异常会被自动传播回调用链。
   • 在异步方法中使用 Task.Exception 属性来检查任务的异常信息。
4. 取消任务：
   • 使用 CancellationToken 和 CancellationTokenSource 来取消任务的执行。在执行任务时，定期检查 CancellationToken 的状态并决定是否取消任务。
5. 多个任务的协调：
   • 使用 Task.WhenAll 方法等待多个任务同时完成。
   • 使用 Task.WhenAny 方法等待任意一个任务完成。
6. 避免阻塞：
   • 避免在主线程或UI线程中使用 Task.Wait 或 Task.Result，以免造成阻塞和UI无响应。
   • 使用异步方法和 await 来确保异步任务的非阻塞执行。
7. 性能考虑：
   • 对于长时间运行的任务，考虑使用 Task.ConfigureAwait(false) 来避免不必要的线程上下文切换。
   • 对于 CPU 密集型操作，使用 Task.Run 在后台线程执行任务。
8. 使用 Task 的一些其他方法和属性：
   • Task.ContinueWith：定义任务完成后要执行的操作。
   • Task.Delay：在一段时间后创建一个已完成的 Task。
   • Task.FromResult：创建一个已完成并具有指定结果的 Task。

请注意，以上仅为Task的一些常见用法和注意事项的概述。在实际应用中，你可能会遇到更多的情况和复杂性，需要根据具体的需求和情况进行适当调整和处理。

示例

当涉及到 Task 的使用示例时，以下是一些常见的示例：

1. 创建并等待一个简单的异步任务：

async Task MyAsyncMethod()
{
    await Task.Delay(1000); // 模拟一个异步操作
    Console.WriteLine("异步任务已完成");
}

// 调用异步方法
await MyAsyncMethod();
Console.WriteLine("继续执行其他操作");

1. 同时等待多个任务完成：

async Task MultipleTasks()
{
    Task task1 = Task.Delay(1000);
    Task task2 = Task.Delay(2000);
    Task task3 = Task.Delay(3000);

    await Task.WhenAll(task1, task2, task3);
    Console.WriteLine("所有任务已完成");
}

// 调用异步方法
await MultipleTasks();
Console.WriteLine("继续执行其他操作");

1. 使用 Task.Run 在后台线程执行任务：

async Task BackgroundTask()
{
    await Task.Run(() =>
    {
        // 在后台线程执行的耗时操作
        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine($"后台操作：{i}");
            Thread.Sleep(1000);
        }
    });
    Console.WriteLine("后台任务已完成");
}

// 调用异步方法
await BackgroundTask();
Console.WriteLine("继续执行其他操作");

1. 取消任务的执行：

async Task CancelableTask(CancellationToken cancellationToken)
{
    while (!cancellationToken.IsCancellationRequested)
    {
        Console.WriteLine("任务正在执行");
        await Task.Delay(1000);
    }
    Console.WriteLine("任务已取消");
}

// 创建取消令牌
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;

// 开始执行任务并在3秒后取消任务
Task task = CancelableTask(cancellationToken);
await Task.Delay(3000);
cancellationTokenSource.Cancel();

// 等待任务完成
try
{
    await task;
    Console.WriteLine("任务已完成");
}
catch (TaskCanceledException)
{
    Console.WriteLine("任务被取消");
}

这些示例涵盖了一些常见的 Task 使用场景，你可以根据自己的需求和情况进行相应的修改和扩展。请记住，在实际应用中，可能需要更多的错误处理、任务协调和其他细节处理，这些示例只是提供了一些基本的概念和起点。