Хранение и извлечение данных, используя литеральные значения и значения переменных в C#.

Введение

Многие приложения, которые вы будете создавать на C#, потребуют от вас работы с данными. Иногда эти данные будут жестко закодированы в вашем приложении. Жестко запрограммированные значения — это значения, которые являются постоянными и неизменными на протяжении всего выполнения программы. Например, вам может потребоваться напечатать сообщение пользователю в случае успешного выполнения какой-либо операции. Сообщение об успехе, скорее всего, будет одним и тем же при каждом запуске приложения. Это жестко закодированное значение также можно назвать константой или буквальным значением.

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

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

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

Цели обучения

В этом модуле вы:

• Создадите литеральные значения для пяти основных типов данных.
• Научитесь объявлять и инициализировать переменные
• научитесь получать и устанавливать значения в переменных
• Разрешите компилятору определять тип данных для вашей переменной при инициализации.

Упражнение. Вывод литеральных значений

Что такое литеральное значение?

Литеральное значение — это постоянное значение, которое никогда не меняется. Ранее вы отображали литеральную строку на консоли вывода. Другими словами, вы буквально хотели, чтобы эта строка буквенно-цифровых символов H, e, l, l, o и т. д. отображалась в консоли вывода.

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

Печать различных литеральных типов данных

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

Когда вы начнете работать в окне кода, вы можете заметить, что определенный синтаксис окрашивается в разные цвета для обозначения ключевых слов, операторов, типов данных и т. д. Начните обращать внимание на цвета. Это может помочь вам обнаружить синтаксические ошибки при вводе символов и помочь вам более эффективно понимать код.

Используйте символьные литералы

Если вам нужен только один буквенно-цифровой символ, выведенный на экран, вы можете создать символьный литерал, заключив один буквенно-цифровой символ в одинарные кавычки. Термин char является сокращением от character (символ). В C# этот тип данных официально называется «char», но часто его называют «символьным».

1. Добавьте следующую строку кода в редакторе кода:

Console.WriteLine('b');

2. Исследуйте введенный вами код.

Обратите внимание, что буква b заключена в одинарные кавычки «b». Одинарные кавычки создают символьный литерал. Напомним, что использование двойных кавычек создает строковый тип данных.

3. Нажмите зеленую кнопку «Выполнить», чтобы запустить код. В окне вывода вы должны увидеть следующий результат:

b

Если вы введете следующий код:

Console.WriteLine('Hello World!');

Вы получите следующую ошибку:

(1,19): error CS1012: Too many characters in character literal

Обратите внимание на одинарные кавычки, окружающие Hello World!. При использовании одинарных кавычек компилятор C# ожидает один символ. Однако в данном случае использовался синтаксис символьного литерала, но вместо него было указано 12 символов!

Как и в случае со строковым типом данных, вы используете char всякий раз, когда у вас есть один буквенно-цифровой символ для представления (а не для вычислений).

Использование целочисленных литералов

Если вы хотите отобразить числовое целое число (без дробей) в консоли вывода, вы можете использовать литерал int. Термин int является сокращением от integer, которое вы можете узнать, изучая математику. В C# этот тип данных официально называется «int», но часто его называют «целым числом». Литерал int не требует никаких других операторов, таких как строка или символ.

1. Добавьте следующую строку кода в редакторе кода:

Console.WriteLine(123);

2. Нажмите зеленую кнопку «Выполнить», чтобы запустить код. В консоли вывода вы должны увидеть следующий результат:

123

Использование литералов с плавающей запятой

Число с плавающей запятой — это число, содержащее десятичную дробь, например 3,14159. C# поддерживает три типа данных для представления десятичных чисел: float, double и decimal. Каждый тип поддерживает разную степень точности.

Float Type    Precision
----------------------------
float         ~6-9 digits
double        ~15-17 digits
decimal        28-29 digits

Здесь точность отражает количество точных цифр после запятой.

1. Добавьте следующую строку кода в редакторе кода:

Console.WriteLine(0.25F);

2. Нажмите зеленую кнопку «Выполнить», чтобы запустить код. В консоли вывода вы должны увидеть следующий результат:

0.25

Обратите внимание, что тип данных float является наименее точным, поэтому лучше использовать этот тип данных для фиксированных дробных значений, чтобы избежать непредвиденных ошибок вычислений.

3. Добавьте следующую строку кода в редакторе кода:

Console.WriteLine(2.625);

Чтобы создать double литерал, просто введите десятичное число. Компилятор по умолчанию использует double литерал, когда десятичное число вводится без суффикса литерала.

