发表于
字数统计 690

虽然有梯子，可以正常访问github页面，但是在发现“git clone”命令速度特别慢，有时还经常卡掉。可以通过设置git 代理，解决被墙问题。

git 有几种传输协议，在Github上主要用到的是Https和SSH协议。所以我们要做的是对git 命令的https 以及ssh流量做代理。

设置https 代理

Git代理有两种设置方式，分别是全局代理和只对Github代理，建议只对github 代理。代理协议也有两种，分别是使用http代理和使用socks5代理，建议使用socks5代理。注意下面代码的端口号需要根据你自己的代理端口设定，比如我的代理socks端口是51837。

全局设置（不推荐）

1
2
3
4
5
6
 
#使用http代理 
git config --global http.proxy http://127.0.0.1:58591
git config --global https.proxy https://127.0.0.1:58591
#使用socks5代理
git config --global http.proxy socks5://127.0.0.1:51837
git config --global https.proxy socks5://127.0.0.1:51837

只对Github代理（推荐）

1
2
3
4
 
#使用socks5代理（推荐）
git config --global http.https://github.com.proxy socks5://127.0.0.1:51837
#使用http代理（不推荐）
git config --global http.https://github.com.proxy http://127.0.0.1:58591

取消代理

1
 
git config --global --unset http.proxy git config --global --unset https.proxy

设置ssh代理（终极解决方案）

https代理存在一个局限，那就是没有办法做身份验证，每次拉取私库或者推送代码时，都需要输入github的账号和密码，非常痛苦。 设置ssh代理前，请确保你已经设置ssh key。可以参考在 github 上添加 SSH key 完成设置 更进一步是设置ssh代理。只需要配置一个config就可以了。

1
2
3
4
 
# Linux、MacOS
vi ~/.ssh/config
# Windows 
到C:\Users\your_user_name\.ssh目录下，新建一个config文件（无后缀名）

将下面内容加到config文件中即可

对于windows用户，代理会用到connect.exe，你如果安装了Git都会自带connect.exe，如我的路径为C:\APP\Git\mingw64\bin\connect

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
#Windows用户，注意替换你的端口号和connect.exe的路径
ProxyCommand "C:\APP\Git\mingw64\bin\connect" -S 127.0.0.1:51837 -a none %h %p

#MacOS用户用下方这条命令，注意替换你的端口号
#ProxyCommand nc -v -x 127.0.0.1:51837 %h %p

Host github.com
  User git
  Port 22
  Hostname github.com
  # 注意修改路径为你的路径
  IdentityFile "C:\Users\Your_User_Name\.ssh\id_rsa"
  TCPKeepAlive yes

Host ssh.github.com
  User git
  Port 443
  Hostname ssh.github.com
  # 注意修改路径为你的路径
  IdentityFile "C:\Users\Your_User_Name\.ssh\id_rsa"
  TCPKeepAlive yes

保存后文件后测试方法如下，返回successful之类的就成功了。

1
2
 
# 测试是否设置成功
ssh -T git@github.com
阅读全文 »

发表于
字数统计 422

在64位程序中运行使用Microsoft.Jet.OLEDB.4.0需要特别注意，因为Microsoft.Jet.OLEDB.4.0驱动程序是为32位环境设计的。在64位操作系统和64位应用程序中，它可能无法正常工作。

如果你需要在64位程序中使用Microsoft.Jet.OLEDB.4.0，你可以尝试以下方法：

使用WoW64（Windows on Windows 64）桥接器：WoW64是Windows提供的一种机制，允许32位应用程序在64位环境中运行。你可以通过在64位程序中调用WoW64桥接器来访问Microsoft.Jet.OLEDB.4.0驱动程序。这可以通过编程方式实现，例如使用系统调用来调用适当的WoW64函数。 使用32位版本的数据库引擎：如果你有权限安装额外的软件，你可以尝试安装32位版本的数据库引擎，例如Microsoft Access，它包含了Microsoft.Jet.OLEDB.4.0驱动程序。然后，你可以在64位程序中使用这个32位版本的数据库引擎来访问数据库。 使用替代的数据库连接驱动程序：如果可能，考虑使用与64位环境兼容的其他数据库连接驱动程序，例如MySQL或SQLite。这些驱动程序可以在64位环境中正常运行，并且提供了与Microsoft.Jet.OLEDB.4.0相似的功能。 请注意，这些方法可能并不适用于所有情况，具体取决于你的应用程序和需求。在进行任何更改之前，请确保备份你的数据，并测试你的应用程序以确保其正常工作。

