Как ввести переменные в си шарп

Как ввести переменные в си шарп

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

Перед использованием любую переменную надо определить. Синтаксис определения переменной выглядит следующим образом:

тип имя_переменной;

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

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

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

Например, определим простейшую переменную:

string name;

В данном случае определена переменная name, которая имеет тип string . то есть переменная представляет строку. Поскольку определение переменной представляет собой инструкцию, то после него ставится точка с запятой.

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

string name; string Name;

После определения переменной можно присвоить некоторое значение:

string name; name = "Tom";

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

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

Также мы можем сразу при определении присвоить переменной значение. Данный прием называется инициализацией:

string name = "Tom";

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

string name = "Tom"; // определяем переменную и инициализируем ее Console.WriteLine(name); // Tom name = "Bob"; // меняем значение переменной Console.WriteLine(name); // Bob

Консольный вывод программы:

Tom Bob

Константы

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

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

const string NAME = "Tom"; // определяем константу

Так, в данном случае определена константа NAME , которая хранит строку «Tom». Нередко для название констант используется верхний регистр, но это не более чем условность.

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

const string NAME; // ! Ошибка - константа NAME не инициализирована

Кроме того, мы ее не сможем изменить в процессе работы программы:

const string NAME = "Tom"; // определяем константу NAME = "Bob"; // !Ошибка - у констаты нельзя изменить значение

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

Переменные

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

Правила именования переменных

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

В языке C# это можно сделать следующим образом: «тип данных» «имя переменной»; , сперва указан тип данных, который храниться в переменной, а за ним имя.

Имя переменной должно соответствовать следующим правилам:

• начинаться со знака подчеркивания “_“, или Unicode символа(да, в своих приложениях вы можете называть переменные именами, которые состоят из символов национального алфавита);
• может содержать Unicode символы, цифры и знак подчеркивания;
• в именах запрещено использовать специальные символы, пробелы, знаки пунктуации;
• имена не должны совпадать с зарезервированными словами языка программирования C#.

abstract	as	base	bool
break	byte	case	catch
char	checked	class	const
continue	decimal	default	delegate
do	double	else	enum
event	explicit	extern	false
finally	fixed	float	for
foreach	goto	if	implicit
in	int	interface	internal
is	lock	long	namespace
new	null	object	operator
out	override	params	private
protected	public	readonly	ref
return	sbyte	sealed	short
sizeof	stackalloc	static	string
struct	switch	this	throw
true	try	typeof	uint
ulong	unchecked	unsafe	ushort
using	using static	virtual	void
volatile	while

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

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

string text; int number; 

Здесь мы определили две переменные, первая типа строка с именем text, вторая – целое число с именем number.

Если возникает необходимость использовать одно из зарезервированных слов в названии переменной, вы можете это сделать, написав перед именем символ “@”. Например int @while; .

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

int age; int Age; 

После того, как вы объявили переменную, можно присвоить ей значение. Для этого используется оператор присваивания – “=”

string user; user = "Alex"; 

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

string name = "Lisa"; 

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

Не смотря на то, что C# позволяет использовать в названиях переменных Unicode символы, в частности русские, правила хорошего тона рекомендуют использовать в именах исключительно английские буквы. Потому, что национальные символы усложняют работу с кодом программы, а иногда могут вызвать дисонанс, когда символы визуально идентичны, а их коды разные(к примеру русская буква “с” и английская “c”).

Область видимости переменных

Область видимости или контекст переменной (scope) – это часть программы, в пределах которой, идентификатор остается связанным с данными в памяти, то есть позволяет через себя обращаться к данным.

В C# достаточно просто определить области видимости переменных, поскольку они отделены фигурными скобками “”, которые указывают на начало и конец блока кода.

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

Рассмотрим на примере программы:

class Program < //контекст уровня класса private static int num1 = 1;//доступна во всех вложенных в класс методах static void Main(string[] args) < //контекст уровня метода Main int num2 = 2; //видима только в пределах метода Main Console.WriteLine(num1 + num2); > static void Print( ) < //контекст уровня метода Print //здесь нельзя обращаться к num2, поскольку она не может выйти за фигурные скобки метода Main //а к num1 можно, она может войти во вложенные скобки int num3 = 3; //видима в пределах метода Print Console.WriteLine(num1 + num3); > > 

