C# 1001 notes

2018-11-05 19:02:15 Конкатена́ция строк в C#

В C# мы можем использовать оператор + не только для сложения чисел, но и склеивания (конкатенации) строк:

string s1 = "C#";
string s2 = "fun";
string s3 = s1 + " is " + s2; // "C# is fun"

Мы можем использовать этот оператор неограниченное количество раз в рамках одного выражения (expression), а само выражение использовать в тех местах кода, где ожидается строка:

string s1 = "Hello " + " Wor" + "ld";
Console.WriteLine("Wish " + "you " + "the best");

Более того, специальные методы String.Concat и String.Format содержат дополнительные перегрузки, которые также могут быть использованы для конкатенации:

// Concat method
string s4 = String.Concat(new object[] {
"The ", 3, " musketeers"
});

string s5 = String.Concat("This", "That");

// Use String.Format to concatenate
string s6 = string.Format("{0}{1}{2}", s1, " is ", s2);

Продолжая рассказывать про полезные фичи в C# нельзя не упомянуть coalesce оператор ??. Принцип его работы прост- возвращать left-hand операнд если он не null и right-hand в обратном случае: int y = x ?? -1. Берите на вооружение

#strings Открыть/Комментировать

2018-11-02 16:39:01 Рабочая неделя заканчивается, а значит пришло время очередной недельной подборки на выходные.

Предлагаю вашему внимаю самые интересные статьи и вопросы этой недели:

Why does Enumerable.Single() iterate all elements, even when more than one item has already been found?

How to use Factory Method Design Pattern in C#

C# Intermediate – Delegates in C#

How to properly implement an interface that was designed for async usage?

Secure Random Integers in .NET Core 3

.NET Standard vs. .NET Core

Всем отличных выходных

#sof_weekly Открыть/Комментировать

2018-11-01 19:02:18 ​​Parse чисел в C#

Каждый числовый тип в C# содержит метод Parse, с помощью которого мы можем преобразовывать строки в соответствующие числовые значения:

byte b1 = byte.Parse("200");
sbyte sb1 = sbyte.Parse("-100");
float f1 = float.Parse("1.2e-4");

Однако, важно отметить, что результат выполнения этого метода может обернуться для нас и следующими исключениями:

FormatException:

int n1 = int.Parse("3.4"); // FormatException

В этом примере мы пробуем привести (распарсить) дробное значение к типу int, в результате чего получаем исключение о некорректности формата входного параметра 3.4.

OverflowException:

uint ui1 = uint.Parse("-1"); // OverflowException

В данном случае мы пытаемся привести отрицательное число к типу uint, значения которого могут быть только положительными. Как итог - исключение, сигнализирующее о переполнении.

Одним из полезных атрибутов, помогающем как в документации, так и в контроле поведения, является ObsoleteAttribute. С его помощью мы можем помечать элементы программы, которые больше не должны использоваться и вскоре могут быть удалены. Обычно мы получаем предупреждение, однако, знали ли вы, что это поведение настраиваемое и мы можем даже возвращать полноценную ошибку компиляции ?

#strings Открыть/Комментировать

2018-10-31 19:02:15 Выключение контроля переполнения в C#

В предыдущей заметке я рассказывал о ключевом слове checked и возможности устанавливать поведение по умолчанию в случае переполнения в рамках проектов. Нелишним будет упомянуть и о ключевом слове unchecked, которое делает обратное.

В том случае, если в настройках проекта в качестве поведения по умолчанию мы выбираем опцию выбрасывать исключения в случае переполнения, то unchecked может нам помочь избежать этого при необходимости:

int n1 = int.MaxValue; // 2147483647 (0x7FFFFFFF)
int n2 = unchecked(n1 + 1); // Перенос -2147483648
int n3 = n1 + 1; // OverflowException

Как и в случае с checked мы так же может использовать unchecked не только для конкретных операторов, но и целых участков кода:

int n1 = int.MaxValue; // 2147483647
unchecked
{
int n2 = n1 + 1; // Перенос -2147483648
int n4 = n1 * 2; // -2
}

Уверен, вы замечали, что следующий код не будет скомпилирован и отобразится ошибка:

int n1 = int.MaxValue + 1; // Ошибка компиляции: overflow

В этом случае нам также может помочь unchecked:

int n2 = unchecked(int.MaxValue + 1);

Одной из полезных возможностей в Visual Studio для повышения продуктивности для меня являются сниппеты (настоятельно рекомендую ознакомиться всем тем, кто их не использует ). А какой из них вы используете чаще всего?

#data_types Открыть/Комментировать

2018-10-30 19:04:12 ​​Контроль переполнения в C#

В прошлой заметке я уже упоминал о том, что по умолчанию при переполнении ведущие биты обнуляются, после чего результат "умещается" в доступных битах:

int n1 = int.MaxValue;
n1 = n1 + 1; // -2147483648 (перенос)

Однако это поведение может быть изменено и для этого мы можем воспользоваться ключевым словом checked:

int n1 = int.MaxValue;
n1 = checked(n1 + 1); // OverflowException

В таком случае вместо продолжения выполнения программы будет выброшено исключение OverflowException, которое мы можем или корректно обработать, или проигнорировать для завершения программы.

Синтаксис ключевого слова checked позволяет контролировать переполнение не только у конкретных операторов, но и целых блоков кода:

checked
{
int n1 = int.MaxValue;
n1 = n1 + 1; // OverflowException
}

Также стоит упомянуть о возможности изменения поведения при переполнении в настройках проекта: Project > Properties > Build > Advanced > Check for arithmetic overflow/underflow.

#data_types Открыть/Комментировать