阅读全文 »

发表于
字数统计 639

什么是哈夫曼编码

在数据传送时，信息表现为0和1的二进制形式。为了提高传输的速度，可以采用变长的编码方式，寻找更优的编码方式。同时，必须要保证编码不存在二义性（任意字符编码都不是其它字符编码的前缀）。

哈夫曼编码就是符合上述要求的编码方式，采用自底向上的形式构造哈夫曼树。按照字符的概率分配码长，实现平均码长最短的编码。

如何进行哈夫曼编码

使用需要传送的字符构造字符集C = {c1, c2, … cn}，并根据字符出现的频率构建概率集W = {w1, w2, … wn}。哈夫曼编码的流程如下：

  • 将字符集C作为叶子节点；
  • 将频率集W作为叶子节点的权值；
  • 使用C和W构造哈夫曼树；
  • 对哈夫曼树的所有分支，左子树分支编码为0，右子树分支编码为1；

通过上述流程，即完成了哈夫曼编码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
void HuffmanCode(Node *p, const int numLeafs, string *codes) {
	// p为节点数组的指针，codes为string数组的指针 
	// 用于存储每个节点的哈夫曼码

	// parent表示父节点位置
	int parent;

	// 每次对一个叶子节点进行编码
	// i表示当前叶子节点位置
	for (int i=0; i < numLeafs; i++) {

		// j表示当前节点位置，i是不能在下面循环中改变的
		// 使用j来记录节点的移动过程
		int j = i;

		// 当前节点的父节点位置
		parent = p[i].parent;

		// 从当前叶子节点p[i]开始，找到哈夫曼树的根节点
		// 循环结束条件是此时parent为0，即达到哈夫曼树的根节点
		while(parent != -1) {

			// 如果当前节点是父节点的左子树，则此分支编码为0
			if (p[parent].left == j) {
				codes[i].push_back('0');
			}

			// 如果当前节点是父节点的右子树，则编码为1
			else {
				codes[i].push_back('1');
			}
   
			j = parent;
			parent = p[j].parent;
		}
		cout << codes[i] << endl;
	}
}
阅读全文 »

发表于
字数统计 37 
1
2
3
4
5
6
7
 
create trigger [Tgr_table] on [table] 
instead of delete 
as 
begin
select '禁止對表進行刪除操作' ---将对表delete全部锁定禁止操作 
return;
end
阅读全文 »

发表于
字数统计 112

COUNT(字段)

进行全表扫描，判断指定字段的值是否为NULL，不为NULL则累加。

性能比count(1)和count(*)慢。

COUNT(*)和COUNT(1)

在InnoDB中COUNT(*)和COUNT(1)实现上没有区别，而且效率一样，但是COUNT(字段)需要进行字段的非NULL判断，所以效率会低一些。

因为COUNT(*)是SQL92定义的标准统计行数的语法，并且效率高，所以请直接使用COUNT(*)查询表的行数！

阅读全文 »

发表于
字数统计 483

在C#中，ArrayList和List都用于存储集合的数据，但它们有一些重要的区别。

类型安全：

ArrayList：ArrayList是泛型集合类，它允许存储任何类型的数据。然而，由于它不是强类型的，因此在操作数据时可能会出现类型错误。 List：List是泛型集合类，这意味着它只能存储同一种类型的数据。由于它是强类型的，因此在编译时就能发现类型错误。 性能：

ArrayList：ArrayList的性能通常比List低。由于它不是泛型类型，因此在存储数据时需要进行装箱和拆箱操作，这会增加额外的开销。 List：List是泛型类型，所以在存储数据时没有装箱和拆箱操作。这使得List在处理大量数据时比ArrayList更有效率。 方法：

