表達式樹練習實踐：C# 五類運算符的表達式樹表達

来源:https://www.cnblogs.com/whuanle/archive/2019/09/18/11545441.html
-Advertisement-
Play Games

表達式樹練習實踐：C 運算符 [TOC] 在 C 中，算術運算符，有以下類型 算術運算符 關係運算符 邏輯運算符 位運算符 賦值運算符 其他運算符 這些運算符根據參數的多少，可以分作一元運算符、二元運算符、三元運算符。本文將圍繞這些運算符，演示如何使用表達式樹進行操作。 對於一元運算符和二元運算符的 ...


目錄

表達式樹練習實踐：C# 運算符

在 C# 中，算術運算符，有以下類型

  • 算術運算符
  • 關係運算符
  • 邏輯運算符
  • 位運算符
  • 賦值運算符
  • 其他運算符

這些運算符根據參數的多少，可以分作一元運算符、二元運算符、三元運算符。本文將圍繞這些運算符，演示如何使用表達式樹進行操作。

對於一元運算符和二元運算符的 Expression 的子類型如下：

UnaryExpression; //一元運算表達式
BinaryExpression; //二元運算表達式

一，算術運算符

運算符 描述
+ 把兩個操作數相加
- 從第一個操作數中減去第二個操作數
* 把兩個操作數相乘
/ 分子除以分母
% 取模運算符，整除後的餘數
++ 自增運算符，整數值增加 1
-- 自減運算符，整數值減少 1

+ 與 Add()

正常代碼

            int a;
            int b;
            a = 100;
            b = 200;
            var ab = a + b;
            Console.WriteLine(ab);

使用表達式樹構建

            ParameterExpression a = Expression.Parameter(typeof(int), "a");
            ParameterExpression b = Expression.Parameter(typeof(int), "b");

            // ab = a + b
            BinaryExpression ab = Expression.Add(a, b);

            // 列印 a + b 的值
            MethodCallExpression method = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), ab);

            Expression<Action<int, int>> lambda = Expression.Lambda<Action<int, int>>(method, a, b);
            lambda.Compile()(100, 200);

            Console.ReadKey();

如果想複雜一些，使用 塊 來執行：

            ParameterExpression a = Expression.Parameter(typeof(int), "a");
            ParameterExpression b = Expression.Parameter(typeof(int), "b");

            // 別忘記了賦值
            BinaryExpression aa = Expression.Assign(a, Expression.Constant(100, typeof(int)));
            BinaryExpression bb = Expression.Assign(b, Expression.Constant(200, typeof(int)));

            // ab = a + b
            BinaryExpression ab = Expression.Add(a, b);

            // 列印 a + b 的值
            MethodCallExpression method = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), ab);

            // 以塊的形式執行代碼，相當於{ }
            // 不需要糾結這裡，後面會有詳細說明，重點是上面
            var call = Expression.Block(new ParameterExpression[] { a, b }, aa, bb, method);
            Expression<Action> lambda = Expression.Lambda<Action>(call);
            lambda.Compile()();

上面兩個示例，是使用表達式樹計算結果，然後還是使用表達式樹列印結果。

前者依賴外界傳入參數值，賦予 a、b，後者則全部使用表達式樹賦值和運算。

那麼，如何通過表達式樹執行運算，獲取執行結果呢？

            ParameterExpression a = Expression.Parameter(typeof(int), "a");
            ParameterExpression b = Expression.Parameter(typeof(int), "b");

            // ab = a + b
            BinaryExpression ab = Expression.Add(a, b);

            Expression<Func<int, int, int>> lambda = Expression.Lambda<Func<int, int, int>>(ab, a, b);
            int result = lambda.Compile()(100, 200);

            Console.WriteLine(result);
            Console.ReadKey();

這些區別在於如何編寫 Expression.Lambda()。

另外，使用 AddChecked() 可以檢查操作溢出。

- 與 Subtract()

與加法一致，此處不再贅述，SubtractChecked() 可以檢查溢出。

a - b ，結果是 100 。

            ParameterExpression a = Expression.Parameter(typeof(int), "a");
            ParameterExpression b = Expression.Parameter(typeof(int), "b");

            // ab = a - b
            BinaryExpression ab = Expression.Subtract(a, b);

            Expression<Func<int, int, int>> lambda = Expression.Lambda<Func<int, int, int>>(ab, a, b);
            int result = lambda.Compile()(200, 100);

            Console.WriteLine(result);

乘除、取模