2018-10-29 19:03:10 Переполнение в C#

Во время выполнения арифметических операций с целочисленными типами возможна ситуация, при которой итоговый результат выходит за рамки доступных значений результирующего типа (другими словами не может быть корректно представлен и размещён в памяти).

Такая ситуация называется переполнением (overflow) и корнями уходит к арифметике и битовому представлению чисел в computer science.

По умолчанию в C# и .NET при переполнении ведущие биты обнуляются, после чего результат "умещается" в доступных битах. В случае с беззнаковыми типами - большие значения станут меньше, а при переполнении знаковых типов положительные числа станут отрицательными.

Позвольте мне продемонстрировать это поведение на примерах:

Максимальным значением для беззнакового типа uint является 0xffffffff:

uint u1 = 0xffffffff;
u1 = u1 + 5; // 0x00000004 (перенос)

int.MaxValue - максимальное значение для знакового типа int:

int n1 = int.MaxValue;
n1 = n1 + 1; // -2147483648 (перенос)

Минимальное значение для знакового типа short является -32768:

short s1 = short.MinValue;
s1 = (short)(s1 - 1); // 32767 (перенос)

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

#data_types Открыть/Комментировать

2018-10-26 16:39:02 ​​ Выходные на пороге, а значит время очередного еженедельного дайджеста.

Предлагаю вашему внимаю самые интересные вопросы этой недели:

C# Intermediate – Queue, Stack, And Hashtable in C#

What does .NET's Equals method really mean?

Use structures to improve the readability of your code

Playing with C# 7 - Deconstruct

The Evolution of C#

IEnumerable and .Where Linq method behaviour?

How to find all classes that implements a generic abstract class using reflection in C#?

Why are 1000 threads faster than a few?

Всем отличных выходных

#sof_weekly

2.9K viewsedited  13:39

Открыть/Комментировать

2018-10-25 19:02:18 Округление чисел с плавающей точкой в C#

Во время разработки мы временами сталкиваемся с необходимостью округлить число с плавающей точкой типа float или double к целочисленному значению типа int. Сделать это неявно, как я уже упоминал ранее, у нас не получится ввиду отсутствия реализации подобного приведения:

int n1 = 4.8f; // Cannot implicitly convert

Поэтому в дело вступает явное приведение:

int n1 = (int)4.8f;

Однако, с этим кодом всё не так просто. Дело в том, что подобное округление на деле окажется ничем иным, как отбрасыванием дробной части у целочисленного значения.

Если же мы хотим руководствоваться математическими правилами округления, то с этим нам поможет класс System.Convert:

float f1 = 4.8f;
int n1 = Convert.ToInt32(4.8f); // 5

Но и здесь всё не всегда так гладко Оказывается, в .NET алгоритм округления (banker's rounding) отличается от привычного нам в тех случаях, когда значения являются пограничными: 0.5, 3.5. В этих случаях округление осуществляется в пользу ближайшего чётного:

int n1 = Convert.ToInt32(8.5f); // 8
int n2 = Convert.ToInt32(9.5f); // 10

Заинтересованы алгоритмом и причиной подобного решения в .NET? Подробнее почитать об этом вы сможете уже самостоятельно здесь

#basics Открыть/Комментировать

2018-10-24 19:04:16 Целочисленное деление и округление в C#

При делении одного целочисленного значения на другое с помощью оператора деления / результат всегда округляется до нуля. Другими словами- обрезается:

int n1 = 7 / 2; // 3
long n2 = -7 / 2; // -3
short n3 = -11 / -3; // 3

Причину этого поведения я описывал в предыдущей заметке - целочисленные аргументы приводят к целочисленному результату.

При попытке поделить на значение, равное 0, мы получим исключение System.DivideByZeroException в runtime:

int i = 0;
int r = 7 / i; // DivideByZeroException

При попытке поделить на литерал 0 мы получим исключение на этапе компиляции:

int r = 7 / 0; // Division by constant zero

Тем удивительнее оказывается тот факт, что в случае деления числа с плавающей точкой на ноль (1.0 / 0) вышеупомянутое исключение выброшено не будет. Мы просто получим в результате бесконечность (Infinity)

#basics Открыть/Комментировать

2018-10-23 19:04:13 Арифметические операции в C#

Во вчерашней заметке мы рассмотрели унарные операции инкремента и декремента.

Сегодняшняя тема достаточно простая, однако, обойти её стороной, на мой взгляд, было бы неправильно. Итак.. бинарные арифметические операции в C#:

+ - сложение двух чисел:

int x = 10;
int z = x + 12; // 22

- - вычитание двух чисел:

int x = 10;
int z = x - 6; // 4

* - умножение двух чисел:

int x = 10;
int z = x * 5; // 50

/ - деление двух чисел:

int x = 10;
int z = x / 5; // 2

double a = 10;
double b = 3;
double c = a / b; // 3.33333333

При делении стоит учитывать, что если оба операнда представляют целые числа, то результат также будет округляться до целого числа:

double z = 10 / 4; // 2

Хочу обратить ваше внимание на то, что несмотря на тип переменной double, которой будет присвоено итоговое значение, результат деления будет целочисленным числом ввиду того, что литералы 10 и 4 имеют целочисленный тип int.

Для выхода из этой ситуации необходимо определять литералы или переменные, участвующие в операции, именно как типы double или float:

double z = 10.0 / 4.0; // 2.5

% - остаток от целочисленного деления:

double x = 10.0;
double z = x % 4.0; // 2

Помните ли вы порядок выполнения операторов? Вот небольшое задание для проверки

#basics Открыть/Комментировать