ArrayList：ArrayList提供的方法比List少，例如没有内置的索引器。 List：List提供了更多的方法和功能，例如内置的索引器。 总的来说，如果你知道你的集合将只包含一种类型的数据，并且关心性能，那么使用List通常是更好的选择。如果你需要存储不同类型的数据，或者不关心性能，那么可以使用ArrayList。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
using System;  
using System.Collections.Generic;  
  
namespace ArrayListDemo  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            // 创建一个ArrayList  
            ArrayList myArrayList = new ArrayList();  
  
            // 向ArrayList添加元素  
            myArrayList.Add("Apple");  
            myArrayList.Add("Banana");  
            myArrayList.Add("Cherry");  
  
            // 输出ArrayList中的元素数量  
            Console.WriteLine("ArrayList中的元素数量：" + myArrayList.Count);  
  
            // 遍历ArrayList并输出其中的元素  
            foreach (var item in myArrayList)  
            {  
                Console.WriteLine(item);  
            }  
  
            // 在ArrayList中查找元素并输出其索引位置  
            int index = myArrayList.IndexOf("Banana");  
            Console.WriteLine("Banana在ArrayList中的索引位置：" + index);  
  
            // 在ArrayList中移除元素并输出新元素数量  
            myArrayList.Remove("Cherry");  
            Console.WriteLine("移除元素后的ArrayList中的元素数量：" + myArrayList.Count);  
  
            // 清空ArrayList中的所有元素  
            myArrayList.Clear();  
            Console.WriteLine("清空后的ArrayList中的元素数量：" + myArrayList.Count);  
  
            Console.ReadLine();  
        }  
    }  
}
阅读全文 »

发表于
字数统计 461

FTDI是一家设计和供应USB芯片和软件方案的专业厂商。

当涉及到FTDI的C# demo时，通常是指使用FTDI驱动程序库（如FT232H和FT245芯片）来与外部设备进行通信。以下是一个简单的示例，演示如何使用C#和FTDI驱动程序库来打开串口、发送数据和接收数据。

首先，确保已经安装了FTDI驱动程序库，并在项目中引用了相关的C#库。然后，可以按照以下步骤编写C#代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
using System;  
using System.IO;  
using System.Linq;  
using System.Text;  
using System.Threading.Tasks;  
using FTDI;  
  
namespace FTDIDemo  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            // 打开串口  
            SerialPort port = new SerialPort("COM3"); // 根据实际情况修改串口号  
            port.BaudRate = 9600; // 根据实际情况修改波特率  
            port.Parity = Parity.None;  
            port.DataBits = 8;  
            port.StopBits = StopBits.One;  
            port.Open();  
  
            // 发送数据  
            string dataToSend = "Hello, FTDI!";  
            byte[] dataBytes = Encoding.ASCII.GetBytes(dataToSend);  
            port.Write(dataBytes, 0, dataBytes.Length);  
  
            // 接收数据  
            byte[] buffer = new byte[1024];  
            int bytesRead = port.Read(buffer, 0, buffer.Length);  
            string receivedData = Encoding.ASCII.GetString(buffer, 0, bytesRead);  
            Console.WriteLine("Received data: " + receivedData);  
  
            // 关闭串口  
            port.Close();  
        }  
    }  
}

在这个示例中，我们首先使用SerialPort类打开一个串口，并设置相关的串口参数。然后，我们将要发送的数据转换为字节数组，并通过串口写入数据。接下来，我们创建一个缓冲区来接收从串口读取的数据，并将其转换为字符串。最后，我们关闭串口。

请注意，这只是一个简单的示例，用于演示如何使用C#和FTDI驱动程序库进行基本的串口通信。实际应用中可能需要更复杂的代码来处理错误处理、数据解析和其他功能。

阅读全文 »

发表于
字数统计 289

Roslyn 是以 API 为驱动的下一代编译器，集成在最新版的 Visual Studio 上。它开放 C# 和 Visual Basic 编译器的 API，使得开发者可以借助编译器进行解析代码文件、动态为编程语言增加功能、扩展编译器、自定义编译器动作等操作。

将Roslyn编译结果保存在流中，用程序集加载方法将流加载到当前程序集中，就可以在当前的程序集中调用了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
using System.Threading.Tasks;  
using Microsoft.CodeAnalysis;  
using Microsoft.CodeAnalysis.CSharp;  
using Microsoft.CodeAnalysis.CSharp.Syntax;  
  