Инструкции объявления

Оператор объявления объявляет новую локальную переменную, локальную константу или локальную эталонную переменную. Чтобы объявить локальную переменную, укажите его тип и укажите его имя. Можно объявить несколько переменных одного типа в одной инструкции, как показано в следующем примере:

string greeting; int a, b, c; List xs; 

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

string greeting = "Hello"; int a = 3, b = 2, c = a + b; List xs = new(); 

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

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

const string Greeting = "Hello"; const double MinLimit = -10.0, MaxLimit = -MinLimit; 

При объявлении локальной константы необходимо также инициализировать ее.

Сведения о локальных ссылочных переменных см. в разделе «Эталонные переменные «.

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

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

var greeting = "Hello"; Console.WriteLine(greeting.GetType()); // output: System.String var a = 32; Console.WriteLine(a.GetType()); // output: System.Int32 var xs = new List(); Console.WriteLine(xs.GetType()); // output: System.Collections.Generic.List`1[System.Double] 

Как показано в предыдущем примере, неявно типизированные локальные переменные строго типизированы.

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

var xs = new List(); 

Вы можете использовать целевое типизированное new выражение в качестве альтернативы:

List xs = new(); List? ys = new(); 

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

var fromPhoenix = from cust in customers where cust.City == "Phoenix" select new < cust.Name, cust.Phone >; foreach (var customer in fromPhoenix) < Console.WriteLine($"Name=, Phone="); > 

Дополнительные сведения о неявно типизированных локальных переменных см. в разделе неявно типизированные локальные переменные.

При сопоставлении шаблонов в шаблоне var используется ключевое слово var .

Ссылочные переменные

При объявлении локальной переменной и добавлении ref ключевое слово перед типом переменной объявляется эталонная переменная или локальная ref :

ref int alias = ref variable; 

Ссылочная переменная — это переменная, которая ссылается на другую переменную, которая называется ссылочной. То есть ссылочная переменная является псевдонимом его ссылки. При назначении значения ссылочной переменной это значение назначается референту. При чтении значения ссылочной переменной возвращается значение ссылки. В следующем примере продемонстрировано такое поведение.

int a = 1; ref int alias = ref a; Console.WriteLine($"(a, alias) is (, )"); // output: (a, alias) is (1, 1) a = 2; Console.WriteLine($"(a, alias) is (, )"); // output: (a, alias) is (2, 2) alias = 3; Console.WriteLine($"(a, alias) is (, )"); // output: (a, alias) is (3, 3) 

ref Используйте оператор = ref назначения для изменения ссылочной переменной, как показано в следующем примере:

void Display(int[] s) => Console.WriteLine(string.Join(" ", s)); int[] xs = [0, 0, 0]; Display(xs); ref int element = ref xs[0]; element = 1; Display(xs); element = ref xs[^1]; element = 3; Display(xs); // Output: // 0 0 0 // 1 0 0 // 1 0 3 

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

Можно определить локальную ref readonly переменную. Нельзя назначить значение переменной ref readonly . Однако можно ref переназначить такую эталонную переменную, как показано в следующем примере:

int[] xs = [1, 2, 3]; ref readonly int element = ref xs[0]; // element = 100; error CS0131: The left-hand side of an assignment must be a variable, property or indexer Console.WriteLine(element); // output: 1 element = ref xs[^1]; Console.WriteLine(element); // output: 3 

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

using System; public class NumberStore < private readonly int[] numbers = [1, 30, 7, 1557, 381, 63, 1027, 2550, 511, 1023]; public ref int GetReferenceToMax() < ref int max = ref numbers[0]; for (int i = 1; i < numbers.Length; i++) < if (numbers[i] >max) < max = ref numbers[i]; >> return ref max; > public override string ToString() => string.Join(" ", numbers); > public static class ReferenceReturnExample < public static void Run() < var store = new NumberStore(); Console.WriteLine($"Original sequence: "); ref int max = ref store.GetReferenceToMax(); max = 0; Console.WriteLine($"Updated sequence: "); // Output: // Original sequence: 1 30 7 1557 381 63 1027 2550 511 1023 // Updated sequence: 1 30 7 1557 381 63 1027 0 511 1023 > > 

