Выражения и операции в C#

Выражения и операции в C#

Доброго времени суток! В этой статье я доступно и коротко расскажу о выражения и операциях, часто используемых в C#.  Основной код программы, написанной на C#, состоит из операторов и блоков операторов. Операторы, состоят из выражений, а те, в свою очередь – из операций и операндов. Пример простейшего выражения: 2 + 5; где «2» и «5» являются операндами, а «+» – операцией.

В программах, написанных на C#, операндами обычно являются объекты классов (в том числе, пользовательских) или переменные/константы встроенных типов.

Операции, можно условно разделить на группы: унарные (с одним операндом), бинарные (с двумя операндами), тернарные (с тремя операндами), но я  буду перечислять операции группируя их по приоритету выполнения (в порядке убывания).

Приоритет выполнения, показывает, в каком порядке, буду выполняться операции в выражении, состоящем более чем из одной операции. Как в математике, помните? Умножение выполняется перед сложением или вычитанием.

Давайте теперь рассмотрим основные операции, доступные в C#!

«.» – операция доступа к полю/свойству/методу класса. Использовать можно, например, так:

/*
* someObject – объект какого-то класса, 
* SomeFiled ­– некое поле, «.» – операция
*/
someObject.SomeField

 

«()» – операция вызова метода. Использовать можно, следующим:

/*
* SomeMethod – некий метод
*/
SomeMethod();

 

«[]» – операция доступа к массиву (если хотите, к элементу массива). Пример использования:

/*
* someArray – некий массив
*/
someArray[0]; //Доступ к первому элементу

 

«++» и «—» после операнда – операции постинкремента и постдекремента (как правило, увеличивает и уменьшает, соответственно, значение операнда на единицу). Использовать можно так:

/*
* someValue – некое значение, например, типа int
*/
someValue++; //Увеличить значение на 1
someValue--; //Уменьшить значение на 1

 

«new» – операция создания объекта/массива. Использовать можно так:

/*
* SomeType – некий тип данных,
* someObject – создаваемый объект,
* someArray – создаваемый массив
*/
SomeType someObject = new SomeType(); //Создание нового объекта
SomeType[] someArray = new SomeType[10]; //Создание нового массива

 

«typeof» – операция получения информации о типе данных. Пример использования:

/*
* SomeType – некое тип данных,
* someInfo – объект типа Type
*/
Type someInfo = typeof(SomeType);

«—» перед операндом – операция отрицания. Использовать можно так:

int a = 5;
int b = -a; //= -5

 

«!» перед операндом – операция логического отрицания. Использовать можно следующим образом:

 

bool a = true;
bool b = !a; //= false

 

«~» перед операндом – операция двоичного (побитового) отрицания. Инвертирует (0 меняет на 1, а 1 на ноль) каждый бит числа. Этой операцией, Вы будете пользоваться редко… Использовать можно так:

int a = 10;
int b = ~a;

 

«++» и «—» перед операндом – операции преинкремента и предекремента соответственно (как правило, увеличивает и уменьшает, соответственно, значение операнда на единицу). Использовать можно так:

/*
* someValue – некое значение, например, типа int
*/
++someValue; //Увеличить значение на 1
--someValue; //Уменьшить значение на 1

 

Обратите внимание, префиксная форма операции инкремента/декремента очень похожа на постфиксную, отличия проявляются лишь при использовании в сложных выражениях. Преинкремент/декремент сначала выполняется сам, а потом возвращает значение, а постфиксная форма, сначала возвращает значение, а потом выполняется.

На практике, постфиксная форма работает так:

int a = 10;
int b = a++; //b = 10, a стало 11

 

А префиксная так:

int a = 10;
int b = ++a; //b = 11, и a стало 11

 

«(…)» перед операндом – операция приведения типа. Используется для приведения переменной одного типа, к другому (так называемое, явное приведение типа). Использовать можно так:

/*
* someObject – объект какого-то типа, 
* OtherType – другой тип данных
*/
(OtherType) someObject; //Приведение объекта someObject к типу OtherType

«*» и «/» – операции умножения и деления. Думаю, использование этих операций в описании не нуждается.

«%» – данная операция, возвращает остаток от деления. К примеру, при делении четного числа на 2, вернет 0. На практике можно использовать так:

/*
* someValue – некая переменная, целого типа 
*/
if(someValue % 2 == 0)
{
    //Четное значение
}else
{
    //Нечетное значение
}