乘法

            // ab = a * b
            BinaryExpression ab = Expression.Multiply(a, b);
// ab = 20000

除法

            // ab = a / b
            BinaryExpression ab = Expression.Divide(a, b);
// ab = 2

取模(%)

            ParameterExpression a = Expression.Parameter(typeof(int), "a");
            ParameterExpression b = Expression.Parameter(typeof(int), "b");

            // ab = a % b
            BinaryExpression ab = Expression.Modulo(a, b);

            Expression<Func<int, int, int>> lambda = Expression.Lambda<Func<int, int, int>>(ab, a, b);
            int result = lambda.Compile()(200, 150);
// ab = 50
            Console.WriteLine(result);
            Console.ReadKey();

自增自減

自增自減有兩種模型，一種是 x++ 或 x--，另一種是 ++x 或 --x。

他們都是屬於 UnaryExpression 類型。

算術運算符 表達式樹 說明
x++ Expression.PostIncrementAssign() 後置
x-- Expression.PostDecrementAssign() 後置
++x Expression.PreIncrementAssign() 前置
--x Expression.PreDecrementAssign() 前置

巧記：Post 後置， Pre 前置；Increment 是加，Decrement是減；Assign與賦值有關(後面會說到)；

x++ 與 x-- 的使用

            int a = 10;
            int b = 10;
            a++;
            b--;
            Console.WriteLine(a);
            Console.WriteLine(b);
            // int a,b;
            ParameterExpression a = Expression.Parameter(typeof(int), "a");
            ParameterExpression b = Expression.Parameter(typeof(int), "b");

            // a = 10,b = 10;
            BinaryExpression setA = Expression.Assign(a, Expression.Constant(10));
            BinaryExpression setB = Expression.Assign(b, Expression.Constant(10));

            // a++
            UnaryExpression aa = Expression.PostIncrementAssign(a);

            // b--
            UnaryExpression bb = Expression.PostDecrementAssign(b);

            //Console.WriteLine(a);
            //Console.WriteLine(b);
            MethodCallExpression callA = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), a);
            MethodCallExpression callB = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), b);

            BlockExpression block = Expression.Block(
                new ParameterExpression[] { a, b },
                setA,
                setB,
                aa,
                bb,
                callA,
                callB
                );

            Expression<Action> lambda = Expression.Lambda<Action>(block);
            lambda.Compile()();

            Console.ReadKey();

如果想把參數從外面傳入，設置 a，b

            // int a,b;
            ParameterExpression a = Expression.Variable(typeof(int), "a");
            ParameterExpression b = Expression.Variable(typeof(int), "b");

            // a++
            UnaryExpression aa = Expression.PostIncrementAssign(a);

            // b--
            UnaryExpression bb = Expression.PostDecrementAssign(b);

            //Console.WriteLine(a);
            //Console.WriteLine(b);
            MethodCallExpression callA = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), a);
            MethodCallExpression callB = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), b);

            BlockExpression block = Expression.Block(
                aa,
                bb,
                callA,
                callB
                );

            Expression<Action<int, int>> lambda = Expression.Lambda<Action<int, int>>(block, a, b);
            lambda.Compile()(10, 10);
            Console.ReadKey();

生成的表達式樹如下

.Lambda #Lambda1<System.Action`2[System.Int32,System.Int32]>(
    System.Int32 $a,
    System.Int32 $b) {
    .Block() {
        $a++;
        $b--;
        .Call System.Console.WriteLine($a);
        .Call System.Console.WriteLine($b)
    }
}

為了理解一下 Expression.Block()，可以在這裡學習一下(後面會說到 Block())。

            // int a,b;
            ParameterExpression a = Expression.Parameter(typeof(int), "a");
            ParameterExpression b = Expression.Parameter(typeof(int), "b");
            ParameterExpression c = Expression.Variable(typeof(int), "c");

            BinaryExpression SetA = Expression.Assign(a, c);
            BinaryExpression SetB = Expression.Assign(b, c);
            // a++
            UnaryExpression aa = Expression.PostIncrementAssign(a);

            // b--
            UnaryExpression bb = Expression.PostDecrementAssign(b);

            //Console.WriteLine(a);
            //Console.WriteLine(b);
            MethodCallExpression callA = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), a);
            MethodCallExpression callB = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), b);

            BlockExpression block = Expression.Block(
                new ParameterExpression[] { a, b },
                SetA,
                SetB,
                aa,
                bb,
                callA,
                callB
                );

            Expression<Action<int>> lambda = Expression.Lambda<Action<int>>(block, c);
            lambda.Compile()(10);

            Console.ReadKey();