В предыдущем примере GetReferenceToMax метод является методом возвращается по ссылке . Он не возвращает максимальное значение, но возвращаемое ссылкой, которое является псевдонимом элемента массива, который содержит максимальное значение. Метод Run назначает ссылку возвращаемой переменной max . Затем, назначив max его, он обновляет внутреннее хранилище экземпляра store . Можно также определить ref readonly метод. Вызывающие методы ref readonly не могут назначить значение возвращаемой ссылке.

Переменная итерации инструкции foreach может быть эталонной переменной. Дополнительные сведения см. в foreach разделе инструкций инструкции инструкций итерации.

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

Сведения о ref полях см ref . в разделе полей статьи ref типов структур.

область d ref

Контекстная ключевое слово scoped ограничивает время существования значения. Модификатор scoped ограничивает время существования ref-safe-to-escape или safe-to-escape соответственно текущим методом. Фактически добавление модификатора утверждает, scoped что код не будет расширять время существования переменной.

Можно применить scoped к параметру или локальной переменной. Модификатор scoped может применяться к параметрам и локальным параметрам, если тип является типом ref struct . scoped В противном случае модификатор может применяться только к локальным ссылочным переменным. Это включает локальные переменные, объявленные модификатором ref и параметрами, объявленными с in ref помощью модификаторов или out модификаторов.

Модификатор scoped неявно this добавляется в методы, объявленные в struct параметрах out , параметрах и ref параметрах, когда тип является ref struct .

Спецификация языка C#

Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:

• Инструкции объявления
• Ссылочные переменные и возвращается

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

См. также

• справочник по C#
• Инициализаторы объектов и коллекций
• Ключевое слово ref
• Сокращение выделения памяти с помощью новых функций C#
• Параметры var (правила стиля IDE0007 и IDE0008)

Совместная работа с нами на GitHub

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

The .NET documentation is open source. Provide feedback here.

Обратная связь

Отправить и просмотреть отзыв по

Введение в переменные в C#

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

Объявление переменной и инициализация

• Переменные в C# могут быть объявлены с использованием следующего синтаксиса: (type) (имяпеременной);

int someNumber;

• В приведенной выше строке объявляется переменная с именем ‘someNumber’ типа ‘int’ (целое число). Однако переменной еще не присвоено значение, и ее начальное значение не определено (но для большинства типов переменных ей присваивается значение ‘default’, которое для ‘int’ равно 0 ).
• Значение переменной можно инициализировать, используя следующий синтаксис: (тип) (имяпеременной) = (значение);

int someNumber = 25;

• В приведенной выше строке объявляется переменная с именем ‘someNumber’ типа ‘int’ и присваивается ей начальное значение 25.

Назначение переменной

• После объявления переменной ей можно присвоить значение с помощью оператора присваивания =:

someNumber = 30;

• В строке выше присваивается новое значение 30 переменной ‘someNumber’.

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

C# поддерживает различные типы переменных, в том числе:

• ‘int’: представляет целые числа.
• ‘float’ и double: представляют числа с плавающей запятой с десятичными знаками.
• ‘char’: представляет один символ.
• ‘string’: представляет последовательность символов.
• ‘bool’: представляет логические значения (истина или ложь).
• ‘DateTime’: представляет значение даты, времени и т. д.

Вот пример использования различных типов переменных:

int age = 25; float weight = 65.5f; char gender = 'M'; string name = "John Doe"; bool isStudent = true; DateTime birthDate = new DateTime(1990, 5, 15);

• В приведенных выше строках объявляются и инициализируются переменные разных типов.

Именование переменных

Имена переменных в C# должны соответствовать определенным правилам, например:

• Они могут содержать буквы, цифры и символы подчеркивания.
• Они не могут начинаться с цифры.
• Они чувствительны к регистру.

Вот пример допустимых имен переменных:

int age; string firstName; double _balance;

Использование переменных в выражениях

• Переменные можно использовать в различных выражениях и расчетах:

int num1 = 10; int num2 = 5; int sum = num1 + num2;

• В приведенных выше строках объявляются две переменные ‘num1’ и ‘num2’ типа ‘int’ и вычисляется их сумма, присваивая результат переменной *h8. *’sum’.

Заключение

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