Snapman系統中TCC執行效率和C#執行效率對比

来源:http://www.cnblogs.com/virtualNatural/archive/2017/07/16/7188680.html
-Advertisement-
Play Games

Snapman集合了TCC編譯器可以直接編譯執行C語言腳本,其腳本執行效率和C#編譯程式進行效率對比,包括下麵4方面: 1、函數執行效率 2、數字轉換成字元串 3、字元串的疊加 4、MD5演算法 這是C#代碼: using System; using System.Collections.Generi ...


Snapman集合了TCC編譯器可以直接編譯執行C語言腳本,其腳本執行效率和C#編譯程式進行效率對比,包括下麵4方面:

1、函數執行效率

2、數字轉換成字元串

3、字元串的疊加

4、MD5演算法

這是C#代碼:

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

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

        int fibonacci(int n)
        {
            if (n == 1 || n == 2)
                return 1;
            return fibonacci(n - 1) + fibonacci(n - 2);
        }
        string numberConvert()
        {
            string result = "";
            for (int i = 0; i < 14000000; i++ )
            {
                result = i.ToString();
            }
            return result;
        }
        string stringAppend()
        {
            string conc = "StringBuilder sb = new StringBuilder(1024);";
            StringBuilder sb = new StringBuilder(1024);
            for (int i = 0; i < 1400; i++)
            {
                sb = new StringBuilder(1024);
                for (int j = 0; j < 10000; j++ )
                {
                    sb.Append(conc);
                }
            }
            return sb.ToString();
        }
        public class MD5
        {
            //static state variables
            private static UInt32 A;
            private static UInt32 B;
            private static UInt32 C;
            private static UInt32 D;

            //number of bits to rotate in tranforming
            private const int S11 = 7;
            private const int S12 = 12;
            private const int S13 = 17;
            private const int S14 = 22;
            private const int S21 = 5;
            private const int S22 = 9;
            private const int S23 = 14;
            private const int S24 = 20;
            private const int S31 = 4;
            private const int S32 = 11;
            private const int S33 = 16;
            private const int S34 = 23;
            private const int S41 = 6;
            private const int S42 = 10;
            private const int S43 = 15;
            private const int S44 = 21;

            /* F, G, H and I are basic MD5 functions.
             * 四個非線性函數:
             * 
             * F(X,Y,Z) =(X&Y)|((~X)&Z)
             * G(X,Y,Z) =(X&Z)|(Y&(~Z))
             * H(X,Y,Z) =X^Y^Z
             * I(X,Y,Z)=Y^(X|(~Z))
             * 
             * (&與,|或,~非,^異或)
             */
            private static UInt32 F(UInt32 x, UInt32 y, UInt32 z)
            {
                return (x & y) | ((~x) & z);
            }
            private static UInt32 G(UInt32 x, UInt32 y, UInt32 z)
            {
                return (x & z) | (y & (~z));
            }
            private static UInt32 H(UInt32 x, UInt32 y, UInt32 z)
            {
                return x ^ y ^ z;
            }
            private static UInt32 I(UInt32 x, UInt32 y, UInt32 z)
            {
                return y ^ (x | (~z));
            }

            /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
             * Rotation is separate from addition to prevent recomputation.
             */
            private static void FF(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 mj, int s, UInt32 ti)
            {
                a = a + F(b, c, d) + mj + ti;
                a = a << s | a >> (32 - s);
                a += b;
            }
            private static void GG(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 mj, int s, UInt32 ti)
            {
                a = a + G(b, c, d) + mj + ti;
                a = a << s | a >> (32 - s);
                a += b;
            }
            private static void HH(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 mj, int s, UInt32 ti)
            {
                a = a + H(b, c, d) + mj + ti;
                a = a << s | a >> (32 - s);
                a += b;
            }
            private static void II(ref UInt32 a, UInt32 b, UInt32 c, UInt32 d, UInt32 mj, int s, UInt32 ti)
            {
                a = a + I(b, c, d) + mj + ti;
                a = a << s | a >> (32 - s);
                a += b;
            }

            private static void MD5_Init()
            {
                A = 0x67452301; //in memory, this is 0x01234567
                B = 0xefcdab89; //in memory, this is 0x89abcdef
                C = 0x98badcfe; //in memory, this is 0xfedcba98
                D = 0x10325476; //in memory, this is 0x76543210
            }

            private static UInt32[] MD5_Append(byte[] input)
            {
                int zeros = 0;
                int ones = 1;
                int size = 0;
                int n = input.Length;
                int m = n % 64;
                if (m < 56)
                {
                    zeros = 55 - m;
                    size = n - m + 64;
                }
                else if (m == 56)
                {
                    zeros = 0;
                    ones = 0;
                    size = n + 8;
                }
                else
                {
                    zeros = 63 - m + 56;
                    size = n + 64 - m + 64;
                }

                ArrayList bs = new ArrayList(input);
                if (ones == 1)
                {
                    bs.Add((byte)0x80); // 0x80 = $10000000
                }
                for (int i = 0; i < zeros; i++)
                {
                    bs.Add((byte)0);
                }

                UInt64 N = (UInt64)n * 8;
                byte h1 = (byte)(N & 0xFF);
                byte h2 = (byte)((N >> 8) & 0xFF);
                byte h3 = (byte)((N >> 16) & 0xFF);
                byte h4 = (byte)((N >> 24) & 0xFF);
                byte h5 = (byte)((N >> 32) & 0xFF);
                byte h6 = (byte)((N >> 40) & 0xFF);
                byte h7 = (byte)((N >> 48) & 0xFF);
                byte h8 = (byte)(N >> 56);
                bs.Add(h1);
                bs.Add(h2);
                bs.Add(h3);
                bs.Add(h4);
                bs.Add(h5);
                bs.Add(h6);
                bs.Add(h7);
                bs.Add(h8);
                byte[] ts = (byte[])bs.ToArray(typeof(byte));

                /* Decodes input (byte[]) into output (UInt32[]). Assumes len is
                 * a multiple of 4.
                 */
                UInt32[] output = new UInt32[size / 4];
                for (Int64 i = 0, j = 0; i < size; j++, i += 4)
                {
                    output[j] = (UInt32)(ts[i] | ts[i + 1] << 8 | ts[i + 2] << 16 | ts[i + 3] << 24);
                }
                return output;
            }
            private static UInt32[] MD5_Trasform(UInt32[] x)
            {

                UInt32 a, b, c, d;

                for (int k = 0; k < x.Length; k += 16)
                {
                    a = A;
                    b = B;
                    c = C;
                    d = D;

                    /* Round 1 */
                    FF(ref a, b, c, d, x[k + 0], S11, 0xd76aa478); /* 1 */
                    FF(ref d, a, b, c, x[k + 1], S12, 0xe8c7b756); /* 2 */
                    FF(ref c, d, a, b, x[k + 2], S13, 0x242070db); /* 3 */
                    FF(ref b, c, d, a, x[k + 3], S14, 0xc1bdceee); /* 4 */
                    FF(ref a, b, c, d, x[k + 4], S11, 0xf57c0faf); /* 5 */
                    FF(ref d, a, b, c, x[k + 5], S12, 0x4787c62a); /* 6 */
                    FF(ref c, d, a, b, x[k + 6], S13, 0xa8304613); /* 7 */
                    FF(ref b, c, d, a, x[k + 7], S14, 0xfd469501); /* 8 */
                    FF(ref a, b, c, d, x[k + 8], S11, 0x698098d8); /* 9 */
                    FF(ref d, a, b, c, x[k + 9], S12, 0x8b44f7af); /* 10 */
                    FF(ref c, d, a, b, x[k + 10], S13, 0xffff5bb1); /* 11 */
                    FF(ref b, c, d, a, x[k + 11], S14, 0x895cd7be); /* 12 */
                    FF(ref a, b, c, d, x[k + 12], S11, 0x6b901122); /* 13 */
                    FF(ref d, a, b, c, x[k + 13], S12, 0xfd987193); /* 14 */
                    FF(ref c, d, a, b, x[k + 14], S13, 0xa679438e); /* 15 */
                    FF(ref b, c, d, a, x[k + 15], S14, 0x49b40821); /* 16 */

                    /* Round 2 */
                    GG(ref a, b, c, d, x[k + 1], S21, 0xf61e2562); /* 17 */
                    GG(ref d, a, b, c, x[k + 6], S22, 0xc040b340); /* 18 */
                    GG(ref c, d, a, b, x[k + 11], S23, 0x265e5a51); /* 19 */
                    GG(ref b, c, d, a, x[k + 0], S24, 0xe9b6c7aa); /* 20 */
                    GG(ref a, b, c, d, x[k + 5], S21, 0xd62f105d); /* 21 */
                    GG(ref d, a, b, c, x[k + 10], S22, 0x2441453); /* 22 */
                    GG(ref c, d, a, b, x[k + 15], S23, 0xd8a1e681); /* 23 */
                    GG(ref b, c, d, a, x[k + 4], S24, 0xe7d3fbc8); /* 24 */
                    GG(ref a, b, c, d, x[k + 9], S21, 0x21e1cde6); /* 25 */
                    GG(ref d, a, b, c, x[k + 14], S22, 0xc33707d6); /* 26 */
                    GG(ref c, d, a, b, x[k + 3], S23, 0xf4d50d87); /* 27 */
                    GG(ref b, c, d, a, x[k + 8], S24, 0x455a14ed); /* 28 */
                    GG(ref a, b, c, d, x[k + 13], S21, 0xa9e3e905); /* 29 */
                    GG(ref d, a, b, c, x[k + 2], S22, 0xfcefa3f8); /* 30 */
                    GG(ref c, d, a, b, x[k + 7], S23, 0x676f02d9); /* 31 */
                    GG(ref b, c, d, a, x[k + 12], S24, 0x8d2a4c8a); /* 32 */

                    /* Round 3 */
                    HH(ref a, b, c, d, x[k + 5], S31, 0xfffa3942); /* 33 */
                    HH(ref d, a, b, c, x[k + 8], S32, 0x8771f681); /* 34 */
                    HH(ref c, d, a, b, x[k + 11], S33, 0x6d9d6122); /* 35 */
                    HH(ref b, c, d, a, x[k + 14], S34, 0xfde5380c); /* 36 */
                    HH(ref a, b, c, d, x[k + 1], S31, 0xa4beea44); /* 37 */
                    HH(ref d, a, b, c, x[k + 4], S32, 0x4bdecfa9); /* 38 */
                    HH(ref c, d, a, b, x[k + 7], S33, 0xf6bb4b60); /* 39 */
                    HH(ref b, c, d, a, x[k + 10], S34, 0xbebfbc70); /* 40 */
                    HH(ref a, b, c, d, x[k + 13], S31, 0x289b7ec6); /* 41 */
                    HH(ref d, a, b, c, x[k + 0], S32, 0xeaa127fa); /* 42 */
                    HH(ref c, d, a, b, x[k + 3], S33, 0xd4ef3085); /* 43 */
                    HH(ref b, c, d, a, x[k + 6], S34, 0x4881d05); /* 44 */
                    HH(ref a, b, c, d, x[k + 9], S31, 0xd9d4d039); /* 45 */
                    HH(ref d, a, b, c, x[k + 12], S32, 0xe6db99e5); /* 46 */
                    HH(ref c, d, a, b, x[k + 15], S33, 0x1fa27cf8); /* 47 */
                    HH(ref b, c, d, a, x[k + 2], S34, 0xc4ac5665); /* 48 */

                    /* Round 4 */
                    II(ref a, b, c, d, x[k + 0], S41, 0xf4292244); /* 49 */
                    II(ref d, a, b, c, x[k + 7], S42, 0x432aff97); /* 50 */
                    II(ref c, d, a, b, x[k + 14], S43, 0xab9423a7); /* 51 */
                    II(ref b, c, d, a, x[k + 5], S44, 0xfc93a039); /* 52 */
                    II(ref a, b, c, d, x[k + 12], S41, 0x655b59c3); /* 53 */
                    II(ref d, a, b, c, x[k + 3], S42, 0x8f0ccc92); /* 54 */
                    II(ref c, d, a, b, x[k + 10], S43, 0xffeff47d); /* 55 */
                    II(ref b, c, d, a, x[k + 1], S44, 0x85845dd1); /* 56 */
                    II(ref a, b, c, d, x[k + 8], S41, 0x6fa87e4f); /* 57 */
                    II(ref d, a, b, c, x[k + 15], S42, 0xfe2ce6e0); /* 58 */
                    II(ref c, d, a, b, x[k + 6], S43, 0xa3014314); /* 59 */
                    II(ref b, c, d, a, x[k + 13], S44, 0x4e0811a1); /* 60 */
                    II(ref a, b, c, d, x[k + 4], S41, 0xf7537e82); /* 61 */
                    II(ref d, a, b, c, x[k + 11], S42, 0xbd3af235); /* 62 */
                    II(ref c, d, a, b, x[k + 2], S43, 0x2ad7d2bb); /* 63 */
                    II(ref b, c, d, a, x[k + 9], S44, 0xeb86d391); /* 64 */

                    A += a;
                    B += b;
                    C += c;
                    D += d;
                }
                return new UInt32[] { A, B, C, D };
            }
            public static byte[] MD5Array(byte[] input)
            {
                MD5_Init();
                UInt32[] block = MD5_Append(input);
                UInt32[] bits = MD5_Trasform(block);

                /* Encodes bits (UInt32[]) into output (byte[]). Assumes len is
                 * a multiple of 4.
                   */
                byte[] output = new byte[bits.Length * 4];
                for (int i = 0, j = 0; i < bits.Length; i++, j += 4)
                {
                    output[j] = (byte)(bits[i] & 0xff);
                    output[j + 1] = (byte)((bits[i] >> 8) & 0xff);
                    output[j + 2] = (byte)((bits[i] >> 16) & 0xff);
                    output[j + 3] = (byte)((bits[i] >> 24) & 0xff);
                }
                return output;
            }

            public static string ArrayToHexString(byte[] array, bool uppercase)
            {
                string hexString = "";
                string format = "x2";
                if (uppercase)
                {
                    format = "X2";
                }
                foreach (byte b in array)
                {
                    hexString += b.ToString(format);
                }
                return hexString;
            }

            public static string MDString(string message)
            {
                char[] c = message.ToCharArray();
                byte[] b = new byte[c.Length];
                for (int i = 0; i < c.Length; i++)
                {
                    b[i] = (byte)c[i];
                }
                byte[] digest = MD5Array(b);
                return ArrayToHexString(digest, false);
            }
        }
        string testMd5()
        {
            
            string conc = "StringBuilder sb = new StringBuilder(1024);StringBuilder sb = new StringBuilder(1024);StringBuilder sb = new StringBuilder(1024);StringBuilder sb = new StringBuilder(1024);";
            conc = conc + conc + conc + conc + conc + conc + conc + conc;
            string about = "";
            for (int i = 0; i < 100000; i++ )
            {
               about = MD5.MDString(conc);
            }
            return about;
        }
        private void button1_Click(object sender, EventArgs e)
        {
            DateTime fbeforDT = System.DateTime.Now;
            fibonacci(45); 
            DateTime fafterDT = System.DateTime.Now;
            TimeSpan ts = fafterDT.Subtract(fbeforDT);
            textBox1.Text = string.Format("fibonacci spend: {0}ms.", ts.TotalMilliseconds);

            DateTime nbeforDT = System.DateTime.Now;
            numberConvert();
            DateTime nafterDT = System.DateTime.Now;
            TimeSpan nts = nafterDT.Subtract(nbeforDT);
            textBox2.Text = string.Format("numberConvert spend: {0}ms.", nts.TotalMilliseconds);

            DateTime sbeforDT = System.DateTime.Now;
            stringAppend();
            DateTime safterDT = System.DateTime.Now;
            TimeSpan sts = safterDT.Subtract(sbeforDT);
            textBox3.Text = string.Format("stringAppend spend: {0}ms.", sts.TotalMilliseconds);

            DateTime mbeforDT = System.DateTime.Now;
            testMd5();
            DateTime mafterDT = System.DateTime.Now;
            TimeSpan mts = mafterDT.Subtract(mbeforDT);
            textBox4.Text = string.Format("testMd5 spend: {0}ms.", mts.TotalMilliseconds);

        }
    }
    
}
View Code