4. Нажмите зеленую кнопку «Выполнить», чтобы запустить код. В окне вывода вы должны увидеть следующий результат:

2.625

5. Добавьте следующую строку кода в редакторе кода:

Console.WriteLine(12.39816m);

Чтобы создать decimal литерал, добавьте букву m после числа. В этом контексте m называется буквальным суффиксом. Суффикс-литерал сообщает компилятору, что вы хотите работать со значением десятичного типа. В качестве суффикса десятичной дроби можно использовать строчную или прописную букву М. 6. Нажмите зеленую кнопку «Выполнить», чтобы запустить код. В окне вывода вы должны увидеть следующий результат:

12.39816

Использование логических литералов

Если вы хотите напечатать значение, представляющее истину или ложь, вы можете использовать логический литерал.

Термин bool является сокращением от Boolean. В C# они официально называются «bool», но часто разработчики используют термин «логическое значение».

1. Добавьте следующие строки кода в редактор кода:

Console.WriteLine(true);
Console.WriteLine(false);

2. Запустите приложение и проверьте результат

true
false

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

Чем важны типы данных?

Типы данных играют центральную роль в C#. Фактически, акцент на типах данных является одной из ключевых особенностей C# по сравнению с другими языками, такими как JavaScript. Разработчики C# считали, что они могут помочь разработчикам избежать распространенных ошибок в программном обеспечении, обеспечив соблюдение типов данных. Вы увидите, как эта концепция раскрывается, когда вы больше узнаете о C#.

Типы данных определяют возможности

Ранее вы видели, что строки и символы используются для «представления, а не вычислений». Если вам нужно выполнить математическую операцию над числовыми значениями, вам следует использовать целое или десятичное число. Если у вас есть данные, которые используются для представления или манипулирования текстом, вам следует использовать тип данных string или char.

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

То же самое можно сказать и о bool. Если вам нужно работать со словами «истина» и «ложь» в вашем приложении, вы должны использовать строку. Однако, если вам нужно работать с понятием true или false при выполнении оценки, вы используете bool.

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

Console.WriteLine("123");
Console.WriteLine(123);

Console.WriteLine("true");
Console.WriteLine(true);

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

Резюме

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

• строка для слов, фраз или любых буквенно-цифровых данных для представления, а не для вычислений
• char для одного буквенно-цифрового символа
• int для целого числа
• decimal для числа с дробной частью
• bool для значения true/false

Объявление переменных

Литерал — это буквально жестко запрограммированное значение. Жестко запрограммированные значения — это значения, которые являются постоянными и неизменными на протяжении всего выполнения программы. Однако большинство приложений потребуют от вас работы со значениями, о которых вы заранее мало что знаете. Другими словами, вам придется работать с данными, поступающими от пользователей, из файлов или со всей сети.

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

Что такое переменная?

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

Имя переменной — это понятная для человека метка, которую компилятор присваивает адресу памяти. Когда вы хотите сохранить или изменить значение по этому адресу памяти или когда вы хотите получить сохраненное значение, вы просто используете созданное вами имя переменной.

Объявить переменную

Чтобы создать новую переменную, необходимо сначала объявить тип данных переменной, а затем дать ей имя.

string firstName;

В данном случае вы создаете новую переменную строкового типа с именем firstName. С этого момента эта переменная может хранить только строковые значения.

Вы можете выбрать любое имя, если оно соответствует нескольким синтаксическим правилам C# для именования переменных.

Правила и соглашения об именах переменных

Один разработчик программного обеспечения однажды сказал: «Самая сложная часть разработки программного обеспечения — это присваивание вещам имен». Имя переменной не только должно соответствовать определенным синтаксическим правилам, но и использоваться для того, чтобы сделать код более читабельным и понятным. Это многого можно требовать от одной строки кода!

Вот несколько важных соображений по поводу имен переменных:

• Имена переменных могут содержать буквенно-цифровые символы и символ подчеркивания. Специальные символы, такие как символ решетки # (также известный как символ числа или символ фунта) или символ доллара $, не допускаются.
• Имена переменных должны начинаться с алфавитной буквы или подчеркивания, а не с цифры.
• Имена переменных чувствительны к регистру, что означает, что string Value; и string value; это две разные переменные.
• Имена переменных не должны быть ключевым словом C#. Например, нельзя использовать следующие объявления переменных: decimal decimal; или string string;.

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

Вот некоторые соглашения по кодированию переменных:

• В именах переменных следует использовать верблюжий регистр — стиль написания, при котором в начале первого слова используется строчная буква, а в начале каждого последующего слова — прописная буква. Например, строка thisIsCamelCase;.
• Имена переменных должны начинаться с алфавитной буквы. Разработчики используют подчеркивание для особых целей, поэтому постарайтесь пока его не использовать.
• Имена переменных должны быть описательными и значимыми в вашем приложении. Выберите имя для своей переменной, которое представляет тип данных, которые она будет хранить.
• Имена переменных должны состоять из одного или нескольких слов, сложенных вместе. Не используйте сокращения или сокращения, поскольку имя переменной (и, следовательно, ее назначение) может быть непонятно другим, читающим ваш код.
• Имена переменных не должны включать тип данных переменной. Вы можете увидеть совет по использованию такого стиля, как string strValue;. Этот совет уже не актуален

Пример string firstName; следует всем этим правилам и соглашениям, при условии, что вы хотите использовать эту переменную для хранения данных, представляющих чье-то имя.

Примеры имен переменных

Вот несколько примеров объявлений переменных с использованием типов данных, о которых вы узнали до сих пор:

char userOption;

int gameScore;

decimal particlesPerMillion;

bool processedCustomer;

Резюме

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

Упражнение. Установка и получение значений из переменных

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

Упражнение – Работа с переменными

В этом упражнении вы объявите переменную, присвоите ей значение, получите ее значение и многое другое.

1. Введите следующий код в редакторе кода:

string firstName;
firstName = "Bob";

Чтобы объявить переменную, вы вводите тип данных, который хотите использовать, а затем имя переменной. Чтобы присвоить значение переменной, вы используете оператор присваивания, который представляет собой одиночный символ равенства =.

Присвоение значения также называется «установкой переменной» или просто операцией «установки».

Неправильное присвоение значение переменной

Важно отметить, что присвоение происходит справа налево. Другими словами, компилятор C# должен сначала понять значение в правой части оператора присваивания, а затем он может выполнить присвоение переменной в левой части оператора присваивания. Если вы измените порядок, вы запутаете компилятор C#.

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

string firstName;
"Bob" = firstName;

Теперь запустите код. В консоли вывода вы увидите следующую ошибку:

(2,1): error CS0131: The left-hand side of an assignment must be a variable, property or indexer

Присвойте переменной значение неправильного типа данных.

Вы узнали, что C# был разработан для обеспечения соблюдения типов. Когда вы работаете с переменными, соблюдение типов означает, что вы не можете присвоить значение одного типа данных переменной, объявленной для хранения другого типа данных.

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

int firstName;
firstName = "Bob";

Теперь запустите код. В консоли вывода вы увидите следующую ошибку:

(2,9): error CS0029: Cannot implicitly convert type 'string' to 'int'

Сообщение об ошибке намекает на то, что компилятор C# пытается сделать за кулисами. Он пытался «неявно преобразовать» строку «Боб» в значение int; однако это невозможно. Несмотря на это, C# попытался выполнить преобразование, но потерпел неудачу, поскольку для слова «Боб» не существует числового эквивалента. Позже вы узнаете больше о неявном и явном преобразовании типов. А пока просто запомните, что переменная может содержать только значения, соответствующие ее указанному типу данных.

Получить значение, сохраненное в переменной.

Чтобы получить значение из переменной, вы просто используете имя переменной. В этом примере будет установлено значение переменной, затем получено это значение и отображено в консоли. Измените написанный вами код, чтобы он соответствовал следующему коду:

string firstName;
firstName = "Bob";
Console.WriteLine(firstName);

Теперь запустите код. В консоли вывода вы увидите следующий результат

Bob

Получение значения из переменной также называется «получением переменной» или просто операцией «получения». Когда вы пишете строки кода, вы увидите, что компилятор проверяет ваш код и выявляет возможные ошибки. Компилятор — отличный инструмент, который поможет вам быстрее исправить код. Теперь, когда вы знакомы с различными типами ошибок, вы можете быстро исправить ошибки с помощью сообщений об ошибках компилятора.

Переназначить значение переменной

Вы можете повторно использовать и переназначать переменную столько раз, сколько захотите. Этот пример иллюстрирует эту идею. Измените написанный вами код, чтобы он соответствовал следующему коду:

string firstName;
firstName = "Bob";
Console.WriteLine(firstName);
firstName = "Liem";
Console.WriteLine(firstName);
firstName = "Isabella";
Console.WriteLine(firstName);
firstName = "Yasmin";
Console.WriteLine(firstName);

