精华内容
下载资源
问答
  • C# 表达式绘图控件

    2010-06-21 16:02:19
    C# 表达式绘图控件C# 表达式绘图控件C# 表达式绘图控件C# 表达式绘图控件C# 表达式绘图控件C# 表达式绘图控件
  • C#表达式

    2009-11-18 09:38:00
    C#语言中的表达式类似于数学运算中的表达式,是操作符、操作对象和标点符号等连接而成的句子。操作符是用来定义类实例中表达式操作符的。表达式是指定计算的操作符、操作符序列。1. 操作符1.1. 操作符的分类表达式...

           C#语言中的表达式类似于数学运算中的表达式,是操作符、操作对象和标点符号等连接而成的句子。操作符是用来定义类实例中表达式操作符的。表达式是指定计算的操作符、操作符序列。

    1.      操作符

    1.1.   操作符的分类

    表达式由操作数和操作符组成。表达式的操作符指出了对操作数的操作。比如:操作符有+-*/new;操作数可以是文字、域、当前变量或表达式。

    C#中有三种类型的操作符:

    Ø        一元操作符

    Ø        二元操作符

    Ø        三元操作符

    2.      算术操作符和算术表达式

    C#中提供的算术操作符有五种:

    Ø        + 加号

    Ø        - 减号

    Ø        * 乘法

    Ø        / 除法

    Ø        % 求余

    3.      赋值操作符和赋值表达式

    C#中提供的赋值表达式有:= += -= /= &= /= ^= <<= >>=

    4.      关系操作符和关系表达式

    C#中定义的比较操作符有:

    Ø        = 等于

    Ø        != 不等于

    Ø        < 小于

    Ø        > 大于

    Ø        <= 小于或等于

    Ø        >= 大于或等于

    Ø        is 动态检查运行时对象类型是否和给定的类型兼容,如:

    class Program

        {

            static void Main(string[] args)

            {

                Console.WriteLine(1 is int);

                Console.WriteLine(1 is float);

                Console.WriteLine(1.0f is float);

                Console.WriteLine(1.0 is double);

                Console.ReadLine();

            }

    }

     

    运行结果:

    True

    False

    True

    True

    Ø        as操作符 as操作符用于通过引用转换或装箱将一个值显式地转换成指定的引用类型。不像显式类型转换,as不会产生任何异常。如果转换不可以进行,那么结果为null

    5.      逻辑操作符和逻辑表达式

    5.1.   逻辑操作符

    C#语言提供了三种逻辑操作符:

    Ø        && 逻辑与

    Ø        || 逻辑或

    Ø        ! 逻辑非

    6.      其它特殊操作符

    6.1.   三元操作符

    6.2.   自增和自减操作符

    6.3.   new操作符

    new操作符用于创建一个新的类型实例。它有三种形式:

    Ø        对象创建表达式,用于创建一个类类型或值类型的实例。

    Ø        数组创建表达式,用于创建一人数组类型实例。

    Ø        代表创建表达式,用于创建一个新的代表类型。

    6.4.   typeof操作符

    typeof操作符用于获得系统原型对象的类型。如:

    class Program

        {

            static void Main(string[] args)

            {

                Console.WriteLine(typeof(int));

                Console.WriteLine(typeof(System.Int32));

                Console.WriteLine(typeof(string));

                Console.WriteLine(typeof(double[]));

                Console.ReadLine();

            }

    }

     

    运行结果:

    System.Int32

    System.Int32

    System.String

    System.Double[]

    6.5.   checkedunchecked操作符

    checkedunchecked操作符用于整型算术运算时控制当前环境中的溢出检查。下列运算参与了checkedunchecked

    Ø        预定义的++--  一元运算符,当其操作类型为整型时

    Ø        预定义的-  一元运算符,当其操作数为整型数时

    Ø        预定义的+-*/等二元操作符,当两个操作数数据类型都是整型

    Ø        从一种整型到另一种整型地显式数据转换

     

    展开全文
  • 下面小编就为大家分享一篇C# 表达式目录树的应用详解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • C#表达式树教程

    2011-09-28 08:56:17
    C# 表达式树教程,阐释表达式树的原理,结合lambda表达式讲解
  • C#表达式

    千次阅读 2018-04-19 22:38:03
    C#表达式树 表达式和表达式树 表达式可以是一个参数(如参数x),一个常数(如常数5),一个加运算(如x+5)等等,可以把几个小的表达式组装在一起成为大的表达式,例如:(x+5)-(++y)。对于这样一个表达式可以用一...

    C#表达式树


     

    表达式和表达式树

    表达式可以是一个参数(如参数x),一个常数(如常数5),一个加运算(如x+5)等等,可以把几个小的表达式组装在一起成为大的表达式,例如:(x+5)-(++y)。对于这样一个表达式可以用一棵树来表示,如下:

    这就是表达式树,表达式树本身也是一个表达式(大的表达式)。一个表达式也是一棵表达式树,可以说它是一棵小的表达式树。可以把表达式树和表达式认为是一个东西,C#中都用Expression类表示。

     

    表达式树结构

    对于一棵表达式树,其叶子节点都是参数或者常数,非叶子节点都是运算符或者控制符。

    C#中的Expression类就是表达式类,在C#中表达式树的节点总共有85种,这些类型全部由枚举变量ExpressionType决定。Expression类成员变量NodeType记录了表达式树根节点的节点类型。表达式树还有一个值类型,由Expression类成员变量Type决定。例如表达式(x+5)-(++y) NodeType为ExpressionType.Subtract(减),Type为typeof(int)。

     

    表达式树的创建

    Lambda表达式方法

    表达式可以通过Lambda表示创建Expression<TDelegate>类型,如下:

    Expression<Func<int, int,bool>> fun = (x, y) => x < y

    这种方法创建出的表达式根节点类型为ExpressionType.Lambda,Type类型为返回值类型typeof(bool)。

    这里的表达式根节点类型为Lambda并不是LessThan(小于)。Expression<TDelegate>有一个成员变量Body,这个成员变量是“lambda表达式的式子”,在例子中fun.Body为x<y,fun.Body的节点类型为LessThan,这里的x<y只是fun的一棵子树。

     

    组装法

    另一种创建表示的方式是通过Expression类的静态函数“组装”表达式如下:

     ParameterExpression p1 = Expression.Parameter(typeof(int),"x");

     ParameterExpression p2 = Expression.Parameter(typeof(int),"y");

      BinaryExpression expr =Expression.GreaterThan(p1, p2);

    我们先创建了两个参数表达式x, y然后用GreaterThan组装在一起,最终的表达式为“x>y”,expr的节点类型为GreaterThan,Type类型为typeof(bool)

    Expression类中有我们所需要所有“组装”表达式的用的静态函数,我们不能直接用new的方法去创建表达式节点,表达式所有的节点需要用Expression类中的静态函数创建。

    更多关于如何创建表示请参考:

    http://www.cnblogs.com/jesse2013/p/expressiontree-part1.html

    http://www.cnblogs.com/jesse2013/p/expressiontree-part2.html

     

    节点类与节点类型

    从创建表达式可以发现表达式不同类型节点会对应不同的类,如ParameterExpression,BinaryExpression,Expression<TDelegate>等等,这些类都继承了Expression类,所以它们都表示表达式,只是他们的根节点的节点类型不一样。

    表达式节点类和表达式类型是有一定对应关系的,下面有一部分总结但不完整。

    类型

    类名

    可对应的节点类型

    常量表达式

    ConstantExpression

    ExpressionType.Constant

    参数表达式

    ParameterExpression

    ExpressionType.Parameter

    一元运算符表达式

    UnaryExpression

    ExpressionType.Negate

    ExpressionType.NegateChecked

    ExpressionType.Not

    ExpressionType.Convert

    ExpressionType.ConvertChecked

    ExpressionType.ArrayLength

    ExpressionType.Quote

    ExpressionType.TypeAs

    二元运算符表达式

    BinaryExpression

    ExpressionType.Add

    ExpressionType.AddChecked

    ExpressionType.Subtract

    ExpressionType.SubtractChecked

    ExpressionType.Multiply

    ExpressionType.MultiplyChecked

    ExpressionType.Divide

    ExpressionType.Modulo

    ExpressionType.And

    ExpressionType.AndAlso

    ExpressionType.Or

    ExpressionType.OrElse

    ExpressionType.LessThan

    ExpressionType.LessThanOrEqual

    ExpressionType.GreaterThan

    ExpressionType.GreaterThanOrEqual

    ExpressionType.Equal

    ExpressionType.NotEqual

    ExpressionType.Coalesce

    ExpressionType.ArrayIndex

    ExpressionType.RightShift

    ExpressionType.LeftShift

    ExpressionType.ExclusiveOr

    is运算符表达式

    TypeBinaryExpression

    ExpressionType.TypeIs

    条件表达式

    ConditionalExpression

    ExpressionType.Conditional

    访问字段或属性表达式

    MemberExpression

    ExpressionType.MemberAccess

    调用成员函数表达式

    MethodCallExpression

    ExpressionType.Call

    Lambda表达式

    LambdaExpression

    ExpressionType.Lambda

    委托表达式

    Expression<TDelegate>

    ExpressionType.Lambda

    new运算符表达式

    NewExpression

    ExpressionType.New

    new数组表达式

    NewArrayExpression

    ExpressionType.NewArrayInit

    ExpressionType.NewArrayBounds

    调用其他表达式的表达式

    InvocationExpression

    ExpressionType.Invoke

    属性初始表达式

    MemberInitExpression

    ExpressionType.MemberInit

    列表初始表达式

    ListInitExpression

    ExpressionType.ListInit

     

    表达式的运行

    实际上大多数表达式都不能运行,只有LambdaExpression和Expression<TDelegate>表达式可以运行,因为这两种表达式相当于一个函数。

    这两种表达式有一个成员函数Compile,可把表达式转换成一个Fun或Action函数对象。如下:

                Expression<Func<int,int>> Fun = x => x + 6;

                var f = Fun.Compile();

                f(5);

    其他类型表达式如果想要运行,我们可以通过Expression类的静态函数Lambda<TDelegate>转换成相应的Expression<TDelegate>节点,然后运行。如下运行我们自己组装的表达式:

      ParameterExpression p1 = Expression.Parameter(typeof(int), "x");

      ParameterExpression p2 = Expression.Parameter(typeof(int), "y");

      BinaryExpression expr = Expression.GreaterThan(p1, p2);

      Expression<Func<int, int, bool>> FunGreater =

     Expression.Lambda<Func<int, int, bool>>(expr, p1, p2);

      Console.WriteLine(FunGreater.ToString());

      Console.WriteLine(FunGreater.Compile().Invoke(5, 2));

     

    遍历表达式树

    表达式树是一棵树,我们可以遍历这棵树,在遍历的时候我们可以替换掉原来表达式中的参数、操作、常数来构建一颗新的表达式树。

     

    遍历表达式树

    可以通过ExpressionVisitor类来遍历一棵表达式树。我们需要重写ExpressionVisitor类的一些函数来达到我们的目的如重写Expression VisitParameter(ParameterExpressionnode)函数,这个函数是当遍历到参数节点时调用。node参数是表达式中的参数,而我们的返回值将会替换当前的表达式中的参数。

     遍历顺序

    遍历的顺序可以由代码控制,可以是先遍历根节点再遍历子树,或者先遍历子树后遍历根节点,然后从左到右遍历子树。

     

    以下创建了一个先序遍历的类,即先遍历根节点,然后从左到右遍历子树。

        internal class ExpVisitor : ExpressionVisitor
        {
            protected override Expression VisitBinary(BinaryExpression node)
            {
                Console.WriteLine($"Binary Type = {node.NodeType}");
                return base.VisitBinary(node);//继续遍历节点的子树
            }
    
            protected override Expression VisitConstant(ConstantExpression node)
            {
                Console.WriteLine($"Constant = {node.Value}");
                return node;//因为是叶子节点,所以可以直接返回
            }
    
            protected override Expression VisitParameter(ParameterExpression p)
            {
                Console.WriteLine($"ParamName = {p.Name}");
                return p;//因为是叶子节点,所以可以直接返回
            }
        }

    利用上面的遍历类遍历表达式 (x <10 && x<3) || (y >= z)

    遍历的结果如下:

     

    替换参数

    以下是一个替换参数的遍历类

        internal class ExpressionParameterReplacer : ExpressionVisitor
        {
            public ExpressionParameterReplacer()
            {
                var newParam = Expression.Parameter(typeof(int), "NewParam");
                this.ParameterExpression = newParam;
            }
    
            public ParameterExpression ParameterExpression { get; private set; }
    
            public Expression Replace(Expression expression)
            {
                return this.Visit(expression);
            }
    
            protected override Expression VisitParameter(ParameterExpression _)
            {
                return this.ParameterExpression;
            }
        }
    

     

    使用该类替换表达式(x <10 && x<3) || (y >= z)中所有的参数,然后遍历输出,替换后生成的表达式为(NewParam < 10&& NewParam <3)|| (NewParam >= NewParam),三个参数都变成了NewParam。

     

    结果如下:

      

    两个例子完整的代码如下:

        internal class ExpressionParameterReplacer : ExpressionVisitor
        {
            public ExpressionParameterReplacer()
            {
                var newParam = Expression.Parameter(typeof(int), "NewParam");
                this.ParameterExpression = newParam;
            }
    
            public ParameterExpression ParameterExpression { get; private set; }
    
            public Expression Replace(Expression expression)
            {
                return this.Visit(expression);
            }
    
            protected override Expression VisitParameter(ParameterExpression _)
            {
                return this.ParameterExpression;
            }
        }
        internal class ExpVisitor : ExpressionVisitor
        {
            protected override Expression VisitBinary(BinaryExpression node)
            {
                Console.WriteLine($"Binary Type = {node.NodeType}");
                return base.VisitBinary(node);//继续遍历节点的子树
            }
    
            protected override Expression VisitConstant(ConstantExpression node)
            {
                Console.WriteLine($"Constant = {node.Value}");
                return node;//因为是叶子节点,所以可以直接返回
            }
    
            protected override Expression VisitParameter(ParameterExpression p)
            {
                Console.WriteLine($"ParamName = {p.Name}");
                return p;//因为是叶子节点,所以可以直接返回
            }
        }
    
        class Program
        {
            static void Main(string[] args)
            {
                Console.WriteLine($"Visiter Tree:");
                Expression<Func<int, int, int, bool>> FunX1 = (x, y, z) => (x < 10 && x>3) || (y >= z);
                Console.WriteLine(FunX1.Body.ToString());
                ExpVisitor v2 = new ExpVisitor();
                v2.Visit(FunX1.Body);
    
                Console.WriteLine($"\n\nReplace Param:");
                ExpressionParameterReplacer v = new ExpressionParameterReplacer();
                var temp = v.Visit(FunX1.Body);
                Console.WriteLine(temp.ToString());
                v2.Visit(temp);
    
                Expression<Func<int, bool>> ReplaceExp = Expression.Lambda<Func<int, bool>>(temp, v.ParameterExpression);
                ReplaceExp.Compile().Invoke(5);
    
                Console.WriteLine($"\n\n");
                ParameterExpression p1 = Expression.Parameter(typeof(int), "x");
                ParameterExpression p2 = Expression.Parameter(typeof(int), "y");
                BinaryExpression expr = Expression.GreaterThan(p1, p2);
                Expression<Func<int, int, bool>> FunGreater = Expression.Lambda<Func<int, int, bool>>(expr, p1, p2);
                Console.WriteLine(FunGreater.ToString());
                Console.WriteLine(FunGreater.Compile().Invoke(5, 2));
            }
        }
    

    输出结果:

     

     

    展开全文
  • 一、前言 一直想写一篇Dpper的定制化扩展的文章...C# 表达式树讲解(一) C# 表达式树遍历(二) C# 表达式树分页扩展(三) C# 表达式树Lambda扩展(四) 二、表达树理解 表达式树以树形数据结构表示代码,其中

    一、前言

    一直想写一篇Dpper的定制化扩展的文章,但是里面会设计到对Lambda表达式的解析,而解析Lambda表达式,就必须要知道表达式树的相关知识点。我希望能通过对各个模块的知识点或者运用能够多一点的讲解,能够帮助到园友了解得更多。虽然讲解得不全面,如果能成为打开这块的一把钥匙,也是蜗牛比较欣慰的。

    表达式系列目录

    C# 表达式树讲解(一)

    C# 表达式树遍历(二)

    C# 表达式树分页扩展(三)

    C# 表达式树Lambda扩展(四)

    二、表达树理解

    表达式树以树形数据结构表示代码,其中每一个节点都是一种表达式,它将我们原来可以直接由代码编写的逻辑以表达式的方式存储在树状的结构里,从而可以在运行时去解析这个树,然后执行,实现动态的编辑和执行代码。在.Net 里面的Linq to SQL就是对表达式树的解析。

    这里先讲解下表达式和表达式树,表达式相信大家都知道,比如x+5或者5,都可以算是表达式,而表达式树里面的树指的二叉树,也就是表达式的集合,C#中的Expression类就是表达式类。对于一棵表达式树,其叶子节点都是参数或者常数,非叶子节点都是运算符或者控制符。

    2.1、表达式的创建

    Lambda表达式方法:

    Expression<Func<int, int,bool>> fun = (x, y) => x < y

    这种方法创建出的表达式根节点类型为ExpressionType.Lambda,Type类型为返回值类型typeof(bool)

    组装法(通过 API 创建表达式树):

    复制代码

    ParameterExpression numParam = Expression.Parameter(typeof(int), "num");
    ConstantExpression five = Expression.Constant(5, typeof(int));
    BinaryExpression numLessThanFive = Expression.LessThan(numParam, five);
    Expression<Func<int, bool>> lambda1 =
        Expression.Lambda<Func<int, bool>>(
            numLessThanFive,
            new ParameterExpression[] { numParam });

    复制代码

    我们先创建了两个参数表达式num和5,然后用LessThan组装在一起,最终的表达式为“num<5”,expr的节点类型为LessThan,Type类型为typeof(bool)

    我们先看看表达式树里面的构造

    首先Expression<TDelegate>的功能是将强类型Lambda表达式表示为表达式树形式的数据结构,他的父类是LambdaExpression,比较他们代码可知,Lambda表达式的主体,名称和参数全部保存在LambdaExpression里面。

    Expression<TDelegate>与LambdaExpression代码截图:

    image

    image

    LambdaExpression里面的Body就是我们的表达式。

    C#表达式给我们提供了丰富的表达式类,进入到LambdaExpression类里面

    image

    方法返回类型以“Expression”结尾的,基本上都是一个表达式类。

    每个表达式代表的定义和创建方法,可以参照微软官方文档https://docs.microsoft.com/zh-cn/dotnet/api/system.linq.expressions.binaryexpression?view=netframework-4.8

    下面是平常使用最多的表达式

    ConstantExpression:常量表达式

    ParameterExpression:参数表达式

    UnaryExpression:一元运算符表达式

    BinaryExpression:二元运算符表达式

    TypeBinaryExpression:is运算符表达式

    ConditionalExpression:条件表达式

    MemberExpression:访问字段或属性表达式

    MethodCallExpression:调用成员函数表达式

    Expression<TDelegate>:委托表达式

    2.2、表达式的解析

    表达式树解析

    通过LambdaExpression类我们可以知道,表达式树包含:参数[Parameters],表达式树类型[NodeType],表达式[Body],返回类型[ReturnType],Lambda表达式的委托[Compile]以及Lambda表达式名称[name],如图所示:

    image

    表达式解析:

    所有的表达式都包含:左节点【Left】,右节点【Right】,类型【NodeType】,不同的表达式还会有其他属性,这里的左右节点依旧是表达式。

    下图是BinaryExpression表达式截图

    image

    表达式树和表达式里面的类型NodeType是一个枚举,一共有85个类型,有兴趣的朋友可以去了解下。

    常用的类型如下:

    ExpressionType.And:C#中类似于&

    ExpressionType.AndAlso:C#中类似于&&

    ExpressionType.Or:C#中类似于|

    ExpressionType.OrElse:C#中类似于||

    ExpressionType.Equal:C#中类似于==

    ExpressionType.NotEqual:C#中类似于!=

    ExpressionType.GreaterThan:C#中类似于>

    ExpressionType.GreaterThanOrEqual:C#中类似于>=

    ExpressionType.LessThan:C#中类似于<

    ExpressionType.LessThanOrEqual:C#中类似于<=

    ExpressionType.Add:C#中类似于+

    ExpressionType.AddChecked:C#中类似于+

    ExpressionType.Subtract:C#中类似于-

    ExpressionType.SubtractChecked:C#中类似于-

    ExpressionType.Divide:C#中类似于/

    ExpressionType.Multiply:C#中类似于*

    ExpressionType.MultiplyChecked:C#中类似于*

    2.3、编译表达式树

    在表达式创建那,我们组合创建了一个Lambda表达式,那么应该怎么使用它呢?在“表达式的解析”里面,LambdaExpression类和Expression<TDelegate>类都有一个Compile的方法,学名是Lambda表达式的委托,其实就是Lambda表达式编译函数的委托,所以我们只需要调用他,得到的结果就是一个函数方法。

    代码修改如下:
     

    复制代码

    ParameterExpression numParam = Expression.Parameter(typeof(int), "num");
    ConstantExpression five = Expression.Constant(5, typeof(int));
    BinaryExpression numLessThanFive = Expression.LessThan(numParam, five);
    Expression<Func<int, bool>> lambda1 =
        Expression.Lambda<Func<int, bool>>(
            numLessThanFive,
            new ParameterExpression[] { numParam });
    
    Console.WriteLine($"Lambda的内容:{lambda1.ToString()}");
    
    //表达式的编译
    var func = lambda1.Compile();
    Console.WriteLine($"Lambda的运行结果:{func(6)}");
    

    复制代码

    运行结果

    image

    三、总结

    这里我们对表达式做了基本的讲解,相信大家对Lambda表达式有了初步的了解,下面我们将继续讲解对一个表达式树的遍历。

    展开全文
  • 改进的C#表达式计算

    2012-02-09 16:31:53
    改进的C#表达式计算 增加参数形式的表达式计算。 如W=300 H=550 计算 W+H
  • 下面小编就为大家带来一篇浅谈c#表达式树Expression简单类型比较demo。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 在运行时使用简单的C#表达式生成器。 当前支持以下操作: public enum Operation { Equals , NotEquals , GreaterThan , LessThan , GreaterThanOrEqual , LessThanOrEqual , Contains , ...
  • C#写的一个表达式解析和计算的例子,包含支持( )+-*/ > < >= != == && || 等操作符。 原用于从Redis读取关键字参数进行判断,可供学习参考。
  • c# 表达式(公式)计算

    2011-08-24 21:55:55
    c# 表达式计算 支持公式\常见函数计算 如:round(pi * (abs(pow(-3, 2)) + sqrt(147 * (14 + 27))))
  • C#表达式求值

    2012-11-26 14:39:29
    C#算术表达式的求值,直接加入项目编译即可,可计算幂
  • C#表达式运算类

    2018-09-05 15:17:48
    能进行以下运算:四则运算、乘方开方、三角函数、逻辑运算。
  • 本篇文章主要介绍了表达式树 Expression Trees的基础知识:Lambda 表达式创建表达式树;API 创建表达式树;编译表达式树;执行表达式树;修改表达式树等等,具有一定的参考价值,下面跟着小编一起来看下吧
  • Dynamic Expresso 嵌入了自己的解析逻辑,通过将其转换为 .NET lambda 表达式或委托来真正解释 C# 语句。 使用 Dynamic Expresso 开发人员可以创建可编写脚本的应用程序、无需编译即可执行 .NET 代码或创建动态 ...
  •  表达式目录树,在C#中是Expression来定义的,它是一种语法树,或者说是一种数据结构。其主要用于存储需要计算、运算的一种结构,它只提供存储功能,不进行运算。通常Expression是配合Lambda一起使用,lambda可以是...
  • C# 表达式求值

    2014-05-21 16:14:46
    字符串表达式求值 输入类似1+2+3,6*5/7的字符串,计算出值
  • C#在学习表达式目录树的时候,好的工具会让你的学习事半功倍,能够更好的帮助你学习和理解,希望能够帮助到你。
  • C# 表达式 计算器

    2010-01-20 17:20:22
    简单计算器,实现优先级比较,可直接输入表达式计算
  • 表达式树使用一种类似树的结构来表示代码,它的每个节点都是一个表达式,比如方法调用和x类
  • C#表达式解析器-1.0

    2017-07-11 14:31:02
    在修正了优先级问题的基础上,做为1.0版发布。
  • 一个C#实现的简单表达式解析器,支持算符优先级、括号以及函数。
  • C#表达式,类型和变量

    千次阅读 2007-03-24 13:51:00
    C#表达式有个初步的了解4.了解什么是String类型5.学习如何使用数组"变量"仅仅是数据的存储位置。你可以把数据存放到其中,或者从中取出来作为C#表达式的一部分。变量中所存放的数据的含义是通过类型来控制的。C#是...
    本节课将介绍C# 语言的表达式,类型和变量。本节课要达到如下几个目的:
    
    1.了解什么是"变量"

    2.学习C#的简单类型

    3.对C#表达式有个初步的了解

    4.了解什么是String类型

    5.学习如何使用数组

    "变量"仅仅是数据的存储位置。你可以把数据存放到其中,或者从中取出来作为C#表达式的一部分。变量中所存放的数据的含义是通过类型来控制的。

    C#是个强类型(???)的语言。这样,一切对变量的操作都是针对该变量的类型而进行的。为了保证变量中所存放数据的合法性和一致性,对不同类型的变量进行操作有相应的规则。

    C#语言的简单类型包含布尔类型和三种数值类型:整型,浮点型和小数。

    1.清单1-1 显示布尔值:Boolean.cs

    using System;
    class Booleans {
    public static void Main() {
    bool content = true;
    bool noContent = false;
    Console.WriteLine("It is {0} that C# Station provides C# programming language content.", content);
    Console.WriteLine("The statement above is not {0}.", noContent);
    }
    }

    说明

    1.在清单1-1中,布尔值作为句子的一部分输出到控制台中。"bool"类型的取值要么为真,要么为假。程序运行结果如下:

    >It is True that C# Station provides C# programming language content.
    >The statement above is not False.

    2.下列表格显示了各种整数类型,所占字节大小和所能表示的数的范围。

    类型 位 范围
    sbyte 8 -128 to 127
    byte 8 0 to 255
    short 16 -32768 to 32767
    ushort 16 0 to 65535
    int 32 -2147483648 to 2147483647
    uint 32 0 to 4294967295
    long 64 -9223372036854775808 to 9223372036854775807
    ulong 64 0 to 18446744073709551615
    char 16 0 to 65535

    在对整数进行计算时,除了字符类型之外,上述这些类型都是适合的。字符类型代表一个Unicode字符。正如在上表中可以看到的,你可以从中选择适合你需要的类型。

    3.下列表格显示了单精度类型,双精度类型和小数类型的数据,它们所占的字节,精度和所能表示的数的范围。

    类型 位 精度 范围
    float 32 7 digits 1.5 x 10-45 to 3.4 x 1038
    double 64 15-16 digits 5.0 x 10-324 to 1.7 x 10308
    decimal 128 28-29 decimal places 1.0 x 10-28 to 7.9 x 1028

    当你需要进行涉及到分数的操作时,就需要用到实型,然而,对于金融财经方面的数据的计算,小数类型也许是你最好的选择。

    4.表达式计算之后可以得出结果。这些表达式把变量和运算符一同放到语句中。下表列出了C#允许的运算符,优先级和结合性。

    分类 运算符 结合性
    初级 (x) x.y f(x) a[x] x++ x-- new typeof sizeof checked unchecked 左
    单目 + - ! ~ ++x --x (T)x 左
    乘法等 * / % 左
    加法等 + - 左
    移位 << >> 左
    关系 < > <= >= is 左
    相等 == != 右
    逻辑与 & 左
    逻辑异或 ^ 左
    逻辑或 | 左
    条件与 && 左
    条件或 || 左
    条件 ?: 右
    赋值等 = *= /= %= += -= <<= >>= &= ^= |= 右

    左结合意味着运算符是从左到右进行运算的。右结合意味着所有的运算是从右到左进行的,如赋值运算符,要等到其右边的计算出来之后,才把结果放到左边的变量中。

    2.清单 1-2. 单目运算符: Unary.cs

    using System;
    class Unary {
    public static void Main() {
    int unary = 0;
    int preIncrement;
    int preDecrement;
    int postIncrement;
    int postDecrement;
    int positive;
    int negative;
    sbyte bitNot;
    bool logNot;
    preIncrement = ++unary;
    Console.WriteLine("Pre-Increment: {0}", preIncrement);
    preDecrement = --unary;
    Console.WriteLine("Pre-Decrement: {0}", preDecrement);
    postDecrement = unary--;
    Console.WriteLine("Post-Decrement: {0}", postDecrement);
    postIncrement = unary++;
    Console.WriteLine("Post-Increment: {0}", postIncrement);
    Console.WriteLine("Final Value of Unary: {0}", unary);
    positive = -postIncrement;
    Console.WriteLine("Positive: {0}", positive);
    negative = +postIncrement;
    Console.WriteLine("Negative: {0}", negative);
    bitNot = 0;
    bitNot = (sbyte)(~bitNot);
    Console.WriteLine("Bitwise Not: {0}", bitNot);
    logNot = false;
    logNot = !logNot;
    Console.WriteLine("Logical Not: {0}", logNot);
    }
    }

    说明

    1.当计算表达式的时候,在后置增一和后置减一运算符进行运算时,先返回其值,再进行增一或者减一运算。当使用前置加号和减号运算符进行运算时,是先进行增一或者减一的运算,然后再返回其结果值。

    2.在清单1-2中, 变量unary初始化为0,进行++x 运算时,"unary"的值加1,再把其值1赋给"preIncrement"变量。在进行--x运算时,先把"unary"的值减到0, 再把值0赋给"preDecrement"变量。

    3.进行x-运算时,先把"unary"的值0赋给"postDecrement" 变量,之后再把"unary"减到-1。进行x++运算时,先把"unary"的值-1赋给"postIncrement"变量,之后再对"unary"加1,使得"unary"变量现在的值为0。

    4.变量"bitNot"初始值为0,进行按位取反运算,本例中,数0表示为二进制"00000000",按位取反之后变为-1,其二进制表示为"11111111"。

    5.了解一下表达式"(sbyte)(~bitNot)", 任何对类型sbyte, byte, short 或者 ushort 类型数据的运算,返回结果都是整数。要把值赋给bitNot变量,我们必须使用cast (类型)运算符(强制类型转换),其中Type表示你希望转换成的类型(本例中为sbyte)。 Cast运算符把大范围类型的数据转换为小范围类型的数据时,须特别谨慎,因为此时有丢失数据的危险。一般来说,把小类型的数据赋给大类型变量,并没有问题, 因为大范围数据类型的变量具有足够的空间存放小类型数据。 注意在signed 和unsigned类型之间进行Cast运算时,也存在此类危险。 许多初级程序设计教程对变量的位表示作出了很好的讲解,同时也介绍了直接进行Cast运算的危险。

    逻辑非(!)运算符可以处理布尔变量值。本例中,"logNot"变量从false 变为true。

    上述程序的输出结果如下:

    >Pre-Increment: 1
    >Pre-Decrement 0
    >Post-Decrement: 0
    >Post-Increment -1
    >Final Value of Unary: 0
    >Positive: 1
    >Netative: -1
    >Bitwise Not: -1
    >Logical Not: True

    3.清单 1-3. 二元运算符 Binary.cs

    using System;
    class Binary {
    public static void Main() {
    int x, y, result;
    float floatResult;
    x = 7;
    y = 5;
    result = x+y;
    Console.WriteLine("x+y: {0}", result);
    result = x-y;
    Console.WriteLine("x-y: {0}", result);
    result = x*y;
    Console.WriteLine("x*y: {0}", result);
    result = x/y;
    Console.WriteLine("x/y: {0}", result);
    floatResult = (float)x/(float)y;
    Console.WriteLine("x/y: {0}", floatResult);
    result = x%y;
    Console.WriteLine("x%y: {0}", result);
    result += x;
    Console.WriteLine("result+=x: {0}", result);
    }
    }

    说明

    清单1-3 演示了二元操作符的几个例子。加法(+),减法(-),乘法(*)和除法(/)的运算结果,就是我们通常进行的的四则运算的结果。

    因为"floatResult"变量是浮点运算类型,所以整型变量"x"和"y" 被强制转换成浮点类型来计算FloatResult。

    这里有个求余数的运算符,两个操作数相除,返回余数。

    最后一条语句给出了另外一种赋值形式,这里用了(+=)运算符.无论什么时候你使用(+=)运算符,那么这个二进制运算符就应该在运算符左右两边都进行运算,然后把值赋给左边的参数。本语句相当于"result = result + x",并返回同样的值。

    前面的课程中,你看到的使用次数较多的一种类型是"string" (字符串)类型。"string"类型是由包含在引号内的Unicode编码的字符构成。例如"This is a string."

    另外一种数据类型是数组。数组可以看成是同种类型的元素构成的集合。当声明数组时,你要指定类型名,数组名,维数和数组大小。

    4.清单 1-4. Array Operations: Array.cs

    using System;
    class Array {
    public static void Main() {
    int[] myInts = { 5, 10, 15 };
    bool[][] myBools = new bool[2][];
    myBools[0] = new bool[2];
    myBools[1] = new bool[1];
    double[,] myDoubles = new double[2, 2];
    string[] myStrings = new string[3];
    Console.WriteLine("myInts[0]: {0}, myInts[1]: {1}, myInts[2]: {2}", myInts[0], myInts[1], myInts[2]);
    myBools[0][0] = true;
    myBools[0][1] = false;
    myBools[1][0] = true;

    Console.WriteLine("myBools[0][0]: {0}, myBools[1][0]: {1}", myBools[0][0], myBools[1][0]);
    myDoubles[0, 0] = 3.147;
    myDoubles[0, 1] = 7.157;
    myDoubles[1, 1] = 2.117;
    myDoubles[1, 0] = 56.00138917;
    Console.WriteLine("myDoubles[0, 0]: {0}, myDoubles[1, 0]: {1}", myDoubles[0, 0], myDoubles[1, 0]);
    myStrings[0] = "Joe";
    myStrings[1] = "Matt";
    myStrings[2] = "Robert";
    Console.WriteLine("myStrings[0]: {0}, myStrings[1]: {1}, myStrings[2]: {2}", myStrings[0], myStrings[1], myStrings[2]);
    }
    }

    说明

    清单 1-4 演示了数组的各种不同实现方法。第一个例子是"myInts"数组,它在声明的同时进行了初始化。

    接着是个二维数组,可以把它理解为数组的数组。我们需要使用"new"运算符来实例化初始数组的大小,之后,再对每个子数组使用new运算符。

    第三个例子是个二维数组。数组可以是多维的,每一维可以通过逗号隔开,也必须用"new"运算符进行实例化。

    最后定义了一个一维的字符串数组。

    每种情况下,对于数据元素的访问可以通过引用元素的位置(下标)来进行。数组的大小可以是任何整型值。其下标从0开始。

    小结
    到现在为止,你已经了解了C# 的变量,简单数据类型,数组和字符串。我们还学习了如何用C#的运算符构成表达式。 


     
    展开全文
  • C#表达式计算 源码

    2012-03-05 20:18:51
    增加的表达式计算,可代入公式,排序计算。如计算W=400,H=600 ,W*H-H 等
  • C#表达式计算器代码

    2011-11-03 12:48:52
    输入一个式子,如“(45+76)*65+(3-6+(4*7))”也可以计算出结果,程序会根据计算符号的优先来计算结果,如先乘除后加减。程序主要用到队列和递归来完成。.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 119,391
精华内容 47,756
关键字:

c#表达式

c# 订阅