namespace RoslynDemo  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            // 加载C#程序集  
            var assembly = Assembly.Load("System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");  
            var compilation = CSharpCompilation.Create("HelloWorld")  
                .AddReferences(assembly)  
                .AddSyntaxTrees(SyntaxFactory.ParseSyntaxTree("using System; class Program { static void Main() { Console.WriteLine(\"Hello, World!\"); } }"));  
  
            // 生成程序集和语法树  
            var assembly = compilation.Emit("HelloWorld.dll");  
            var syntaxTree = compilation.SyntaxTrees.Single();  
  
            // 解析语法树并提取方法信息  
            var root = syntaxTree.GetRoot();  
            var methods = root.DescendantNodes().OfType<MethodDeclarationSyntax>();  
            foreach (var method in methods)  
            {  
                Console.WriteLine("方法名称：{0}", method.Identifier);  
                Console.WriteLine("方法返回类型：{0}", method.Type);  
                Console.WriteLine("方法体：");  
                Console.WriteLine(method.Body);  
                Console.WriteLine();  
            }  
        }  
    }  
}
阅读全文 »

发表于
字数统计 594

Portable Mode

Visual Studio Code supports Portable mode. This mode enables all data created and maintained by VS Code to live near itself, so it can be moved around across environments.

This mode also provides a way to set the installation folder location for VS Code extensions, useful for corporate environments that prevent extensions from being installed in the Windows AppData folder.

Portable mode is supported on the ZIP download for Windows, and the TAR.GZ download for Linux, as well as the regular Application download for macOS. See the Download page to find the correct .zip / .tar.gz file for your platform.

Note: Do not attempt to configure portable mode on an installation from the Windows User or System installers. Portable mode is only supported on the Windows ZIP (.zip) archive. Note as well that the Windows ZIP archive does not support auto update.

Enable Portable mode

Windows, Linux

After unzipping the VS Code download, create a data folder within VS Code’s folder:

1
2
3
4
 
|- VSCode-win32-x64-1.25.0-insider
|   |- Code.exe (or code executable)
|   |- data
|   |- ...

From then on, that folder will be used to contain all VS Code data, including session state, preferences, extensions, etc.

The data folder can be moved to other VS Code installations. This is useful for updating your portable VS Code version, in which case you can move the data folder to a newer extracted version of VS Code.

macOS

On macOS, you need to place the data folder as a sibling of the application itself. Since the folder will be alongside the application, you need to name it specifically so that VS Code can find it. The default folder name is code-portable-data:

1
2
 
|- Visual Studio Code.app
|- code-portable-data

Portable Mode won’t work if your application is in quarantine, which happens by default if you just downloaded VS Code. Make sure you remove the quarantine attribute, if Portable Mode doesn’t seem to work:

1
 
xattr -dr com.apple.quarantine Visual\ Studio\ Code.app

Note: On Insiders, the folder should be named code-insiders-portable-data.

Update Portable VS Code

On Windows and Linux, you can update VS Code by copying the data folder over to a more recent version of VS Code.

On macOS, automatic updates should work as always, no extra work needed.

Migrate to Portable mode

You can also migrate an existing installation to Portable mode.

Windows, Linux

  1. Download the VS Code (or VS Code Insiders) ZIP distribution for your platform.
  2. Create the data folder as above.
  3. Copy the user data directory Code to data and rename it to user-data:
    • Windows %APPDATA%\Code
    • Linux $HOME/.config/Code
  4. Copy the extensions directory to data:
    • Windows %USERPROFILE%\.vscode\extensions
    • Linux ~/.vscode/extensions

As an example, here’s the desired outcome on Windows:

1
2
3
4
5
6
7
8
 
|- VSCode-win32-x64-1.25.0-insider
|   |- Code.exe (or code executable)
|   |- data
|   |   |- user-data
|   |   |   |- ...
|   |   |- extensions
|   |   |   |- ...
|   |- ...