Теперь запустите код. В консоли вывода вы увидите следующий результат:

Bob
Liem
Isabella
Yasmin

Инициализировать переменную

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

string firstName;
Console.WriteLine(firstName);

Теперь запустите код. В консоли вывода вы увидите следующий результат:

(2,19): error CS0165: Use of unassigned local variable 'firstName'

Чтобы избежать возможности появления неназначенной локальной переменной, рекомендуется установить значение как можно скорее после его объявления.

Фактически, вы можете выполнить как объявление, так и установку значения переменной в одной строке кода. Этот метод называется инициализацией переменной. Измените написанный вами код, чтобы он соответствовал следующему коду:

string firstName = "Bob";
Console.WriteLine(firstName);

Теперь запустите код. В консоли вывода вы увидите следующий результат:

Bob

Резюме

• Вы должны присвоить (set) значение переменной, прежде чем сможете получить (get) значение из переменной
• Вы можете инициализировать переменную, присвоив ей значение в месте объявления
• Назначение происходит справа налево
• В качестве оператора присваивания используется один символ равенства
• Чтобы получить значение из переменной, вы просто используете имя переменной

Объявление неявно типизированных локальных переменных

Компилятор C# работает незаметно, помогая вам при написании кода. Он может определить тип данных вашей переменной по ее инициализированному значению. В этом модуле вы узнаете об этой функции, называемой неявно типизированными локальными переменными.

Что такое неявно типизированные локальные переменные?

Неявно типизированная локальная переменная создается с помощью ключевого слова var, за которым следует инициализация переменной. Например:

var message = "Hello world!";

В этом примере строковая переменная была создана с использованием ключевого слова var вместо ключевого слова string.

Ключевое слово var сообщает компилятору C#, что тип данных подразумевается присвоенным значением. После того, как тип подразумевается, переменная действует так же, как если бы для ее объявления использовался фактический тип данных. Ключевое слово var используется для экономии нажатий клавиш, когда типы длинные или когда тип очевиден из контекста.

Например:

var message = "Hello world!";

Поскольку переменной message сразу же присваивается строковое значение «Hello World!», компилятор C# понимает намерение и обрабатывает каждый экземпляр сообщения как экземпляр типа string.

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

var message = "Hello World!";
message = 10.703m;

Если вы запустите этот код, вы увидите следующее сообщение об ошибке.

(2,11): error CS0029: Cannot implicitly convert type 'decimal' to 'string'

Другие языки программирования используют ключевое слово var по-другому. В C# тип переменных присваивается компилятором независимо от того, используете ли вы фактическое имя типа данных или разрешаете компилятору подразумевать тип данных. Другими словами, тип блокируется во время объявления и, следовательно, никогда не сможет хранить значения другого типа данных.

Переменные, использующие varключевое слово, должны быть инициализированы.

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

var message;

Если вы попытаетесь запустить этот код во время его компиляции, вы увидите следующий вывод:

(1,5): error CS0818: Implicitly-typed variables must be initialized

Зачем использовать ключевое слово var?

Ключевое слово var широко распространено в сообществе C#. Если вы посмотрите на пример кода в книге или в сети, то, скорее всего, увидите varключевое слово вместо фактического имени типа данных, поэтому важно понимать его использование.

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

По мере того, как вы начинаете, рекомендуется продолжать использовать фактическое имя типа данных при объявлении переменных, пока вы не почувствуете себя более комфортно при работе с кодом. Использование типа данных при объявлении переменных поможет вам быть целенаправленным при написании кода.

Резюме

Вот что вы узнали об этом ключевом слове var на данный момент:

• Ключевое слово var сообщает компилятору, что тип данных переменной следует определять на основе значения, которому она инициализирована.
• Скорее всего, вы встретите это ключевое слово var, читая код других людей;тем не менее, по возможности следует использовать явный тип данных когда возможно.

Задание

Задача: отобразить литеральные значения и значения переменных.

1. Сохраните в переменных следующие значения:

Bob 
3 
34.4

Этим переменным следует дать имена, отражающие их назначение. Убедитесь, что вы выбрали правильный тип данных для каждой переменной в зависимости от типа данных, которые она будет хранить. Наконец, вы объедините переменные со строками-литералами, переданными в серию команд вывода строки чтобы сформировать полное сообщение. 2. Напишите код в редакторе, чтобы отобразить следующее сообщение

Hello, Bob! You have 3 messages in your inbox. The temperature is 34.4 celsius.

При формировании строки следует обращаться к переменным а не хардкодить значения.