為什麼這裡要多加一個 c 呢？我們來看看生成的表達式樹

.Lambda #Lambda1<System.Action`1[System.Int32]>(System.Int32 $c) {
    .Block(
        System.Int32 $a,
        System.Int32 $b) {
        $a = $c;
        $b = $c;
        $a++;
        $b--;
        .Call System.Console.WriteLine($a);
        .Call System.Console.WriteLine($b)
    }
}

觀察一下下麵代碼生成的表達式樹

            // int a,b;
            ParameterExpression a = Expression.Parameter(typeof(int), "a");
            ParameterExpression b = Expression.Parameter(typeof(int), "b");

            // a++
            UnaryExpression aa = Expression.PostIncrementAssign(a);

            // b--
            UnaryExpression bb = Expression.PostDecrementAssign(b);

            //Console.WriteLine(a);
            //Console.WriteLine(b);
            MethodCallExpression callA = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), a);
            MethodCallExpression callB = Expression.Call(null, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }), b);

            BlockExpression block = Expression.Block(
                new ParameterExpression[] { a, b },
                aa,
                bb,
                callA,
                callB
                );

            Expression<Action<int, int>> lambda = Expression.Lambda<Action<int, int>>(block, a, b);
            lambda.Compile()(10, 10);
            Console.ReadKey();
.Lambda #Lambda1<System.Action`2[System.Int32,System.Int32]>(
    System.Int32 $a,
    System.Int32 $b) {
    .Block(
        System.Int32 $a,
        System.Int32 $b) {
        $a++;
        $b--;
        .Call System.Console.WriteLine($a);
        .Call System.Console.WriteLine($b)
    }
}

關於前置的自增自減，按照上面示例編寫即可，但是需要註意的是， ++x 和 --x ，是“先運算後增/自減”。

二，關係運算符

==、!=、>、<、>=、<=

C# 中的關係運算符如下

運算符 描述
== 檢查兩個操作數的值是否相等，如果相等則條件為真。
!= 檢查兩個操作數的值是否相等，如果不相等則條件為真。
> 檢查左操作數的值是否大於右操作數的值，如果是則條件為真。
< 檢查左操作數的值是否小於右操作數的值，如果是則條件為真。
>= 檢查左操作數的值是否大於或等於右操作數的值，如果是則條件為真。
<= 檢查左操作數的值是否小於或等於右操作數的值，如果是則條件為真。

== 表示相等比較，如果是值類型和 string 類型，則比較值是否相同；如果是引用類型，則比較引用的地址是否相等。

其它的關係運算符則是僅比較值類型的大小。

實例代碼

            int a = 21;
            int b = 10;
            Console.Write("a == b：");
            Console.WriteLine(a == b);

            Console.Write("a < b ：");
            Console.WriteLine(a < b);


            Console.Write("a > b ：");
            Console.WriteLine(a > b);

            // 改變 a 和 b 的值 
            a = 5;
            b = 20;

            Console.Write("a <= b：");
            Console.WriteLine(a <= b);


            Console.Write("a >= b：");
            Console.WriteLine(b >= a);

            Console.ReadKey();