這是C#編譯出來Release的頁面:

這是Snapman系統中寫的TCC腳本代碼:

int fibonacci(int n)  
{  
    if(n==1||n==2)  
        return 1;  
    return fibonacci(n-1) + fibonacci(n-2);  
}
char* numberConvert()
{
    char* result = (char*)malloc(128);
    for (int i = 0; i < 14000000; i++ )
    {
        itoa(i,result,10);
    }
    return result;
}
char* stringAppend()
{
    char* conc = "StringBuilder sb = new StringBuilder(1024);";
    char* sb = (char*)malloc(1024);
    int len = 1024, cl = strlen(conc), curlen = 0;
    for (int i = 0; i < 1400; i++)
    {
        free(sb);
        len = 1024;
        curlen = 0;
        sb = (char*)malloc(1024);
        for(int j = 0; j < 10000; j++)
        {
            if(curlen + cl > len)
            {
                sb = (char*)realloc(sb,len*2);
                len *= 2;
            }
            memcpy(sb+curlen,conc,cl);
            curlen += cl;
        }
    }
    sb[curlen] = 0;
    return sb;
}

#define S11 7 
#define S12 12 
#define S13 17 
#define S14 22 
#define S21 5 
#define S22 9 
#define S23 14 
#define S24 20 
#define S31 4 
#define S32 11 
#define S33 16 
#define S34 23 
#define S41 6 
#define S42 10 
#define S43 15 
#define S44 21 

