开发练习

[renyh]

本Issue是练习C#一些开发知识。

Github地址：https://github.com/DigitalPlatform/dp3

运行里面的practice项目

如何编译

1. 应使用 Visual Studio 2017 或 2019

2. 确保安装过 .NET Core SDK 2.6 以上版本
   下载地址：
   https://dotnet.microsoft.com/download/visual-studio-sdks

3. dp3 Solution 中引用了一个名为 dp-library 的submodule。需要用 Git 命令行执行（先安装一个Git桌面工具，例如GitHub Desktop，然后启动Git Shell）：

git submodule init
git submodule update

以确保获得最新的 dp-library 代码。

Git 命令执行以后，需要重新打开 dp2 Solution 变动才能生效

[renyh]

练习使用CancellationToken让线程停止

（这段代码是一开始写的，作废，最新正式代码在下方）

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

        CancellationTokenSource _cancelTokenSource = new CancellationTokenSource();

        private void button_start_Click(object sender, EventArgs e)
        {
            Task.Run(() =>
            {
                dothing(this._cancelTokenSource.Token);
            });
        }

        // 做事
        void dothing(CancellationToken token)
        {
            // 设置按置状态
            this.Invoke((Action)(() =>
                EnableControls(false)
                ));
            try
            {
                int i = 0;
                for (; ; )
                {
                    if (token.IsCancellationRequested)
                        break;

                    i++;

                    // 界面显示信息
                    this.Invoke((Action)(() =>
                            this.textBox_info.Text += this.textBox_info.Text + i.ToString() + "\r\n"
                            ));
                }
            }
            finally
            {
                // 设置按置状态
                this.Invoke((Action)(() =>
                    EnableControls(false)
                    ));
            }
        }

        // 设置控件是否可用
        void EnableControls(bool bEnable)
        {
            this.button_start.Enabled = bEnable;
            this.button_stop.Enabled = !(bEnable);
        }

        // 停止
        private void button_stop_Click(object sender, EventArgs e)
        {
            this._cancelTokenSource.Cancel();
        }
    }

这段代码是学习通过CancellationToken终止张程，但运行起来有2个问题：
1）是怎么反复出现 112，为什么不是连续的123；
2）点 停止 按钮没反应，点不动。
不知是什么原因？
后来检查代码是发现是这一句写错了this.textBox_info.Text += this.textBox_info.Text + i.ToString() + "\r\n"，不应该是+=，应是=。
A += 1 相当于 A = A + 1

---

最新代码

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace practice
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        // 名字以用途命名即可。TokenSource 这种类型名称可以不出现在名字中
        CancellationTokenSource _cancel = new CancellationTokenSource();

        private void button_start_Click(object sender, EventArgs e)
        {
            // 每次开头都重新 new 一个。这样避免受到上次遗留的 _cancel 对象的状态影响
            this._cancel = new CancellationTokenSource();
            this.textBox_info.Text = "";

            Task.Run(() =>
            {
                doSomething(this._cancel.Token);
            });
        }

        // 做事
        void doSomething(CancellationToken token)
        {
            // 设置按钮状态
            this.Invoke((Action)(() =>
                EnableControls(false)
                ));
            try
            {
                int i = 0;
                while (token.IsCancellationRequested == false)
                {
                    /*
                    // 中断也可以用
                    token.ThrowIfCancellationRequested();
                    */

                    i++;

                    // 界面显示信息
                    this.Invoke((Action)(() =>
                        this.textBox_info.Text = this.textBox_info.Text + i.ToString() + "\r\n"
                            ));
                  }
            }
            finally
            {
                // 设置按置状态
                this.Invoke((Action)(() =>
                    EnableControls(true)
                    ));
            }
        }

        // 设置控件是否可用
        void EnableControls(bool bEnable)
        {
            this.button_start.Enabled = bEnable;
            this.button_stop.Enabled = !(bEnable);
        }

        private void button_stop_Click(object sender, EventArgs e)
        {
            // 停止
            this._cancel.Cancel();
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            // 窗口关闭前让循环退出
            this._cancel.Cancel();
        }
    }
}

[renyh]

this.Invoke((Action)(() =>
                        this.textBox_info.Text = this.textBox_info.Text + i.ToString() + "\r\n"
                            ));

