表达式树练习实践：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; |
表达式树里面我没有找到这些运算符的如何编写，如果你找到了，欢迎告诉我。。。
表达式树练习实践：C# 五类运算符的表达式树表达的更多相关文章
- 表达式树练习实践：C#判断语句
目录 表达式树练习实践:C#判断语句 if if...else switch ?? 和 ?: 表达式树练习实践:C#判断语句 判断语句 C# 提供了以下类型的判断语句: 语句 描述 if 一个 if ...
- javascript运算符与表达式
表达式 表达式是关键字.运算符.变量以及文字的组合,用来生成字符串.数字或对象.一个表达式可以完成计算.处理字符.调用函数.或者验证数据等操作. 表达式的值是表达式运算的结果,常量表达式的值就是常量本 ...
- C语言---程序的一般形式、数据类型、常量变量、运算符、表达式、格式化输入输出
1. 程序的一般形式 (1)注释 ① 分类:单行注释( // ): 注释一行.多行注释( /**/ ): 在这个区间内,都属于多行注释,可以换行. ② 作用:提示代码的作用,提示思路 不写注释的后 ...
- 第十五节：Expression表达式目录树(与委托的区别、自行拼接、总结几类实例间的拷贝)
一. 基本介绍 回忆: 最早接触到表达式目录树(Expression)可能要追溯到几年前使用EF早期的时候,发现where方法里的参数是Expression<Func<T,bool> ...
- 表达式树练习实践：C#值类型、引用类型、泛型、集合、调用函数
目录 表达式树练习实践:C#值类型.引用类型.泛型.集合.调用函数 一,定义变量 二,访问变量/类型的属性字段和方法 1. 访问属性 2. 调用函数 三,实例化引用类型 四,实例化泛型类型于调用 五, ...
- 表达式树练习实践：C# 循环与循环控制
目录 表达式树练习实践:C# 循环 LabelTarget for / while 循环 无限循环 最简单的循环 多次循环 break 和 continue 一起 表达式树练习实践:C# 循环 C# ...
- 01-Java基础知识：数据类型与变量、标识符、运算符、表达式
Java基础知识:数据类型与变量.标识符.运算符.表达式 一.数据类型 Java定义了基本数据类型.引用数据类型.自定义类型. 八种基本数据类型:byte (1). short (2). int ( ...
- java与.net比较学习系列(4) 运算符和表达式
上一篇总结了java的数据类型,得到了冰麟轻武等兄弟的支持,他们提出并补充了非常好的建议,在这里向他们表示感谢.在后面的文章中,我会尽力写得更准确和更完善的,加油! 另外,因为C#是在java之后,也 ...
- Python第二天 变量 运算符与表达式 input()与raw_input()区别 字符编码 python转义符 字符串格式化 format函数字符串格式化 帮助
Python第二天 变量 运算符与表达式 input()与raw_input()区别 字符编码 python转义符 字符串格式化 format函数字符串格式化 帮助 目录 Pychar ...
随机推荐
- windows查看端口被占用
1.打开控制台终端 2.在命令行下输入netstat -ano|findstr "8080"(8080是被占用的端口) 3.记住最后一列的数字PID如4684 4.输入taskli ...
- html5新特性-header,nav,footer,aside,article,section等各元素的详解
Html5新增了27个元素,废弃了16个元素,根据现有的标准规范,把HTML5的元素按优先级定义为结构性属性.级块性元素.行内语义性元素和交互性元素四大类. 下面是对各标签的详解,section.he ...
- 如何彻底禁用 werfalut.exe
在程序中调用 控制台程序 的时候,一旦出现控制台出现 crash 往往会弹出 werfault 窗口, 这样往往会锁死线程,导致程序无法继续运行. 那如何禁止 werfault 窗口的弹出呢? 在 s ...
- Oracle中的转换函数
Oracle中的转换函数有三个,分别为to_char(),to_date(),to_number() 1.to_char()的用法 格式化当前的日期时间 select sysdate,to_char( ...
- Python模块之requests,urllib和re
目录 一.爬虫的步骤 二.使用Jupyter 三.爬虫请求模块之urllib 四.爬虫请求模块之requests 五.爬虫分析之re模块 一.爬虫的步骤 1.发起请求,模拟浏览器发送一个http请求 ...
- idea打包失败时，强行打包
set target_jar="E:\handSight\fras\Jars" cd Jars del fras-.jar rem 拉取最新代码 call git pull ech ...
- Flink的Job启动Driver端(源码分析)
整个Flink的Job启动是通过在Driver端通过用户的Envirement的execute()方法将用户的算子转化成StreamGraph,然后得到JobGraph通过远程RPC将这个JobGra ...
- 《Tomcat和JVM的性能调优你真的学会了吗？》总结篇
Tomcat性能调优: 找到Tomcat根目录下的conf目录,修改server.xml文件的内容.对于这部分的调优,我所了解到的就是无非设置一下Tomcat服务器的最大并发数和Tomcat初始化时创 ...
- docker An error occurred 虚拟化错误解决
问题: 本人电脑上装了VMware和docker,系统是win10专业版,然后今天想用下docker,打开报错,Hyper-V未开启,开启之后再次报错 An error occurred Hardwa ...
- lua_基本语法
学习lua,首先应该了解热更新. 热更新:可以在不重新下载客户端的情况下更新软件内容.在使用软件过程中,我们经常会遇到这种情况:升级软件,没错,这就使用的是热更新. C#不能直接热更新,原因为:C#脚 ...