static unsigned char PADDING[64] = { 
    0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 
}; 

#define   F(x, y, z) (((x) & (y)) | ((~x) & (z))) 
#define   G(x, y, z) (((x) & (z)) | ((y) & (~z))) 
#define   H(x, y, z) ((x) ^ (y) ^ (z)) 
#define   I(x, y, z) ((y) ^ ((x) | (~z))) 

#define   ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) 

#define   FF(a, b, c, d, x, s, ac) {   (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac);   (a) = ROTATE_LEFT ((a), (s));   (a) += (b);   } 
#define   GG(a, b, c, d, x, s, ac) {   (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac);   (a) = ROTATE_LEFT ((a), (s));   (a) += (b);   } 
#define   HH(a, b, c, d, x, s, ac) {   (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac);   (a) = ROTATE_LEFT ((a), (s));   (a) += (b);   } 
#define   II(a, b, c, d, x, s, ac) {   (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac);   (a) = ROTATE_LEFT ((a), (s));   (a) += (b); } 

typedef unsigned char *POINTER; 
typedef unsigned short int UINT2; 
typedef unsigned long int UINT4; 
typedef struct   
{ 
    UINT4 state[4]; 
    UINT4 count[2]; 
    unsigned char buffer[64]; 
} MD5_CTX; 

