Skip to main content

C# Expressions (C# Specification Part 3)

Expressions are constructed from operands and operators. The operators of an expression indicate which operations to apply to the operands. Examples of operators include +, -, *, /, and new. Examples of operands include literals, fields, local variables, and expressions.
When an expression contains multiple operators, the precedence of the operators controls the order in which the individual operators are evaluated. For example, the expression x + y * z is evaluated as x + (y * z) because the * operator has higher precedence than the + operator.
Most operators can be overloaded. Operator overloading permits user-defined operator implementations to be specified for operations where one or both of the operands are of a user-defined class or struct type.
The following table summarizes C#’s operators, listing the operator categories in order of precedence from highest to lowest. Operators in the same category have equal precedence.


Category
Expression
Description
Primary
x.m
Member access
x(...)
Method and delegate invocation
x[...]
Array and indexer access
x++
Post-increment
x--
Post-decrement
new T(...)
Object and delegate creation
new T(...){...}
Object creation with initializer
new {...}
Anonymous object initializer
new T[...]
Array creation
typeof(T)
Obtain System.Type object for T
checked(x)
Evaluate expression in checked context
unchecked(x)
Evaluate expression in unchecked context
default(T)
Obtain default value of type T
delegate {...}
Anonymous function (anonymous method)
Unary
+x
Identity
-x
Negation
!x
Logical negation
~x
Bitwise negation
++x
Pre-increment
--x
Pre-decrement
(T)x
Explicitly convert x to type T
await x
Asynchronously wait for x to complete
Multiplicative
x * y
Multiplication
x / y
Division
x % y
Remainder

Additive
x + y
Addition, string concatenation, delegate combination
x – y
Subtraction, delegate removal
Shift
x << y
Shift left
x >> y
Shift right
Relational and type testing
x < y
Less than
x > y
Greater than
x <= y
Less than or equal
x >= y
Greater than or equal
x is T
Return true if x is a T, false otherwise
x as T
Return x typed as T, or null if x is not a T
Equality
x == y
Equal
x != y
Not equal
Logical AND
x & y
Integer bitwise AND, boolean logical AND
Logical XOR
x ^ y
Integer bitwise XOR, boolean logical XOR
Logical OR
x | y
Integer bitwise OR, boolean logical OR
Conditional AND
x && y
Evaluates y only if x is true
Conditional OR
x || y
Evaluates y only if x is false
Null coalescing
X ?? y
Evaluates to y if x is null, to x otherwise
Conditional
x ? y : z
Evaluates y if x is true, z if x is false
Assignment or anonymous function
x = y
Assignment
x op= y
Compound assignment; supported operators are
*=   /=   %=   +=   -=   <<=   >>=   &=   ^=   |=
(T x) => y
Anonymous function (lambda expression)


Labels:

Comments

Post a Comment

Popular posts from this blog

Accessing File Stored in Windows Azure Blob Storage Using jQuery

Did you know it was possible to access the Windows Azure Blob Storage directly from JavaScript, for example using jQuery? At first, it sounds obvious, since Blobs are after all accessible from a public UR. But in practice, there is a very big hurdle: the Web browser’s Same Origine Policy or SOP, that restricts JavaScript code to accessing resources originating from the same site the script was loaded from. This means that you will never be able to load a Windows Azure Blob using XMLHttpRequest for example! Fortunately, there is a popular workaround called JSONP (“JSON with Padding”). The idea behind this technique is that the script tag is not submitted to the SOP: an HTML page can thus load a JavaScript file from any site. So, if you expose your data in an “executable” form in JavaScript, a page will be able to load this data using a script tag. For example: <script type=”text/javascript” src=”http://www.sandeepknarware.in/exemple.jsonp”> </script> But how can ...
Post a Comment
Read more

Support for debugging lambda expressions with Visual Studio 2015

Anyone who uses LINQ (or lambdas in general) and the debugger will quickly discover the dreaded message “Expression cannot contain lambda expressions”. Lack of lambda support has been a limitation of the Visual Studio Debugger ever since Lambdas were added to C# and Visual Basic.  With visual studio 2015 Microsoft has added support for debugging lambda expressions. Let’s first look at an example, and then I’ll walk you through current limitations. Example To try this yourself, create a new C# Console app with this code: using System.Diagnostics; using System.Linq; class Program { static void Main() { float[] values = Enumerable.Range(0, 100).Select(i => (float)i / 10).ToArray(); Debugger.Break(); } } Then compile, start debugging, and add “values.Where(v => (int)v == 3).ToArray()” in the Watch window. You’ll be happy to see the same as what the screenshot above shows you. I am using Visual Studio 2015 Preview and it has some limitati...
1 comment
Read more

gcAllowVeryLargeObjects Element

There are numerous new features coming with .NET 4.5 and here, on this blog, you can find several posts about it. But the feature we are goint to talk about today is very exciting, because we were waiting for it more than 10 years. Since .NET 1.0 the memory limit of .NET object is 2GB. This means you cannot for example create array which contains elements with more than 2GB in total. If try to create such array, you will get the OutOfMemoryException. Let’s see an example how to produce OutOfMemoryException. Before that Open Visual Studio 2012, and create C# Console Application, like picture below. First lets create simple struct with two double members like example below: 1 2 3 4 5 6 7 8 9 10 11 12 public struct ComplexNumber {      public double Re;      public double Im;      public ComplexNumber( double re, double im)      {    ...
Post a Comment
Read more