C# — Как при вводе двух слов присвоить переменную второму слову


Содержание

Переменные

Синтаксис объявления переменных в C# выглядит следующим образом:

Объявить можно переменную любого действительного типа. Важно подчеркнуть, что возможности переменной определяются ее типом. Например, переменную типа bool нельзя использовать для хранения числовых значений с плавающей точкой. Кроме того, тип переменной нельзя изменять в течение срока ее существования. В частности, переменную типа int нельзя преобразовать в переменную типа char.

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

Инициализация переменной

Задать значение переменной можно, в частности, с помощью оператора присваивания. Кроме того, задать начальное значение переменной можно при ее объявлении. Для этого после имени переменной указывается знак равенства (=) и присваиваемое значение. Если две или более переменные одного и того же типа объявляются списком, разделяемым запятыми, то этим переменным можно задать, например, начальное значение. Ниже приведена общая форма инициализации переменной:

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

В C# используются два метода для обеспечения инициализации переменных перед пользованием:

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

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

Например, в C# поступить следующим образом нельзя:

Динамическая инициализация

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

В данном примере объявляются три локальные переменные i1, i2, result, первые две из которых инициализируются константами, а переменная result инициализируется динамически с использованием метода Math.Sqrt(), возвращающего квадратный корень выражения. Следует особо подчеркнуть, что в выражении для инициализации можно использовать любой элемент, действительный на момент самой инициализации переменной, в том числе вызовы методов, другие переменные или литералы.

Неявно типизированные переменные

Как пояснялось выше, все переменные в C# должны быть объявлены. Как правило, при объявлении переменной сначала указывается тип, например int или bool, а затем имя переменной. Но начиная с версии C# 3.0, компилятору предоставляется возможность самому определить тип локальной переменной, исходя из значения, которым она инициализируется. Такая переменная называется .

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

Единственное отличие неявно типизированной переменной от обычной, явно типизированной переменной, — в способе определения ее типа. Как только этот тип будет определен, он закрепляется за переменной до конца ее существования.

Неявно типизированные переменные внедрены в C# не для того, чтобы заменить собой обычные объявления переменных. Напротив, неявно типизированные переменные предназначены для особых случаев, и самый примечательный из них имеет отношение к языку интегрированных запросов (LINQ). Таким образом, большинство объявлений переменных должно и впредь оставаться явно типизированными, поскольку они облегчают чтение и понимание исходного текста программы.

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

Ввод строк из нескольких слов

Строки и символы: кавычки или апострофы?

Объявление, инициализация и присвоение строк

Объявление строки происходит стандартным способом: указывается тип string и имя переменной.

string str1, str2, str3;

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

При инициализации строки мы ее объявляем и сразу же присваиваем:

//Инициализация переменной name

string name = «Андрей»;

Не нашли то, что искали? Воспользуйтесь поиском:

Лучшие изречения: Учись учиться, не учась! 10395 — | 7893 — или читать все.

188.64.174.135 © studopedia.ru Не является автором материалов, которые размещены. Но предоставляет возможность бесплатного использования. Есть нарушение авторского права? Напишите нам | Обратная связь.

Отключите adBlock!
и обновите страницу (F5)

очень нужно

C# как можно присвоить значение переменной имя которой записано в другой переменной?

есть набор переменных (w_a_01,w_a_02,w_a_03. ) каждая поб своим именем тип у всех string

и есть переменная (name тип тоже string) значение которой имя одной из переменной набора. типа name = «w_a_01»

также есть label в который должна выводиться информация

собственно вопрос каким образом можно присвоить label.text значение переменной имя которой записано в переменной name

язык програмирования C#

соответственно интересует и как можно сделать наоборот взять значение из label.text и присвоить той переменной имя которой записано в name

если можно с примером кода
Заранее спасибо

12 ответов

дело в том что все объекты динамические т.е. параметры того же label берутся из файла скина и вопрос именно как передать значение в данный объект если заранее неизвестно с какой переменной он будет работать а известно это только из файла скина в котором можно чтото прописать например название переменной.
Т.е. у этого label может быть значение любой из описанных переменны

поэтому собственно и вопрос как это лучше сделать

если есть какие либо варианты кода по подобны реализациям буду премного благодарен

А почему прописывать именно название переменной, почему не само значение ? Или можно сделать метод, который это значение вернет. Не привязывайся к названиям переменных. Ни к чему хорошему это не приведет.

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

каким образом он его может вернуть если изначально неизвестно откуда возвращать? узнать это можно только считав файл скина.

ну простой пример в самой программе есть параметр ну например ширина экрана X

динамически из скина создаются 5 объектов

как этот X присвоить второму объекту

а при следующем запуске юзер может поменятьчто этот Х присваивать не второму а 5 му объекту

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

а объектов может быть куча боольшая и параметров тоже боольшая куча

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

Что вы подразумеваете под «переменными»?
Если обычние локальные переменные, то изменить ее значение, основываясь лишь на имени (string) — невозможно. Сами подумайте почему.

Если некоторое поле или свойство класса, то вполне реально, и отражение (reflection) вам в помошь, примеры для C# на форуме уже встречались — пользуйтесь поиском.

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