使用表達式樹實現

            // int a,b;
            ParameterExpression a = Expression.Parameter(typeof(int), "a");
            ParameterExpression b = Expression.Parameter(typeof(int), "b");

            // a = 21,b = 10;
            BinaryExpression setA = Expression.Assign(a, Expression.Constant(21));
            BinaryExpression setB = Expression.Assign(b, Expression.Constant(20));

            // Console.Write("a == b：");
            // Console.WriteLine(a == b);
            MethodCallExpression call1 = Expression.Call(null,
                typeof(Console).GetMethod("Write", new Type[] { typeof(string) }),
                Expression.Constant("a == b："));
            MethodCallExpression call11 = Expression.Call(null,
                typeof(Console).GetMethod("WriteLine", new Type[] { typeof(bool) }),
                Expression.Equal(a, b));

            // Console.Write("a < b ：");
            // Console.WriteLine(a < b);
            MethodCallExpression call2 = Expression.Call(null,
                typeof(Console).GetMethod("Write", new Type[] { typeof(string) }),
                Expression.Constant("a < b ："));
            MethodCallExpression call22 = Expression.Call(null,
                typeof(Console).GetMethod("WriteLine", new Type[] { typeof(bool) }),
                Expression.LessThan(a, b));

            // Console.Write("a > b ：");
            // Console.WriteLine(a > b);
            MethodCallExpression call3 = Expression.Call(null,
                typeof(Console).GetMethod("Write", new Type[] { typeof(string) }),
                Expression.Constant("a > b ："));
            MethodCallExpression call33 = Expression.Call(null,
                typeof(Console).GetMethod("WriteLine", new Type[] { typeof(bool) }),
                Expression.GreaterThan(a, b));


            // 改變 a 和 b 的值 
            // a = 5;
            // b = 20;
            BinaryExpression setAa = Expression.Assign(a, Expression.Constant(5));
            BinaryExpression setBb = Expression.Assign(b, Expression.Constant(20));

            // Console.Write("a <= b：");
            // Console.WriteLine(a <= b);
            MethodCallExpression call4 = Expression.Call(null,
                typeof(Console).GetMethod("Write", new Type[] { typeof(string) }),
                Expression.Constant("a <= b："));
            MethodCallExpression call44 = Expression.Call(null,
                typeof(Console).GetMethod("WriteLine", new Type[] { typeof(bool) }),
                Expression.LessThanOrEqual(a, b));

            // Console.Write("a >= b：");
            // Console.WriteLine(b >= a);
            MethodCallExpression call5 = Expression.Call(null,
                typeof(Console).GetMethod("Write", new Type[] { typeof(string) }),
                Expression.Constant("a >= b："));
            MethodCallExpression call55 = Expression.Call(null,
                typeof(Console).GetMethod("WriteLine", new Type[] { typeof(bool) }),
                Expression.GreaterThanOrEqual(a, b));

            BlockExpression block = Expression.Block(new ParameterExpression[] { a, b },
                setA,
                setB,
                call1,
                call11,
                call2,
                call22,
                call3,
                call33,
                setAa,
                setBb,
                call4,
                call44,
                call5,
                call55
                );

            Expression<Action> lambda = Expression.Lambda<Action>(block);
            lambda.Compile()();
            Console.ReadKey();

生成的表達式樹如下

.Lambda #Lambda1<System.Action>() {
    .Block(
        System.Int32 $a,
        System.Int32 $b) {
        $a = 21;
        $b = 20;
        .Call System.Console.Write("a == b：");
        .Call System.Console.WriteLine($a == $b);
        .Call System.Console.Write("a < b ：");
        .Call System.Console.WriteLine($a < $b);
        .Call System.Console.Write("a > b ：");
        .Call System.Console.WriteLine($a > $b);
        $a = 5;
        $b = 20;
        .Call System.Console.Write("a <= b：");
        .Call System.Console.WriteLine($a <= $b);
        .Call System.Console.Write("a >= b：");
        .Call System.Console.WriteLine($a >= $b)
    }
}

三，邏輯運算符

&&、||、!

運算符 描述
&& 稱為邏輯與運算符。如果兩個操作數都非零，則條件為真。
|| 稱為邏輯或運算符。如果兩個操作數中有任意一個非零，則條件為真。
! 稱為邏輯非運算符。用來逆轉操作數的邏輯狀態。如果條件為真則邏輯非運算符將使其為假。

邏輯運算符的運行，結果是 true 或 false。

邏輯運算符 表達式樹
&& Expression.AndAlso()
|| Expression.OrElse()
！ Expression.Not() 
            int a = 10;
            int b = 11;

            Console.Write("[a == b && a > b]：");
            Console.WriteLine(a == b && a > b);

            Console.Write("[a > b || a == b]：");
            Console.WriteLine(a > b || a == b);

            Console.Write("[!(a == b)]：");
            Console.WriteLine(!(a == b));
            Console.ReadKey();