void Encode(unsigned char *output, UINT4 *input, unsigned int len

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 在使用mybatis進行資料庫連接操作時對於SQL語句返回結果的處理通常有兩種方式,一種就是resultType另一種就是resultMap,下麵說下我對這兩者的認識和理解 比如,我們平時使用的單表查詢,很多時候使用的就是resultType 下來,看一段代碼吧 上面的PO類我使用的是我的一個小De ...
  • Java 是1995年SUN公司推出的一門高級編程語言,是面向互聯網的語言,WEB應用程式首選的語言(安卓底層,大數據hadoop框架用java編寫,Spark用Scala編寫,Scala用java寫的),(相對其他語言)簡單易學、安全可靠、完全面向對象、跨平臺(操作系統,完全忽略操作系統,寫完後任 ...
  • 第1種方法: //setSize(300, 200); pack(); // 得到顯示器屏幕的寬、高 int width = Toolkit.getDefaultToolkit().getScreenSize().width; int height = Toolkit.getDefaultToolk ...
  • 題目背景 全場基本暴力 題目描述 輸入輸出格式 輸入格式: 如圖 輸出格式: 如圖 輸入輸出樣例 輸入樣例#1: 如圖 輸出樣例#1: 如圖 輸入樣例#1: 如圖 輸出樣例#1: 如圖 說明 如圖 這題用到了容斥原理和線性篩的一些東西, 表示沒怎麼看懂、。。。 ...
  • 在web開發中,靜態資源的訪問是必不可少的,如:圖片、js、css 等資源的訪問。 spring Boot 對靜態資源訪問提供了很好的支持,基本使用預設配置就能滿足開發需求。 一、預設靜態資源映射 Spring Boot 對靜態資源映射提供了預設配置 Spring Boot 預設將 / 所有訪問映射 ...
  • 在使用spring boot過程中,可以發現項目中只需要極少的配置就能完成相應的功能,這歸功於spring boot中的模塊化配置,在pom.xml中依賴的每個Starter都有預設配置,而這些預設配置足以滿足正常的功能開發。 如果需要修改自定義修改預設配置,spring boot 提供了很簡便的方 ...
  • 一 概述 1.目錄進入點 目錄進入點是文件在壓縮文件中的映射,代表壓縮文件。壓縮文件時,創建目錄進入點,將文件寫入該目錄進入點。解壓時,獲取目錄進入點,將該目錄進入點的內容寫入硬碟指定文件。 如果目錄進入點是一個文件夾,在命名時必須以路徑分隔符結尾,在Window操作系統中名稱分隔符為“/”。 2. ...
  • 什麼是電腦程式設計? 簡單的說,它就是告訴電腦要做什麼。電腦可以做很多事情,但是不太擅長自主思考,程式員需要像給小孩子喂飯一樣告訴它具體的細節,並且使電腦能夠理解的語言——演算法。 演算法(Algorithm)是指解題方案的準確而完整的描述,是一系列解決問題的清晰指令,演算法代表著用系統的方法描述 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發(一):使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說,近來想嘗試開發一款安卓APP,考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP,畢竟是使用Visual Studio開發工具,使用起來也比較的順手,結合微軟官方的教程進行了安卓 ...
  • 前言 QuestPDF 是一個開源 .NET 庫,用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫,它徹底改變了我們生成 PDF 文檔的方 ...
  • 項目地址 項目後端地址: https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址: ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址: http://tree ...
  • 話不多說,直接開乾 一.下載 1.官方鏈接下載: https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe,運行開始下載SQL server; 二. ...
  • 前言 隨著物聯網(IoT)技術的迅猛發展,MQTT(消息隊列遙測傳輸)協議憑藉其輕量級和高效性,已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫,為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog支持多種接收器用於日誌存儲,增強器用於添加屬性,LogContext管理動態屬性,支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項,適用於不同需求。 ...
  • 目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據,爬取信息時需要模擬瀏覽器行為,否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下: 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • 1.前言 什麼是熱更新 游戲或者軟體更新時,無需重新下載客戶端進行安裝,而是在應用程式啟動的情況下,在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR,Xlua,ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles,Addressable, ...
  • 本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺,其實像阿裡雲,騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後,它會送 ...
  • 通過以下方式可以高效,並保證數據同步的可靠性 1.API設計 使用RESTful設計,確保API端點明確,並使用適當的HTTP方法(如POST用於創建,PUT用於更新)。 設計清晰的請求和響應模型,以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證,確保接收到的數據符合預期格 ...