Lemings, Стандартные .ini файлы. Нет разницы в какой последовательности в них указаны пары ключ-значение.

Файл skin.ini:
[Options]
x=10
y=40

Программко:
конфиг = читать_файлег(«skin.ini»);
int y = конфиг.дай_значение(«Options», «y»);
int x = конфиг.дай_значение(«Options», «x»);

Вот в таком роде.
Ах, да! Это же С#. Тогда .xml

hardcase
по поводу названия впринципе понятно
но поэтому собсно и вопрос как реализовать :)

xml формат тут впринципе непричем совсем
в чем хранить скин это дело десятое.

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

значение переменной формируется программой и хранить его мне ненужно

нужно вывести значение переменной в объект типа label (из скина беруться параметры и данные объекты формируются динамически) но только в тот в который указан в скине

пример
сформировано 10 объектов типа label (label1,label2,label3. ) формируется на основании файла скина

в скине прописано label1, , ,
ну и так далее для всех остальных label

и есть куча переменных в которых содержаться данные (w_a_01,w_a_02,w_a_03. )

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

как основываясь на данных параметрах в свойство объекта label.text передать значение из основываясь на параметре записаном в скине для данного label.text

чтобы проще было фай скина выглядит примерно так

label1,25,10,w_a_07
label2,25,20,w_a_03
label3,25,30,w_a_08
label4,25,40,w_a_09
label5,25,50,w_a_10

соответственно на основании его в
label1 выводится значение переменной w_a_07
label2 выводится значение переменной w_a_03
label3 выводится значение переменной w_a_08
label4 выводится значение переменной w_a_09
label5 выводится значение переменной w_a_10

естесно если поменять в скине значения то выводиться должно по другому

принципииального значения как хранить данные в переменных или массиве или кактоеще никакого нет

Переменные C#

Дата изменения: 30.06.2020

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

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

C# является языком со статической типизацией. Это значит, что при создании переменной обязательно определяется тип хранящихся в ней данных, и этот тип нельзя изменить в ходе программы. (Исключение — тип dynamic)
От типа также зависит объем памяти, выделяемый под переменную. Такая строгость помогает избегать ошибок и эффективно использовать память, а также является «дружественной» для компилятора, превращающего программу на языке C# в машинный код.

Подробнее типы данных разберем в следующих уроках, а пока для ясности приведем базовые типы данных в C#:

Целочисленные: sbyte, short, ushort, int, uint, long, ulong

Числа с плавающей запятой: float, double

Десятичные: decimal

Логическое значение: bool
Строка: string

Символ: char

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

Объявление переменной в C# имеет следующий общий вид:

Где data_type – существующий тип данных (то есть один из встроенных типов в C# либо созданный пользователем), а variables – одна или несколько переменных, которые будут хранить значения типа data_type.

Примеры объявления переменных:

Инициализация переменных в C#

Инициализация переменной (первое присвоение значения) выглядит так:

При этом инициализировать переменную можно сразу при ее объявлении в виде:

Переменную, неинициализированную при объявлении, называют переменной с отложенной инициализацией.

Примеры инициализации переменных:

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

Динамическая инициализация

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

Константы

Константы хранят данные, которые не могут быть изменены в процессе выполнения программы. Их значения присваиваются в конце компиляции. Для объявления констант в C# используется ключевое слово const:

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

Цукерберг рекомендует:  Django Admin что это такое и зачем

Неявная типизация

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

После инициализации, неявно типизированная переменная не имеет никаких отличий от явно типизированной.

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

Программирование на C, C# и Java

Уроки программирования, алгоритмы, статьи, исходники, примеры программ и полезные советы

ОСТОРОЖНО МОШЕННИКИ! В последнее время в социальных сетях участились случаи предложения помощи в написании программ от лиц, прикрывающихся сайтом vscode.ru. Мы никогда не пишем первыми и не размещаем никакие материалы в посторонних группах ВК. Для связи с нами используйте исключительно эти контакты: vscoderu@yandex.ru, https://vk.com/vscode

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

Рассмотрим, как поменять местами значения двух переменных в коде программы. Статья предназначена тем, кто только начинает делать первые шаги в программировании.

Как только вы начнете писать свою второю в жизни программу (первая – вывод слов Hello World), вы столкнетесь с необходимостью обмена значениями между двумя числовыми переменными, поскольку манипуляции с данными непременно это предполагают. В примерах кода, которые приводятся в статье мы оперируем с целочисленными переменными типа int, но данные примеры легко адаптировать под любой вид числовых переменных: byte, long, float, double и т.п. Для этого вам будет достаточно заменить все ключевые слова int, на требуемый тип данных.

Примеры подходят и будут работать во всех Си-подобных языках программирования: C, C++, C#; а также в языке Java.

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

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

Начнем с тезиса о том, что переменные в программе имеют содержимое. Они содержат информацию. Для того, чтобы провести какую-либо аналогию с жизнью, нужно подумать: а какие предметы что-нибудь в себе содержат? Первое, что приходит на ум – это ёмкость с жидкостью.

Пусть у нас есть два стакана: в одном налито молоко, а в другом кока-кола. Как нам перелить содержимое одного стакана в другой (нельзя же смешивать эти два совершенно несовместимых продукта) [заметили аналогию? ведь содержимое двух переменных нам тоже нужно поменять местами]? Ответ очевиден – понадобится третий (пустой) стакан. С помощью него удастся перелить содержимое одного стакана в другой. Вот так:

  1. Перелить молоко из первого стакана в третий.
  2. Перелить кока-колу из второго стакана в первый.
  3. Из третьего стакана перелить молоко во второй стакан. Готово!

Иллюстрация действий приводится на рисунке ниже.

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

Пусть даны переменные a и b, и их значения нужно поменять местами. Нам понадобится промежуточная временная третья переменная, назовем её temp (сокращение от английского слова temporary – временный). Чтобы выполнить замену, придется также выполнить три действия:


  1. Присвоим переменной temp значение из переменной a.
  2. Присвоим a значение b.
  3. Присвоим b значение переменный temp. Готово!

Реализуем описанный выше алгоритм действий и составим программу обмена значениями двух переменных величин. Ниже представлен её код:

Как замкнуть переменную в C# и не выстрелить себе в ногу

Еще в далеком 2005 с выходом стандарта C# 2.0 появилась возможность передачи переменной в тело анонимного делегата посредством ее захвата (или замыкания, кому как угодно) из текущего контекста. В 2008 вышел в свет новый стандарт C# 3.0, принеся нам лямбды, пользовательские анонимные классы, LINQ запросы и многое другое. Сейчас на дворе январь 2020 и большинство C# разработчиков с нетерпением ждут релиз стандарта C# 7.0, который должен привнести много новых полезных «фич». А вот фиксить старые «фичи», никто особо не торопится. Поэтому способов случайно выстрелить себе в ногу по-прежнему хватает. Сегодня мы поговорим об одном из их, и связан он с не совсем очевидным механизмом захвата переменных в тело анонимных функций в языке C#.

Введение

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

А теперь ближе к делу. Я напишу простой пример кода, а вам необходимо будет сказать, что конкретно в данном случае будет выведено в консоль.

И так, приступим:

А теперь внимание, ответ:

Эта статья для тех, кто посчитал иначе. Давайте разберёмся в причинах такого поведения.

Почему так происходит?

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

В данном случае метод Foo из приведенного в начале участка кода объявлен внутри класса Program. Для лямбды () => Console.WriteLine(i) компилятором был сгенерирован класс-контейнер c__DisplayClass1_0, а внутри него — поле i содержащее одноименную захваченную переменную и метод b__0 содержащий тело лямбды.

Давайте рассмотрим дизассемблированный IL код метода b__0 (тело лямбды) с моими комментариями:

Все верно, это именно то, что мы делаем внутри лямбды, никакой магии. Идем дальше.

Как известно, тип int (полное название — Int32) является структурой, а значит при передаче куда-либо передается не ссылка на него в памяти, а копируется непосредственно его значение.

Копироваться значение переменной i должно (по логике вещей) во время создания экземпляра класса-контейнера. И если вы ответили неверно на мой вопрос в начале статьи, то вероятнее всего вы ожидали, что контейнер будет создан непосредственно перед объявлением лямбды в коде.

На самом деле переменная i после компиляции вообще не будет создана внутри метода Foo. Вместо этого будет создан экземпляр класса-контейнера c__DisplayClass1_0, а его поле i будет проинициализировано вместо локальной переменной i значением 0. Более того, везде, где до этого мы использовали локальную переменную i, теперь используется поле класса-контейнера.

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

В итоге мы получаем один экземпляр класса-контейнера на все итерации цикла for. А добавляя при каждой итерации в список actions новую лямбду, мы, по факту, добавляем в него одну и ту же ссылку на ранее созданный экземпляр класса-контейнера. В результате чего, когда мы обходим циклом foreach все элементы списка actions, то все они содержат один и тот же экземпляр класса-контейнера. А если учесть, что цикл for выполняет инкремент к значению итератора после каждой итерации (даже после последней), то значение поля i внутри класса контейнера после выхода из цикла становится равным десяти после выполнения цикла for.

Убедиться во всем мной вышесказанном можно, взглянув на дизассемблированный IL код метода Foo (естественно с моими комментариями):

Вывод

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

Интересный факт заключается в том, что аналогичное поведение было и у цикла foreach до стандарта C# 5.0. Microsoft буквально засыпали жалобами о неинтуитивном поведении в баг-трекере, после чего с выходом стандарта C# 5.0 это поведение было изменено посредством объявления переменной итератора внутри каждой итерации цикла, а не перед ним на этапе компиляции, но для всех остальных конструкций циклов подобное поведение осталось без изменений. Подробнее об этом можно прочитать по ссылке в разделе Breaking Changes.

Вы спросите, как же избежать данной ошибки? На самом деле ответ очень простой. Необходимо следить за тем, где и какие переменные вы захватываете. Помните, класс-контейнер будет создан там, где вы объявили свою переменную, которую в дальнейшем будете захватывать. Если захват происходит в теле цикла, а переменная объявлена за его пределами, то необходимо переприсвоить ее внутри тела цикла в новую локальную переменную. Корректный вариант приведенного в начале примера мог бы выглядеть так:

Если выполнить данный код, то в консоль будут выведены числа от 0 до 9 как и ожидалось:

Посмотрев на IL код цикла for из данного примера, мы увидим, что экземпляр класса-контейнера будет создаваться каждую итерацию цикла. Таким образом, список actions будет содержать ссылки на разные экземпляры с корректными значениями итераторов.

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

Совсем недавно мы — разработчики статического анализатора PVS-Studio — реализовали очередную диагностику, направленную на поиск ошибок неправильного захвата переменных в анонимные функции внутри циклов. В свою же очередь спешу предложить вам проверить ваш код на наличие ошибок и опечаток нашим статическим анализатором.

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

Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Ivan Kishchenko. How to capture a variable in C# and not to shoot yourself in the foot

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

С#: присвоить одно значение нескольким переменным в одном выражении

Есть ли какой-либо способ (просто из любопытства, потому что я столкнулся с несколькими присвоениями одинаковых значений для множества переменных сегодня) в С#, чтобы сразу назначить одно значение нескольким переменным в одном выражении?

Что-то в этих строках (псевдокод):

Наверное, нет, но я подумал, что стоит попробовать, если на самом деле возможно что-то подобное!

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

Возьмем, например, класс, который записывается в консоль каждый раз, когда вызывается get и set accessor.

Это приведет к выводу

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

Это будет желать:

‘num2 = 5’ присваивание возвращает возвращаемое значение.

Это позволяет вам делать сумасшедшие вещи, такие как num1 = (num2 = 5) +3; , которые будут назначать 8 для num1, хотя я бы не рекомендовал делать это как не очень читаемый.

Управление одной формой из другой

Иногда бывает нужно обратиться к элементам какой-то формы из другой в процессе выполнения программы. Например, есть форма Form1, из нее мы открываем другую Form2 и теперь, работая в форме Form2 нужно обратиться, получить доступ к элементам родительской формы Form1. Я нашел несколько способов как это сделать.

1-й способ. Передача ссылки в public переменную.

Перед открытием формы, передаем ссылку на нужный элемент в переменную public вызываемой формы.

В форме Form2 переменная, в которую передавали ссылку, будет теперь соответствовать кнопке button1 из формы Form1

2-й способ. Передача ссылки в дочернюю форму.

Суть примерна та же, то и в 1-м способе. При открытии формы Form2 передаем в нее ссылку на элемент, который планируем потом менять.

Теперь в форме Form2 нужно создать переменную, которая будет содержать ссылку на эту кнопку и через нее будем обращаться к кнопке на Form1 (строки 5,7,9 и 15).

3-й способ. Доступ ко всей родительской форме.

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

Шаг 1. В файле Program.cs создаем публичную переменную f1 (строка 5).

Шаг 2. Открываем Form1.Designer.cs и в нем у элементов, к которым нужно будет обратиться из другой формы, меняем private на public . Например, сделаем доступной для изменений кнопку button1 на форме Form1.

Шаг 3. При создании формы Form1 присваиваем переменной f1 ссылку на эту форму (строка 7)

Переменные и константы в C#

Важнейшим свойством алгоритма (а значит и программы), как известно, является массовость (обработка различных данных). Поэтому в программировании появились переменные, предназначенные для размещения данных. Любая переменная должна объявлена (присвоено имя — идентификатор) и инциализирована (задано какое-либо значение, принадлежащее к определенному типу). Допускается динамическая инициализация переменных (в процессе выполнения кода программы). Возможно использование неявно типизированных переменных. Поясняется целесообразность объявления констант.

Цукерберг рекомендует:  С++ - Из С++ на Ассемблер

Рассмотрим эти понятия на примерах.

Идентификатор — это имя сущности в коде. Существует стандарт именования идентификаторов, который следует использовать в коде.
Идентификатор может :
— начинаться с символа «_»;
— содержать заглавные и строчные буквы в формате Unicode;
— регистр имеет значение.
Идентификатор не может :
— начинаться с цифры;
— начинаться с символа, если это ключевое слово;
— содержать более 511 символов.
По соглашению (не обязательно, но желательно):
1. Параметры, локальные переменные и частные (private) свойства и методы пишутся в camel case (слова пишутся слитно, без пробелов и нижних подчеркиваний, каждое новое слово кроме первого с заглавной буквы, например, myVariavle).
2. Все остальные идентификаторы — в стиле Pascal case (тоже самое, что и camel case, только первое слово с заглавной буквы, например, MyClass).
Мое примечание к подсказке. Вы можете использовать кроме латинских (английских) букв и буквы русского алфавита (как, впрочем и других национальных алфавитов), однако не увлекайтесь этим. Более привычно, когда в идентификаторе используются буквы английского алфавита, цифры и символ подчеркивания (прежний стандарт).

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

Шаблон объявления переменной в C# выглядит следующим образом:
ТипДанных Идентификатор;
Например:
int k1;
System.Int32 _counter;
Int32 счетчик;

Все три переменных: k1, _counter, счетчик являются переменными одного типа, занимают в памяти 4 байта.

Заметим, что использование символов Юникода в написании идентификаторов разрешает использование букв национальных алфавитов, включая русский.

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

Кроме того, тип переменной нельзя изменять в течение срока ее существования. В частности, переменную типа int нельзя преобразовать в переменную типа char.

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

Инициализация переменной

Задать значение переменной можно, в частности, с помощью оператора присваивания. Кроме того, задать начальное значение переменной можно при ее объявлении. Для этого после имени переменной указывается знак равенства (=) и присваиваемое значение. Если две или более переменные одного и того же типа объявляются списком, разделяемым запятыми, то этим переменным можно задать, например, начальное значение.
Ниже приведена общая форма инициализации переменной:
int k1 = 10;
char символ = ‘Z’;
float f = 15.7F;
int x = 5, y = 10, z = 12;

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

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

Например, в C# поступить следующим образом нельзя:
public static int принт()
<
int d;
Console.WriteLine(d); return 0;
>

Получим при компиляции сообщение об ошибке: Использование локальной переменной “d”, которой не присвоено значение.

Динамическая инициализация

В приведенных выше примерах в качестве инициализаторов переменных использовались только константы, но в C# допускается также динамическая инициализация переменных с помощью любого выражения, действительного на момент объявления переменной:
int a = 3, b = 4;
// Инициализируем динамически переменную c:
double c = Math.Sqrt(a * a + b * b);
Console.WriteLine(«<0>», c);

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

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

Неявно типизированные переменные

Теперь некоторое отступление от строгих правил, привыкайте и к исключениям (по англ. — Exception). Как пояснялось выше, все переменные в C# должны быть объявлены. Как правило, при объявлении переменной сначала указывается тип, например int или bool, а затем имя переменной. Но начиная с версии C# 3.0, компилятору предоставляется возможность самому определить тип локальной переменной, исходя из значения, которым она инициализируется.
Такая переменная называется неявно типизированной. Неявно типизированная переменная объявляется с помощью ключевого слова var и должна быть непременно инициализирована.
Для определения типа этой переменной компилятору служит тип ее инициализатора, то есть значения, которым она инициализируется:
var n = 12; // переменная i инициализируется целочисленным литералом
var d = 12.3; // переменная d инициализируется литералом
// с плавающей точкой, имеющему тип double
var f = 0.34F; // переменная f теперь имеет тип float

Единственное отличие неявно типизированной переменной от обычной, явно типизированной переменной, — в способе определения ее типа. Как только этот тип будет определен, он закрепляется за переменной до конца ее существования.
Неявно типизированные переменные внедрены в C# не для того, чтобы заменить собой обычные объявления переменных. Напротив, неявно типизированные переменные предназначены для особых случаев, и самый примечательный из них имеет отношение к языку интегрированных запросов (LINQ).

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

Константы

Как следует из названия, константа — это переменная, значение которой не меняется за время ее существования. Предваряя переменную ключевым словом const при ее объявлении и инициализации, вы объявляете ее как константу:
const int N_max =100;
Идентификатор константы записывается по общим правилам написания идентификаторов (см. подсказку выше).
Ниже перечислены основные характеристики констант:
1. Они должны инициализироваться при объявлении, и однажды присвоенные им значения никогда не могут быть изменены.
2. Константа не может быть объявлена непосредственно в пространстве имен, но может быть объявлена либо в классе, либо в функции.
3. Значение константы должно быть вычислено во время компиляции.

Таким образом, инициализировать константу значением, взятым из другой переменной, нельзя. Если все-таки нужно это сделать, используйте поля только для чтения.
Константы всегда неявно статические. Нет необходимости включать модификатор static в объявление константы.
Использование констант в программах обеспечивает, по крайней мере, три преимущества:
1. Константы облегчают чтение программ, заменяя «магические» числа и строки читаемыми именами, назначение которых легко понять. Например, через константу N_max может задать максимальное количество элементов в массиве объектов, при необходимости это число может быть изменено всего лишь в одном операторе объявления константы.
2. Константы облегчают модификацию программ. Например, предположим, что в программе C# имеется константа IncomeTax (подоходный налог), которой присвоено значение 13 процентов. Если налог когда-нибудь изменится, вы можете модифицировать все вычисления налога, просто присвоив новое значение этой константе, и не понадобится просматривать код в поисках значений и изменять каждое из них, надеясь, что оно нигде не будет пропущено.
3. Константы позволяют избежать ошибок в программах. Если попытаться присвоить новое значение константе где-то в другом месте программы, а не там, где она объявлена, компилятор выдаст сообщение об ошибке.

В наших примерах константы используются достаточно часто.

Следующая небольшая тема раздела: Область видимости переменных

Строки (Руководство по программированию на C#) Strings (C# Programming Guide)

Строка — это объект типа String, значением которого является текст. A string is an object of type String whose value is text. Внутри программы текст хранится в виде упорядоченной коллекции объектов Char только для чтения. Internally, the text is stored as a sequential read-only collection of Char objects. В конце строки C# нет нуль-символов. Поэтому строка C# может содержать любое число внедренных нуль-символов (‘\0’). There is no null-terminating character at the end of a C# string; therefore a C# string can contain any number of embedded null characters (‘\0’). Свойство Length строки соответствует числу содержащихся в ней объектов Char , но не числу символов Юникода. The Length property of a string represents the number of Char objects it contains, not the number of Unicode characters. Для доступа к отдельным кодовым точкам Юникода в строке используйте объект StringInfo. To access the individual Unicode code points in a string, use the StringInfo object.

Сравнение строки и System.String string vs. System.String

В C# ключевое слово string является псевдонимом для String. In C#, the string keyword is an alias for String. Таким образом, String и string эквивалентны, их можно использовать независимо от используемого соглашения об именовании. Therefore, String and string are equivalent, and you can use whichever naming convention you prefer. Класс String предоставляет множество методов для безопасного создания, обработки и сравнения строк. The String class provides many methods for safely creating, manipulating, and comparing strings. Кроме того, язык C# перегружает некоторые операторы для упрощения типичных операций со строками. In addition, the C# language overloads some operators to simplify common string operations. Дополнительные сведения о ключевых словах см. в статье, посвященной строкам. For more information about the keyword, see string. Дополнительные сведения о типе и его методах см. здесь: String. For more information about the type and its methods, see String.

Объявление и инициализация строк Declaring and Initializing Strings

Вы можете объявлять и инициализировать строки различными способами, как показано в следующем примере: You can declare and initialize strings in various ways, as shown in the following example:

Обратите внимание, что вы не используете оператор new для создания объекта строки, за исключением случаев инициализации строки с помощью массива символов. Note that you do not use the new operator to create a string object except when initializing the string with an array of chars.

Инициализируйте строку с константным значением Empty для создания нового объекта String, строка которого имеет нулевую длину. Initialize a string with the Empty constant value to create a new String object whose string is of zero length. Представлением строкового литерала строки с нулевой длиной является «». The string literal representation of a zero-length string is «». Если вы инициализируете строки со значением Empty вместо NULL, вы снизите вероятность появления исключения NullReferenceException. By initializing strings with the Empty value instead of null, you can reduce the chances of a NullReferenceException occurring. Используйте статический метод IsNullOrEmpty(String), чтобы проверить значение строки, прежде чем пытаться получить к ней доступ. Use the static IsNullOrEmpty(String) method to verify the value of a string before you try to access it.

Неизменность строковых объектов Immutability of String Objects

Строковые объекты являются неизменяемыми: их нельзя изменить после создания. String objects are immutable: they cannot be changed after they have been created. Может показаться, что все методы String и операторы C# изменяют строку, но в действительности они возвращают результаты в новый строковый объект. All of the String methods and C# operators that appear to modify a string actually return the results in a new string object. Когда содержимое s1 и s2 объединяется для формирования одной строки, две исходные строки не изменяются, как показано в следующем примере. In the following example, when the contents of s1 and s2 are concatenated to form a single string, the two original strings are unmodified. Оператор += создает новую строку, которая содержит объединенное содержимое. The += operator creates a new string that contains the combined contents. Этот новый объект присваивается переменной s1 , а исходный объект, который был присвоен s1 , освобождается для сборки мусора, так как ни одна переменная не ссылается на него. That new object is assigned to the variable s1 , and the original object that was assigned to s1 is released for garbage collection because no other variable holds a reference to it.

Так как «изменение» строки на самом деле является созданием новой строки, создавать ссылки на строки следует с осторожностью. Because a string «modification» is actually a new string creation, you must use caution when you create references to strings. Если вы создадите ссылку на строку, а затем «измените» исходную строку, ссылка будет по-прежнему указывать на исходный объект, а не на новый объект, который был создан при изменении строки. If you create a reference to a string, and then «modify» the original string, the reference will continue to point to the original object instead of the new object that was created when the string was modified. Это поведение проиллюстрировано в следующем коде: The following code illustrates this behavior:

Инструкции по созданию новых строк, основанных на таких изменениях, как операции поиска и замены исходной строки, см. в практическом руководстве по изменению содержимого строки. For more information about how to create new strings that are based on modifications such as search and replace operations on the original string, see How to: Modify String Contents.

Регулярные и буквальные строковые литералы Regular and Verbatim String Literals

Используйте регулярные строковые литералы, когда вам нужно внедрить escape-символы, доступные в C#, как показано в следующем примере: Use regular string literals when you must embed escape characters provided by C#, as shown in the following example:

Буквальные строковые литералы используются для удобства и читабельности, если текст строки содержит символы обратной косой черты, например в путях к файлам. Use verbatim strings for convenience and better readability when the string text contains backslash characters, for example in file paths. Так как буквальные строки сохраняют символы новой строки как часть текста строки, их можно использовать для инициализации многострочных строк. Because verbatim strings preserve new line characters as part of the string text, they can be used to initialize multiline strings. Используйте двойные кавычки, чтобы вставить кавычки в буквальной строке. Use double quotation marks to embed a quotation mark inside a verbatim string. В следующем примере показаны наиболее часто используемым буквальные строки: The following example shows some common uses for verbatim strings:

Escape-последовательности строк String Escape Sequences

Escape-последовательность Escape sequence Имя символа Character name Кодировка Юникод Unicode encoding
\’ \’ Одинарная кавычка Single quote 0x0027 0x0027
\» \» Двойная кавычка Double quote 0x0022 0x0022
\\ Обратная косая черта Backslash 0x005C 0x005C
\0 \0 Null Null 0x0000 0x0000
\a \a Предупреждение Alert 0x0007 0x0007
\b \b Backspace Backspace 0x0008 0x0008
\f \f Перевод страницы Form feed 0x000C 0x000C
\n \n Новая строка New line 0x000A 0x000A
\r \r Возврат каретки Carriage return 0x000D 0x000D
\t \t Горизонтальная табуляция Horizontal tab 0x0009 0x0009
\v \v Вертикальная табуляция Vertical tab 0x000B 0x000B
\u \u Escape-последовательность Юникода (UTF-16) Unicode escape sequence (UTF-16) \uHHHH (диапазон: 0000–FFFF; пример: \u00E7 = «ç») \uHHHH (range: 0000 — FFFF; example: \u00E7 = «ç»)
\U \U Escape-последовательность Юникода (UTF-32) Unicode escape sequence (UTF-32) \U00HHHHHH (диапазон: 000000–10FFFF; пример: \U0001F47D = «��») \U00HHHHHH (range: 000000 — 10FFFF; example: \U0001F47D = «��»)
\x \x Escape-последовательность Юникода аналогична «\u», она отличается только длиной переменной Unicode escape sequence similar to «\u» except with variable length \xH[H][H][H] (диапазон: 0–FFFF; пример: \x00E7 или \x0E7 или \xE7 = «ç») \xH[H][H][H] (range: 0 — FFFF; example: \x00E7 or \x0E7 or \xE7 = «ç»)

Если вы используете escape-последовательность \x с менее чем четырьмя шестнадцатеричными цифрами, то когда непосредственно следующие за ней символы также являются допустимыми шестнадцатеричными цифрами (т. е. 0–9, A–F и a–f), они будут интерпретированы как часть этой escape-последовательности. When using the \x escape sequence and specifying less than 4 hex digits, if the characters that immediately follow the escape sequence are valid hex digits (i.e. 0-9, A-F, and a-f), they will be interpreted as being part of the escape sequence. Например, \xA1 дает результат «¡», являющийся кодовой точкой U+00A1. For example, \xA1 produces «¡», which is code point U+00A1. Однако если следующий символ — «A» или «a», тогда escape-последовательность будет интерпретироваться как \xA1A и даст результат «ਚ», являющийся кодовой точкой U+0A1A. However, if the next character is «A» or «a», then the escape sequence will instead be interpreted as being \xA1A and produce «ਚ», which is code point U+0A1A. В таких случаях, чтобы избежать некорректной интерпретации, указывайте все четыре шестнадцатеричных знака (например, \x00A1 ). In such cases, specifying all 4 hex digits (e.g. \x00A1 ) will prevent any possible misinterpretation.

Во время компиляции буквальные строки преобразуются в обычные строки с теми же escape-последовательностями. At compile time, verbatim strings are converted to ordinary strings with all the same escape sequences. Поэтому, если вы просматриваете буквальную строку в окне контрольных значений отладчика, вы увидите escape-символы, добавленные компилятором, а не буквальную версию из исходного кода. Therefore, if you view a verbatim string in the debugger watch window, you will see the escape characters that were added by the compiler, not the verbatim version from your source code. Например, буквальная строка @»C:\files.txt» будет отображаться в окне контрольных значений как «C:\\files.txt». For example, the verbatim string @»C:\files.txt» will appear in the watch window as «C:\\files.txt».

Строки формата Format Strings

Строка формата — это строка, содержимое которой можно определить динамически во время выполнения. A format string is a string whose contents are determined dynamically at runtime. Строки формата создаются путем внедрения интерполированных выражений или заполнителей внутри фигурных скобок в строке. Format strings are created by embedding interpolated expressions or placeholders inside of braces within a string. Весь код внутри фигурных скобок ( <. >) будет преобразован в значение и выходные данные как отформатированная строка во время выполнения. Everything inside the braces ( <. >) will be resolved to a value and output as a formatted string at runtime. Существует два способа создания строк формата: интерполяция строк и составное форматирование. There are two methods to create format strings: string interpolation and composite formatting.

Интерполяция строк String Interpolation

В C# 6.0 и более поздних версий интерполированные строки определяются по специальному символу $ . Они включают интерполированные выражения в фигурных скобках. Available in C# 6.0 and later, interpolated strings are identified by the $ special character and include interpolated expressions in braces. См. дополнительные сведения в интерактивном руководстве по интерполяции строк в C#. If you are new to string interpolation, see the String interpolation — C# interactive tutorial for a quick overview.

Используйте интерполяцию для повышения удобства чтения и обслуживаемости кода. Use string interpolation to improve the readability and maintainability of your code. Интерполяция строк позволяет достичь тех же результатов, что и использование метода String.Format , но более простым и понятным способом. String interpolation achieves the same results as the String.Format method, but improves ease of use and inline clarity.

Составное форматирование Composite Formatting

String.Format использует заполнители в фигурных скобках, чтобы создать строку формата. The String.Format utilizes placeholders in braces to create a format string. В этом примере результат аналогичен выходным данным, получаемым с помощью метода интерполяции строк, описанного выше. This example results in similar output to the string interpolation method used above.

См. дополнительные сведения о типах форматирования в .NET. For more information on formatting .NET types see Formatting Types in .NET.

Подстроки Substrings

Подстрока — это последовательность символов, содержащихся в строке. A substring is any sequence of characters that is contained in a string. Используйте метод Substring, чтобы создать новую строку из части исходной строки. Use the Substring method to create a new string from a part of the original string. Одно вхождение подстроки или несколько можно найти с помощью метода IndexOf. You can search for one or more occurrences of a substring by using the IndexOf method. Используйте метод Replace, чтобы заменить все вхождения указанной подстроки новой строкой. Use the Replace method to replace all occurrences of a specified substring with a new string. Как и метод Substring, метод Replace фактически возвращает новую строку и не изменяет исходную строку. Like the Substring method, Replace actually returns a new string and does not modify the original string. Дополнительные сведения см. в практическом руководстве по поиску строк и практическом руководстве по изменению содержимого строк. For more information, see How to: search strings and How to: Modify String Contents.

Доступ к отдельным символам Accessing Individual Characters

Используя нотацию массива со значением индекса, можно получить доступ только для чтения к отдельным символам, как показано в следующем примере: You can use array notation with an index value to acquire read-only access to individual characters, as in the following example:

Если вам необходимо изменить отдельные символы в строке и функций методов String вам недостаточно, используйте объект StringBuilder, чтобы изменить отдельные символы «на месте», а затем создайте новую строку для сохранения результатов с помощью методов StringBuilder. If the String methods do not provide the functionality that you must have to modify individual characters in a string, you can use a StringBuilder object to modify the individual chars «in-place», and then create a new string to store the results by using the StringBuilder methods. В следующем примере предположим, что необходимо определенным образом изменить исходную строку, а затем сохранить результаты для дальнейшего использования: In the following example, assume that you must modify the original string in a particular way and then store the results for future use:

Строки NULL и пустые строки Null Strings and Empty Strings

Пустая строка — это экземпляр объекта System.String, который содержит нуль символов. An empty string is an instance of a System.String object that contains zero characters. Пустые строки часто используются в различных сценариях программирования для представления пустого текстового поля. Empty strings are used often in various programming scenarios to represent a blank text field. Вы можете вызывать методы для пустых строк, так как они являются допустимыми объектами System.String. You can call methods on empty strings because they are valid System.String objects. Пустые строки инициализируются следующим образом: Empty strings are initialized as follows:

В отличие от пустых строк строка NULL не ссылается на экземпляр объекта System.String, поэтому любая попытка вызвать метод для строки NULL приводит к исключению NullReferenceException. By contrast, a null string does not refer to an instance of a System.String object and any attempt to call a method on a null string causes a NullReferenceException. Но вы можете использовать строки NULL в операциях объединения и сравнения с другими строками. However, you can use null strings in concatenation and comparison operations with other strings. В следующих примерах показаны случаи, в которых ссылка на строку NULL вызывает и не вызывает исключение: The following examples illustrate some cases in which a reference to a null string does and does not cause an exception to be thrown:

Использование класса StringBuilder для быстрого создания строк Using StringBuilder for Fast String Creation

Операции со строками в .NET хорошо оптимизированы, и в большинстве случаев они не снижают производительность. String operations in .NET are highly optimized and in most cases do not significantly impact performance. Но в некоторых сценариях, например в сплошных циклах, которые выполняются сотни и тысячи раз, операции со строками могут повлиять на производительность. However, in some scenarios such as tight loops that are executing many hundreds or thousands of times, string operations can affect performance. Класс StringBuilder создает строковый буфер, который ускоряет работу, если программа выполняет много операций над строками. The StringBuilder class creates a string buffer that offers better performance if your program performs many string manipulations. Строка StringBuilder также позволяет заново присваивать отдельные символы, что не поддерживает встроенный строковый тип данных. The StringBuilder string also enables you to reassign individual characters, something the built-in string data type does not support. Например, этот код изменяет содержимое строки без создания новой строки: This code, for example, changes the content of a string without creating a new string:

В этом примере объект StringBuilder используется для создания строки из набора числовых типов: In this example, a StringBuilder object is used to create a string from a set of numeric types:

Строки, методы расширения и LINQ Strings, Extension Methods and LINQ

Так как тип String использует IEnumerable , вы можете применять методы расширения, определенные для строк в классе Enumerable. Because the String type implements IEnumerable , you can use the extension methods defined in the Enumerable class on strings. Чтобы избежать визуального загромождения, эти методы исключены из IntelliSense для типа String, но все равно доступны. To avoid visual clutter, these methods are excluded from IntelliSense for the String type, but they are available nevertheless. Можно также использовать выражения запроса LINQ LINQ в строках. You can also use LINQ LINQ query expressions on strings. Дополнительные сведения см. в документации по LINQ и строкам. For more information, see LINQ and Strings.

Понравилась статья? Поделиться с друзьями:
Все языки программирования для начинающих