使用表達式樹編寫

            //int a = 10;
            //int b = 11;
            ParameterExpression a = Expression.Parameter(typeof(int), "a");
            ParameterExpression b = Expression.Parameter(typeof(int), "b");
            BinaryExpression setA = Expression.Assign(a, Expression.Constant(10));
            BinaryExpression setB = Expression.Assign(b, Expression.Constant(11));

            //Console.Write("[a == b && a > b]：");
            //Console.WriteLine(a == b && a > b);
            MethodCallExpression call1 = Expression.Call(null, typeof(Console).GetMethod("Write", new Type[] { typeof(string) }), Expression.Constant("[a == b && a > b]："));

            MethodCallExpression call2 = Expression.Call(
                null,
                typeof(Console).GetMethod("WriteLine", new Type[] { typeof(bool) }),
                 Expression.AndAlso(Expression.Equal(a, b), Expression.GreaterThan(a, b))
                );

            //Console.Write("[a > b || a == b]：");
            //Console.WriteLine(a > b || a == b);
            MethodCallExpression call3 = Expression.Call(null, typeof(Console).GetMethod("Write", new Type[] { typeof(string) }), Expression.Constant("[a > b || a == b]："));
            MethodCallExpression call4 = Expression.Call(
                null,
                typeof(Console).GetMethod("WriteLine", new Type[] { typeof(bool) }),
                Expression.OrElse(Expression.Equal(a, b), Expression.GreaterThan(a, b))
                );

            //Console.Write("[!(a == b)]：");
            //Console.WriteLine(!(a == b));
            MethodCallExpression call5 = Expression.Call(null, typeof(Console).GetMethod("Write", new Type[] { typeof(string) }), Expression.Constant("[!(a == b)]："));
            MethodCallExpression call6 = Expression.Call(
                null,
                typeof(Console).GetMethod("WriteLine", new Type[] { typeof(bool) }),
                Expression.Not(Expression.Equal(a, b))
                );
            BlockExpression block = Expression.Block(
                new ParameterExpression[] { a, b },
                setA,
                setB,
                call1,
                call2,
                call3,
                call4,
                call5,
                call6
                );

            Expression<Action> lambda = Expression.Lambda<Action>(block);
            lambda.Compile()();
            Console.ReadKey();

生成的表達式樹如下

.Lambda #Lambda1<System.Action>() {
    .Block(
        System.Int32 $a,
        System.Int32 $b) {
        $a = 10;
        $b = 11;
        .Call System.Console.Write("[a == b && a > b]：");
        .Call System.Console.WriteLine($a == $b && $a > $b);
        .Call System.Console.Write("[a > b || a == b]：");
        .Call System.Console.WriteLine($a == $b || $a > $b);
        .Call System.Console.Write("[!(a == b)]：");
        .Call System.Console.WriteLine(!($a == $b))
    }
}

四，位運算符

&、|、^、~、<<、>>

運算符 描述 實例
& 如果同時存在於兩個操作數中，二進位 AND 運算符複製一位到結果中。 (A & B) 將得到 12，即為 0000 1100
| 如果存在於任一操作數中，二進位 OR 運算符複製一位到結果中。 (A | B) 將得到 61，即為 0011 1101
^ 如果存在於其中一個操作數中但不同時存在於兩個操作數中，二進位異或運算符複製一位到結果中。 (A ^ B) 將得到 49，即為 0011 0001
~ 按位取反運算符是一元運算符，具有"翻轉"位效果，即0變成1，1變成0，包括符號位。 (~A ) 將得到 -61，即為 1100 0011，一個有符號二進位數的補碼形式。
<< 二進位左移運算符。左操作數的值向左移動右操作數指定的位數。 A << 2 將得到 240，即為 1111 0000
>> 二進位右移運算符。左操作數的值向右移動右操作數指定的位數。 A >> 2 將得到 15，即為 0000 1111

限於篇幅，就寫示例了。

位運算符 表達式樹
& Expression.Add(Expression left, Expression right)
| Expression.Or(Expression left, Expression right)
^ Expression.ExclusiveOr(Expression expression)
~ Expression.OnesComplement( Expression expression)
<< Expression.LeftShift(Expression left, Expression right)
>> Expression.RightShift(Expression left, Expression right)

五，賦值運算符

運算符 描述 實例
= 簡單的賦值運算符，把右邊操作數的值賦給左邊操作數 C = A + B 將把 A + B 的值賦給 C
+= 加且賦值運算符，把右邊操作數加上左邊操作數的結果賦值給左邊操作數 C += A 相當於 C = C + A
-= 減且賦值運算符，把左邊操作數減去右邊操作數的結果賦值給左邊操作數 C -= A 相當於 C = C - A
*= 乘且賦值運算符，把右邊操作數乘以左邊操作數的結果賦值給左邊操作數 C = A 相當於 C = C A
/= 除且賦值運算符，把左邊操作數除以右邊操作數的結果賦值給左邊操作數 C /= A 相當於 C = C / A
%= 求模且賦值運算符，求兩個操作數的模賦值給左邊操作數 C %= A 相當於 C = C % A
<<= 左移且賦值運算符 C <<= 2 等同於 C = C << 2
>>= 右移且賦值運算符 C >>= 2 等同於 C = C >> 2
&= 按位與且賦值運算符 C &= 2 等同於 C = C & 2
^= 按位異或且賦值運算符 C ^= 2 等同於 C = C ^ 2
|= 按位或且賦值運算符 C |= 2 等同於 C = C | 2