如果执行的语句只有一句，后面不加;号。
如果执行的是多条语句，要用{}括起来，每句后面加;号。

                    // 界面显示信息
                    this.Invoke((Action)(() =>
                            {
                                this.textBox_info.Text = this.textBox_info.Text + i.ToString() + "\r\n";
                                this.textBox_info.ScrollToCaret();
                            }
                     ));

[renyh]

每次按下开始按钮以后，cancellationTokenSource 对象要重新 new 一个。不然可能会保持上一次的 Cancel 状态

            // 每次开头都重新 new 一个。这样避免受到上次遗留的 _cancel 对象的状态影响
            this._cancel1 = new CancellationTokenSource();

// 要注意 CancellationTokenSource 对象要 Dispose。
https://stackoverflow.com/questions/6960520/when-to-dispose-cancellationtokensource

        private void button_stop_Click(object sender, EventArgs e)
        {
            // 停止
            this._cancel.Cancel();
            // 不再使用时，调用Dispose
            this._cancel.Dispose();
        }

[renyh]

Task.Run 和 Task.Factory.StartNew 区别

Task.Run 是在 dotnet framework 4.5 之后才可以使用。
可以认为 Task.Run 是简化的 Task.Factory.StartNew 的使用，除了需要指定一个线程是长时间占用的，否则就使用 Task.Run

创建新线程的2个方法

            Task.Run(() =>
            {
                var foo = 2;
            });

这时 foo 的创建就在另一个线程，需要知道 Task.Run 用的是线程池，也就是不是调用这个函数就会一定创建一个新的线程，但是会在另一个线程运行。

            Task.Factory.StartNew(() =>
            {
                var foo = 2;
            });

可以看到，两个方法实际上是没有差别，但是Task.Run比较好看，所以推荐使用Task.Run。

[renyh]

ConfigureAwait()不写默认是回到原始线程。

1. RunAsync()：直接执行该异步方法，后续代码紧接着执行。
2. await RunAsync()：执行异步方法，并在结束后再执行后续代码（在此行代码之前的代码在同一线程中执行）。
3. await RunAsync().ConfigureAwait(false)：执行异步方法，并在结束后再执行后续代码（执行的线程不指定）

ConfigureAwait不写默认是回到异常方式执行前的同一线程。

https://docs.microsoft.com/en-us/dotnet/api/system.threading.tasks.task.configureawait?view=netframework-4.8

https://stackoverflow.com/questions/26681332/why-configureawaitfalse-is-not-the-default-option

https://codeday.me/bug/20180115/119541.html

https://www.cnblogs.com/cmt/p/configure_await_false.html

[renyh]

这两种判断token cancel退出循环的方式都可以

                while (token.IsCancellationRequested == false)
                {
                    /*
                    // 中断也可以用
                    token.ThrowIfCancellationRequested();
                    */

                 ...todo...
               }

[renyh]

注意如果 Task.Run是赋值给一个变量时，里面的函数要加return

                Task <Item> t2 = Task.Run(() =>
                {
                    return this._worker.doSomething(this._cancel.Token);
                });

如果一个函数被task方法运行，有多个返回值的话，返回值不能再用out/ref这类参数来返回了，多个返回值要封装在一个对象里。

        // 做事
        public Item doSomething(CancellationToken token,string prefix)
        {
            int i = 0;
            while (token.IsCancellationRequested == false)
            {

                i++;

                // 通知接管了该事件的外面调用者
                if (ShowInfoHandler != null)
                {
                    string text= prefix+ i.ToString();
                    ShowInfoHandler(text);
                }
            }

            Item item = new Item
            {
                text = "合计" + i.ToString(),
                count = i
            };

            return item;
        }

[renyh]

Lambda表达式

lambda表达式是一个未命名的方法.

lambda表达式具有以下形式：
(parameters) => expression

在这个示例中，有一个参数， x ，表达式为 x * x :
x => x * x;
lambda表达式的每个参数都对应一个委托参数，表达式的类型对应于委托的返回类型。
在上面的代码中， x 对应于参数 i ，表达式 x * x 对应于返回类型 int ，因此它与 Converter 委托兼容。delegate int Converter (int i);

lambda表达式的代码可以是语句块而不是表达式。
x => { return x * x; };

---