«+» и «—» – операции сложения и вычитания. Думаю, в дополнительном описании не нуждаются.

«<<» и «>>» – операции побитового сдвига влево и вправо соответственно. Как это работает на практике:

/*
* someValue – некая переменная, например, целого типа 
*/
someValue = someValue &amp;amp;lt;&amp;amp;lt; 2; //Сдвиг влево всех битов на две позиции
someValue = someValue &amp;amp;gt;&amp;amp;gt; 2; //Сдвиг вправо всех битов на две позиции

 «>», «<», «>=», «<=» – операции сравнения, больше, меньше, больше или равно, меньше или равно. В дополнительном описании вряд ли нуждаются…

«is» – операция проверки возможности приведения типа. На практике работает так:

/*
* someValue – некая переменная, 
* SomeType – какой-то тип данных
*/
if(someValue is SomeType == true)
{
    //someValue можно привести к типу SomeType
}else
{
    //someValue нельзя привести к типу SomeType
}

«as» – операция преобразования типа, без генерации исключения в случае неудачи. Данная операция осуществляет попытку преобразовать объект одного типа к другому, но, если такое преобразование невозможно, возвращает null (пустую ссылку, если хотите). На практике это работает так:

/*
* someValue – некая переменная,
* otherObject – ссылка типа SomeType,
* SomeType – какой-то тип данных
*/
SomeType otherObject = someValue as SomeType;

if(otheObject != null)
{
    //someValue преобразовано к типу SomeType и сохранено в otheObject
}else
{
    //someValue нельзя привести к типу SomeType, otherObject == null 
}

«==» и «!=» – операции эквивалентности, эквивалентно и неэквивалентно (обратные друг другу операции).

«&» – операция побитового «И» для целочисленных типов и операция логического умножения, для bool-типов.

«^» – операция побитового исключающего «ИЛИ» для целочисленных типов и операция логического исключающего «ИЛИ», для bool-типов.

«|» – операция побитового «ИЛИ» для целочисленных типов и операция логического «ИЛИ», для bool-типов.

«&&» -– операция условного «И». Возвращает истину, если истины оба операнда, во всех остальных случаях, вернет ложь. Использовать можно так:

/*
* firstValue – некая переменная, типа bool
* secondValue – другая переменная, типа bool
*/
if(firstValue &amp;amp;amp;&amp;amp;amp; secondValue)
{
    //Обе переменные имеют значение true
}else
{
    //Как минимум одна переменная имеет значение false
}

«||» -– операция условного «ИЛИ». Возвращает истину, если хоть один операнд имеет значение true. Использовать можно так:

/*
* firstValue – некая переменная, типа bool
* secondValue – другая переменная, типа bool
*/
if(firstValue || secondValue)
{
    // Как минимум одна переменная имеет значение true
}else
{
    Обе переменные имеют значение false
}

 «??» – операция проверки на null. Имеет вид: [объект 1] ?? [объект 2]. Если [объект 1] не равен null, то возвращается [объект 1], в противном случае – [объект 2]. Использовать можно так:
/*
* someString – некая переменная, типа string
*/

string restultString = someString ?? "Пустая ссылка";

/*
* Если переменная someString равна null, то restultString
* получит значение «Пустая ссылка», в противном случае,
* restultString; получит значение переменной someString
*/

 

«?» – условная операция. Имеет вид: [условие] ? [результат 1] : [результат 2]. Если выполняется условие, то возвращается [результат 1], если условие не выполняется – [результат 2].  Использовать можно так:

/*
* someValue – некая переменная, типа int
*/

int resultValue = someValue &amp;lt; 0 ? -someValue : someValue;

/*
* Если переменная someValue меньше 0, то resultValue
* получит значение переменной someValue, в противном случае, 
* resultValue получит значение переменной someString умноженной на -1
*/

«=» – операция присваивания. Думаю, что пояснять для чего нужна эта операция не нужно, она использовалась не однократно в примерах выше.

«*=», «/=», «%=», «+=», «-=», «<<=», «>>=», «&=», «^=», «|=» – операции составного присваивания. Работу покажу на примере операции «+=»:

/*
* someValue – некая переменная, например, типа int
*/
someValue += 5; //Эта запись дает такой же результат, что и запись: someValue = someValue + 5;


    
        

        
         
        
    
    

    
    
       
        
    	

		
Добавить комментарий