kb88凯时官网登录-d88尊龙官网手机app > 编程开发 > c类语言

c#五类运算符使用表达式树进行操作-kb88凯时官网登录

来自：网络
时间：2023-01-01
阅读：
免费资源网 - https://freexyz.cn/

在 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> lambda = expression.lambda>(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 lambda = expression.lambda(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> lambda = expression.lambda>(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> lambda = expression.lambda>(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> lambda = expression.lambda>(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()后置
xexpression.preincrementassign()前置
--xexpression.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 lambda = expression.lambda(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> lambda = expression.lambda>(block, a, b);
            lambda.compile()(10, 10);
            console.readkey();

生成的表达式树如下

.lambda #lambda1(
    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> lambda = expression.lambda>(block, c);
            lambda.compile()(10);
            console.readkey();

为什么这里要多加一个 c 呢？我们来看看生成的表达式树

.lambda #lambda1(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> lambda = expression.lambda>(block, a, b);
            lambda.compile()(10, 10);
            console.readkey();
.lambda #lambda1(
    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 lambda = expression.lambda(block);
            lambda.compile()();
            console.readkey();

生成的表达式树如下

.lambda #lambda1() {
    .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 lambda = expression.lambda(block);
            lambda.compile()();
            console.readkey();

生成的表达式树如下

.lambda #lambda1() {
    .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;

到此这篇关于c#五类运算符使用表达式树进行操作的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持。

免费资源网 - https://freexyz.cn/

opencv通过透视变换实现矫正图像详解

目录



1、概述


2、代码演示


3、示例图片






1、概述


案例：使用opencv将一张折射的图片给矫正过来


实现步骤：


1.载入图像


2.图像灰度化

2023-02-21 21:37:50

.net core以windows服务方式部署

前言netcore用了这么久，虽然多数都是部署在centos系统，但也有部署在windows上的情况。最省力的部署方式是发布后直接在发布目录打开cmd，运行dotnet命令。虽然很省力，但是保留一

2023-01-01 18:00:07

c#循环与循环控制的表达式树实现

c# 提供了以下几种循环类型。循环类型描述while 循环当给定条件为真时，重复语句或语句组。它会在执行循环主体之前测试条件。for/foreach 循环多次执行一个语句序列，简化管理

2023-01-01 18:00:05

c#实现单位换算器

本文实例为大家分享了c#实现单位换算器的具体代码，供大家参考，具体内容如下一、阐述进制间转换：十六进制、十进制、八进制、二进制。
长度间转换：毫米、厘米、米、公里、英寸、

2023-01-01 18:00:03

c#中逆变的实际应用场景详解

目录前言协变的应用场景逆变的应用场景讨论总结前言早期在学习泛型的协变与逆变时，网上的文章讲解、例子算是能看懂，但关于逆变的具体应用场景这方面的知识，我并没有深刻的认识

2023-01-01 17:59:57

详解c#如何实现读写ini文件

目录介绍1.创建一个ini文件2.创建一个winform界面3.添加一个ini管理类4.添加winform代码介绍ini文件格式由节、键、值组成。节[section]参数（键=值）name=value1.创建一个ini文

2023-01-01 17:59:52

c#中的out参数、ref参数和params可变参数用法介绍

out参数：out关键字 通过引用来传递参数，在定义方法和调用方法的时候都必须使用out关键字简单来讲out可以用来返回多个参数类型。 static void main(string[] args)

2023-01-01 17:59:48

c#值类型、引用类型、泛型、集合、调用函数的表达式树实践

目录一，定义变量二，访问变量/类型的属性字段和方法1. 访问属性调用静态类型属性调用实例属性/字段2. 调用函数调用静态类型的函数调用实例的函数三，实例化引用类型new给属性赋

2023-01-01 17:59:40

c#实现温度转换功能

本文实例为大家分享了c#实现温度转换功能的具体代码，供大家参考，具体内容如下界面图代码using system;using system.collections.generic;using system.componentmodel;using

2023-01-01 17:59:38

c#实现在pdf文档中应用多种不同字体

目录引入dll应用字体c#vb.net绘制效果引入dll 本次程序中引入的是spire.pdf.dll，引入方法如下：【方法1】通过nuget安装。可以在visual studio中打开“kb88凯时官网登录的解决方案资源管理器

2023-01-01 17:59:32

c#操作sqlite实现数据的增删改查

目录简介主要代码sqlitehelper.csusinglock.csform1.cs简介sqlite是一个轻量级、跨平台的关系型数据库，在小型项目中，方便，易用，同时支持多种开发语言，下面是我用c#语言对sqlite

2023-01-01 17:59:30

c#算法之整数反转

题目给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。示例 1:输入: 123输出: 321 示例 2:输入: -123输出: -321示例 3:输入: 120输出: 21注意:假设我们

2023-01-01 17:59:26

c#数据类型转换(显式转型、隐式转型、强制转型)

c# 的类型转换有显式转型 和 隐式转型 两种方式。显式转型：有可能引发异常、精确度丢失及其他问题的转换方式。需要使用手段进行转换操作。隐式转型：不会改变原有数据精确度、

2023-01-01 17:59:24

c#算法之回文数

回文数判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。示例 1:输入: 121输出: true示例 2:输入: -121输出: false解释: 从左向右读, 为

2023-01-01 17:59:21

c#表达式树基础教程

什么是表达式树来自微软官方文档的定义：表达式树以树形数据结构表示代码。它能干什么呢？你可以对表达式树中的代码进行编辑和运算。 这样能够动态修改可执行代码、在不同数据

2023-01-01 17:59:19

wcf基础介绍并创建简单应用程序

什么是wcf？wcf, 英文全称(windows communication foundation) , 即为windows通讯平台。windows想到这里大家都知道了 , wcf也正是由微软公司推出的这个一个玩意, 基于soa的一

2023-01-01 17:59:10

c#跨平台开发之使用c/c 生成的动态链接库

操作环境：visual studio 2017如何实现 使用 c# 进行嵌入式开发？.net core 虽然实现了跨平台，但是不可能处处使用 c# 开发，就好像没人使用sql开发安卓app，每种语言都有其优秀的地

2023-01-01 17:59:05

c#五类运算符使用表达式树进行操作

在 c# 中，算术运算符，有以下类型算术运算符关系运算符逻辑运算符位运算符赋值运算符其他运算符这些运算符根据参数的多少，可以分作一元运算符、二元运算符、三元运算符。本文将

2023-01-01 17:58:58

c#通过标签软件bartender的zpl命令打印条码

注:由于工作需要, 也是第一次接触到打印机的相关内容, 凑巧, 通过找了很多资料和帮助后, 也顺利的解决了打印标签的问题(标签的表面信息[二维码,条形码, 文字] 和 rfid标签

2023-01-01 17:58:49

c#基于sockets类实现tcp通讯

本文实例为大家分享了c#基于sockets类实现tcp通讯的具体代码，供大家参考，具体内容如下最终效果tcpclientusing system;using system.collections.generic;using system.compon

2023-01-01 17:58:43

为xamarin.forms的导航栏增加搜索功能

在使用navigationpage导航的时候, 我们可以给里面添加一些功能按钮, 如下所示:

2023-01-01 17:58:38

c#中间语言及ildasm工具用法

当我们编译 .net 应用程序时会发生什么？当我们编译任何 .net 应用程序时，它将生成一个程序集，该扩展项可以是 。dll 或 。exe。例如，如果编译窗口或控制台应用程序，则将得到 .exe

2023-01-01 17:58:35

c#创建控制windows服务

需求针对一种特殊的应用, 不需要显示gui, 希望常驻在windows服务当中,在必要的时候我们可以进行启动或开机启动。这个时候我们就可以创建windowsservice 来实现。创建window

2023-01-01 17:58:31

c#实现mqtt服务端与客户端通讯功能

关于mqttmqtt(消息队列遥测传输)是iso 标准(iso/iec prf 20922)下基于发布/订阅范式的消息协议。它工作在 tcp/ip协议族上，是为硬件性能低下的远程设备以及网络状况糟糕的情

2023-01-01 17:58:26

c#异步编程async/await用法详解

异步函数简介一般指 async 修饰符声明得、可包含await表达式得方法或匿名函数。声明方式异步方法的声明语法与其他方法完全一样, 只是需要包含 async 关键字。async可以出现

2023-01-01 17:58:24

unity ugui 按钮绑定事件的 4 种方式汇总

ugui 可视化创建以及关联事件很方便, 动态创建可以利用创建好的 prefab 进行实例化, 只是在关联事件上有些复杂, 本文总结了几种给按钮绑定事件的关联方式.1. 可视化创建及

2023-01-01 17:58:21

关于c#中gui编程的标准事件问题

前言昨天的文章，带大家简单学习c#中的事件，了解订阅者和发布者之间的逻辑关联，也通过小案例进行实际操作，可以看到具体的输出结果。目前在工作中，使用winform桌面开发比较多，很多

2023-01-01 17:58:16

c#基于serialport类实现串口通讯详解

本文实例为大家分享了c#基于serialport类实现串口通讯的具体代码，供大家参考，具体内容如下最终效果窗体设置：using system;using system.collections.generic;using system.com

2023-01-01 17:58:13

c#实现贪吃蛇小游戏

本文实例为大家分享了c#实现贪吃蛇小游戏的具体代码，供大家参考，具体内容如下之前一直想写一个贪吃蛇小游戏，上个周末终于有时间做了一个，现在和大家分享。界面界面比较简单，一个

2023-01-01 17:58:12

c#接口inotifypropertychanged使用方法

inotifypropertychanged:该接口包含一个事件, 针对属性发生变更时, 执行该事件发生。 // // 摘要: // 通知客户端属性值已更改。 public interface inotify

2023-01-01 17:58:03

热点内容

c语言实现520表白代码 祝你表白成功!
2021-06-03
c语言中fun用法详解
2020-05-31
qt图形图像开发之高性能曲线图模块qcustomplot库详细使用方法与实例(支持动、静曲线图
2020-05-26
c语言实战之浪漫烟花表白程序代码
2021-04-24
vs code c/c 环境配置教程(无法打开源文件“xxxxxx.h”或者检测到 #include 错误,请
2020-11-01
vs2019配置opencv时找不到microsoft.cpp.x64.user的解决方法
2020-05-26
vs2019如何添加头文件路径的方法步骤
2020-11-01
c语言实现放烟花的程序
2021-02-22
c语言如何用if判断成绩等级？
2020-06-19
qt串口通信开发之qserialport模块简单使用方法与实例
2020-05-26
返回顶部
顶部
网站地图