Lambda表达式最常用于Func和Action委托。
Func<int,int> sqr = x => x * x;

下面是一个接受两个参数的表达式示例：

Func<string,string,int> totalLength = (s1, s2) => s1.Length + s2.Length;
int total = totalLength ("a", "the"); 

---

Lambda表达式示例

https://blog.csdn.net/wangboxian/article/details/41963205#

####（一）输入参数

在Lambda表达式中，输入参数是Lambda运算符的左边部分。它包含参数的数量可以为0、1或者多个。只有当输入参数为1时，Lambda表达式左边的一对小括弧才可以省略。输入参数的数量大于或者等于2时，Lambda表达式左边的一对小括弧中的多个参数质检使用逗号（,）分割。

示例1

下面创建一个Lambda表达式，它的输入参数的数量为0.该表达式将显示“This is a Lambda expression”字符串。

()=>Console.WriteLine("This is a Lambda expression.");

分析1
由于上述Lambda表达式的输入参数的数量为0，因此，该Lambda表达式的左边部分的一对小括弧不能被省略。

示例2
下面创建一个Lambda表达式，它的输入参数包含一个参数：m。该表达式将计算m参数与2的乘积。

m=>m*2;

分析2
上述Lambda表达式的输入参数省略了一对小括弧，它与“(m)=>m*2”Lambda表达式是等效的。

示例3
下面创建一个Lambda表达式，它的输入参数包含两个参数：m和n。该表达式将计算m和n参数的乘积。

(m,n)=>m*n;

####（二）表达式或语句块
多个Lambda表达式可以构成Lambda语句块。语句块可以放到运算符的右边，作为Lambda的主体。根据主题不同，Lambda表达式可以分为表达式Lambda和语句Lambda。语句块中可以包含多条语句，并且可以包含循环、方法调用和if语句等。

示例1
下面创建一个Lambda表达式，它的右边部分是一个表达式。该表达式计算m参数的平方值。

m=>m*n;

分析1
如果Lambda表达式的右边部分是一个语句块，那么该语句块不必被"{"和"}"包围。

示例2
下面创建一个Lambda表达式，它的输入参数包括两个参数：m和n。该表达式的右边包含2个表达式；第一个表达式计算m和n参数的乘积，结果保存为result变量；第二个表达式显示result变量的值。

(m,n)=>{int result=m*n; Console.WriteLine(result);}

分析2
上述Lambda表达式的右边部分包含2个表达式，因此，该表达式的右边部分必须被"{"和"}"包围。

[renyh]

检索一个读者记录，装入读者窗。注意这应该是一条已经登记过指纹的读者记录。然后进行指纹登记。注意，最后不要保存。然后，再次启动指纹登记功能，出现指纹中心界面，不要进行登记。然后，去点读者窗右上角的 X 按钮关闭读者窗，这时候就会抛出异常

这也是一个(典型的 await 放在 form closing 事件里面出现故障的)好例子，回头我们分析一下代码。

[renyh]

Creating a Cookie Aware WebClient

public class CookieAwareWebClient : WebClient
{
    public CookieContainer CookieContainer { get; set; }
    public Uri Uri { get; set; }
 
    public CookieAwareWebClient() : this (new CookieContainer())
    {
    }
 
    public CookieAwareWebClient(CookieContainer cookies)
    {
        this.CookieContainer = cookies;
    }
 
    public override WebRequest GetWebRequest(Uri address)
    {
        WebRequest request = base.GetWebRequest(address);
        if (request is HttpWebRequest)
	{
	     (request as HttpWebRequest).CookieContainer = this.CookieContainer;
	}
	HttpWebRequest httpRequest = (HttpWebRequest) request;
	httpRequest.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
	return httpRequest;
    }
 
    public override WebResponse GetWebResponse(WebRequest request)
    {
         WebResponse response = base.GetWebResponse(request);
 
 	//this string contains the cookies data
	String setCookieHeader = response.Headers[HttpResponseHeader.SetCookie];
 
	if (setCookieHeader != null)
	{
	    ////do something if needed to parse out the cookie.
		// NOTE: the cookies from the request is handled by the response itself, don't need add again.
		// if you want to create your cookie, do the following.
	    //if (setCookieHeader != null)
	    //{
	        Cookie cookie = new Cookie(); //create cookie
		this.CookieContainer.Add(cookie);
	    //}
	}
	return response;
    }
}