macOS

  1. Download VS Code (or VS Code Insiders) for macOS.
  2. Create the code-portable-data folder as above.
  3. Copy the user data directory Code to code-portable-data and rename it to user-data:
    • $HOME/Library/Application Support/Code
  4. Copy the extensions directory to code-portable-data:
    • ~/.vscode/extensions

TMP directory

By default, the default TMP directory is still the system one even in Portable Mode, since no state is kept there. If you want to also have your TMP directory within your portable directory, you can create an empty tmp directory inside the data folder. As long as a tmp directory exists, it will be used for TMP data.

阅读全文 »

发表于
字数统计 546

MQTT（Message Queuing Telemetry Transport，消息队列遥测传输协议），是一种基于发布/订阅（publish/subscribe）模式的”轻量级”通讯协议，该协议构建于TCP/IP协议上，由IBM在1999年发布。MQTT最大优点在于，可以以极少的代码和有限的带宽，为连接远程设备提供实时可靠的消息服务。作为一种低开销、低带宽占用的即时通讯协议，使其在物联网、小型设备、移动应用等方面有较广泛的应用。

MQTT是一个基于客户端-服务器的消息发布/订阅传输协议。MQTT协议是轻量、简单、开放和易于实现的，这些特点使它适用范围非常广泛。在很多情况下，包括受限的环境中，如：机器与机器（M2M）通信和物联网（IoT）。其在，通过卫星链路通信传感器、偶尔拨号的医疗设备、智能家居、及一些小型化设备中已广泛使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
using MQTTnet;
using MQTTnet.Client;

private async Task Handle_Received_Application_Message()
{
    var mqttFactory = new MqttFactory();
    using (var mqttClient = mqttFactory.CreateMqttClient())
    {
        var mqttClientOptions = new MqttClientOptionsBuilder()
            .WithTcpServer("192.168.106.76")
            .Build();

        mqttClient.ApplicationMessageReceivedAsync += e =>
        {
            string payload = Encoding.UTF8.GetString(e.ApplicationMessage.Payload);
            HandlePayload(payload);
            return Task.CompletedTask;
        };

        var mqttSubscribeOptions = mqttFactory.CreateSubscribeOptionsBuilder()
            .WithTopicFilter(f =>
            {
                f.WithTopic("fe-prod/sso2_burnin/v1/0c:b2:b7:ce:de:73/SSO2/all-data");
            })
            .WithTopicFilter(f =>
            {
                f.WithTopic("fe-prod/sso2_burnin/v1/fc:69:47:b8:3a:54/SSO2/all-data");
            })
            .WithTopicFilter(f => {
                f.WithTopic("fe-prod/sso2_burnin/v1/24:76:25:e9:9b:73/SSO2/all-data");
            })
            .Build();

        mqttClient.DisconnectedAsync += async e =>
        {
            AddLog("Disconnected...");
            await Task.Delay(1000);
            log.Error("连接已断开,尝试重新连接...", e.Exception);
            for (int i = 9; i > 0; i--)
            {
                AddLog($"Reconnect after {i}s...");
                await Task.Delay(1000);
            }
            await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
            await mqttClient.SubscribeAsync(mqttSubscribeOptions, CancellationToken.None);
            //if (e.ClientWasConnected)
            //{
            //    // Use the current options as the new options.
            //    await mqttClient.ConnectAsync(mqttClient.Options);
            //}
            //else
            //{
            //    await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
            //    await mqttClient.SubscribeAsync(mqttSubscribeOptions, CancellationToken.None);
            //}
        };

        await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
        await mqttClient.SubscribeAsync(mqttSubscribeOptions, CancellationToken.None);

        locks.WaitOne();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
import paho.mqtt.client as mqtt

# Successful Connection Callback
def on_connect(client, userdata, flags, rc):
    print('Connected with result code '+str(rc))
    client.subscribe('testtopic/#')

# Message delivery callback
def on_message(client, userdata, msg):
    print(msg.topic+" "+str(msg.payload))

client = mqtt.Client()

# Set callback handler
client.on_connect = on_connect
client.on_message = on_message

# Set up connection
client.connect('broker.emqx.io', 1883, 60)
# Publish message
client.publish('emqtt',payload='Hello World',qos=0)

client.loop_forever()
阅读全文 »