限於篇幅,請自行領略... ...

運算符 表達式樹
= Expression.Assign
+= Expression.AddAssign
-= Expression.SubtractAssign
*= Expression.MultiplyAssign
/= Expression.DivideAssign
%= Expression.ModuloAssign
<<= Expression.LeftShiftAssign
>>= Expression.RightShiftAssign
&= Expression.AndAssign
^= Expression.ExclusiveOrAssign
|= Expression.OrAssign

^= ，註意有兩種意思一種是位運算符的異或(ExclusiveOrAssign)，一種是算術運算符的冪運算(PowerAssign)。

六，其他運算符

運算符 描述 實例
sizeof() 返回數據類型的大小。 sizeof(int)，將返回 4.
typeof() 返回 class 的類型。 typeof(StreamReader);
& 返回變數的地址。 &a; 將得到變數的實際地址。
* 變數的指針。 *a; 將指向一個變數。
? : 條件表達式 如果條件為真 ? 則為 X : 否則為 Y
is 判斷對象是否為某一類型。 If( Ford is Car) // 檢查 Ford 是否是 Car 類的一個對象。
as 強制轉換，即使轉換失敗也不會拋出異常。 Object obj = new StringReader("Hello"); StringReader r = obj as StringReader;

表達式樹裡面我沒有找到這些運算符的如何編寫，如果你找到了，歡迎告訴我。。。


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

-Advertisement-
Play Games
更多相關文章
  • SpringCloud（四）Hystrix熔斷器
    前面已經學習了服務註冊與發現組件，負載均衡組件，這樣我們的微服務系統已經可以使用了。為了保證其高可用，單個服務通常會集群部署。由於網路原因或者自身的原因，服務並不能保證 100% 可用，如果單個服務出現問題，調用這個服務就會出現線程阻塞，此時若有大量的請求涌入，Servlet 容器的線程資源會被消耗 ...
  • 【Rocketmq】通過 docker 快速搭建 rocketmq 環境
    1. 安裝 Namesrv 拉取鏡像 docker pull rocketmqinc/rocketmq:4.4.0` docker run d p 9876:9876 v {RmHome}/data/namesrv/logs:/root/logs v {RmHome}/data/namesrv/st ...
  • redis 的過期策略都有哪些？記憶體淘汰機制都有哪些？手寫一下 LRU 代碼實現？
    面試題 redis 的過期策略都有哪些？記憶體淘汰機制都有哪些？手寫一下 LRU 代碼實現？ 面試官心理分析 如果你連這個問題都不知道，上來就懵了，回答不出來，那線上你寫代碼的時候，想當然的認為寫進 redis 的數據就一定會存在，後面導致系統各種 bug，誰來負責？ 常見的有兩個問題： 往 redi ...
  • IntelliJ IDEA搭建Spring Boot 2 項目入門
    之前都是用Eclipse，今天試了下IntelliJ IDEA，搭建了一個Spring Boot 2的Hello world項目。 ...
  • Python基礎---控制執行流程
    一.if語句 1.if語句 作用:讓程式根據條件選擇性地執行某條語句或某些語句 說明:if語句又叫條件語句,也叫分支語句 語法: 語法說明: elif子句可以有0個,1個或多個 else子句可以有0個或1個且只能放在此if語句的最後 要求:if語句內部的語句通常要以4個空格的縮進來表示包含關係,相同 ...
  • laravel中利用迴圈實現隔行換色
    1.首先在你的路由文件定義好訪問的路徑 2. ...
  • 開源日誌框架Exceptionless使用教程
    Exceptionless是一款日誌記錄框架，它開源、免費、提供管理界面、易於安裝和使用。ExceptionLess底層採用ElasticSearch作為日誌存儲，提供了快速、豐富的查詢API，方便我們進行系統集成。本文將介紹ExceptionLess的常見用法。 安裝ExceptionLess 在 ...
  • C#伺服器全面講解與製作
    C#伺服器全面講解與製作一 環境配置與基礎架構 環境配置 基礎的伺服器架構 環境配置 基礎的伺服器架構 這裡我會講解高級的C#伺服器的全面製作流程 會對大家有很大的幫助 不過在這個教程中主要是講解伺服器的製作，所以不會講解客戶端的製作，不過會提供相關客戶端的代碼。 1 環境配置 1.1 VS cod ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 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 ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類