You will see two overridden methods for GetWebRequest and GetWebResponse. These methods can be overridden to handle the cookie container. You will also notice the AutomaticDecompression that can be placed on the HttpWebRequest to validate the response is being unzipped (GZIP) automatically since the WebClient doesn't do this out of the box.

Now, when calling web services or executing POSTs or GETs, it will handle holding your cookies for you automatically. They are included in subsequent requests

How to use:

1. use cookie. 
 
CookieContainer cookies = new CookieContainer ();
WebClient wc = new CookieAwareWebClient(cookies);
wc.Encoding = Encoding.UTF8;
 
// send request, the class will get the cookies from the response and store the cookies in its CookieContainer (property);
string data = wc.UploadString(uri, postStr);  // or = wc.DownloadString(uri);
// get the cookies from class
cookies = ((CookieAwareWebClient)wc).CookieContainer; 

// now you can create new query with the cookies.
WebClient wc = new CookieAwareWebClient(cookies); (same as above);
 

[renyh]

关于通道

1. 前端可以开多条通道与服务器通讯
2. 用通道池实现多个通道的分配和回收。
3. 对于restful协议，一根通道就是一个CookieContainer。
4. 多个通道时用按需登录的方式，避免每次登录。
5. 对于restful协议，需要调logout接口，让服务器端释放一根通道

[renyh]

C# winform或控制台Properties.Settings.Default的使用及存储位置

Properties.Settings.Default

Settings里的属性根据范围分为两种 “用户”和“应用程序”
范围为“应用程序”的属性，读取都是从APP.CONFIG里获取，设置也可以通过手工修改App.config改变，但是在程序中无法对其进行赋值，只能读取。
而范围为“用户”的属性 Settings 在第一次运行时会读取App.config里的初始值
但是一旦调用Save方法后，Settings里“用户”范围的属性就会保存在系统里面，类似WebForm里的Cookies一样
从此以后，读取都会从系统里保存的值里读取，手工修改App.config里的“用户”范围的属性不会影响到这些属性，但是在调用Reset方法时会从新从App.config里获取“用户”范围的属性写入到系统中。

也就是说，settings里“用户”范围的属性总共有3个地方存储。
1、app.config配置文件-----程序第一次运行，之前程序未调用save()，在系统中找不到就会从这里获取
2、操作系统--------当settings调用save()保存后。
3、内存----程序启动后，实例化settings对象，该实例在创建的时候从系统（如果系统中没有就如前面提到的从配置文件中获取）读取在内存中。

另外app.config,系统，内存这3个位置之间值的关系可以使用以下方法互相影响。

new() 构造函数，从系统或配置文件中读取属性值 ，“用户”属性先检查系统，如果没有值，再从配置文件中读取，“应用程序”属性都从配置文件读取。

Save：将settings“用户”范围的属性写入到系统中， settings实例后，在程序中被赋予新值，如果想保存这些值以便在程序下一次运行时使用，就可以调用Save保存
例：Properties.Settings.Default.Save();

Reload：从系统或App.config中读取已保存的值刷新当前内存里“用户”范围的属性。先检查系统，当系统中没有保存时再从app.config中获取
例：Properties.Settings.Default.Reload();

Reset：清空系统中保存的settings，并且从app.config中刷新内存里“用户”范围的属性。
例：Properties.Settings.Default.Reset();

Upgrade：当程序安装多个时，从最新的一个程序所保存在系统的值读取出来并刷新内存里“用户”范围的属性。
例：Properties.Settings.Default.Upgrade();

[renyh]

程序签名报错，如何解决？

程序签名时出错: 未能对 bin\Debug\app.publish\dp2Mini.exe 签名。SignTool Error: The specified timestamp server either could not be reached or
returned an invalid response.
SignTool Error: An error occurred while attempting to sign: bin\Debug\app.publish\dp2Mini.exe dp2Mini

参考
electron-userland/electron-builder#2795
将时间戳服务器地址改为 http://sha256timestamp.ws.symantec.com/sha256/timestamp ，编译和发布正常。

http://www.voidcn.com/article/p-olprouko-buk.html

[renyh]

如何设置程序集版本