Уловки и особенности C #

Уловки и особенности C #

У любого языка программирования есть свои хитрости и цели.

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

Члены с телом выражения в классах

В C # ООП мы можем найти несколько полезных инструментов, которые могут сэкономить нам много времени и места при написании кода.

public class SampleClass
{
    public int x { get; set; }
    public int y { get; set; }
    public int z => x + y; //automaticlly holds the sum
}

В следующем примере мы видим два основных объявления переменных.

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

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

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

Обратите внимание, что этот оператор также может быть равен функциям, возвращающим значения.

public class SampleClass
{
   public int x { get; set;}
   public int y { get; set;}
   public double z => Avrage(x, y);//automaticlly holds the average
   public double Average(int x, int y)
   {
     double sum = x + y;
     return sum / 2.0;
   }
}

В приведенном выше коде значение z всегда будет средним от x и y.

Вот еще один пример:

int x = 5;
int y = 6;
int z => x + y; //stores 11 on the beginning
public void IncX()
{ 
 this.x++; /* now x = 6 and z = 12 because we increased x by one and now z is updated to the current sum of x & y which is 12*/
}

Специальные ключевые слова

название

int myVariable = 5;
Console.WriteLine(nameof(myVariable)); /*prints the name of the variable*/

В следующих строках кода используется специальное ключевое слово nameof. Это ключевое слово в основном возвращает имя переменной, в которую вы ввели.

В этом примере код напечатает «myVariable»;

перейти к

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

Если вы поклонник сборки, то, скорее всего, вы уже знакомы с ключевым словом goto. Ключевое слово goto аналогично ключевому слову «jmp» в сборке.

int number = 45;
goto nextLabel;
Console.WriteLine("My Number is 5"); //not be executed
nextLabel:
  Console.WriteLine(number); //will be executed

Основная идея ключевого слова goto - пропускать строки кода и переходить к метке.

Например, в этих строках кода строка с выводом «My Number of 5» никогда не будет выполнена, потому что ключевое слово goto пропускает ее и переходит к «nextLabel».

Таким образом, единственное, что будет напечатано на экране, - это значение числа.

int number = 5;
goto myLabel;
if(number == 7)
{
myLabel:
  Console.WriteLine("I like the goto keyword!");
}

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

ref & out

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

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

int b; //not initialized
Initialize(out b); //valid 

Ключевое слово ref также изменяет значение параметра вне функции (если вы вносите изменения), но вам не нужно инициализировать значение внутри функции, и вы не можете принимать неинициализированную переменную как параметр.

int b; //not initialized
Initialize(ref b); //not valid

Когда мы объявляем параметр как ref или out, мы должны указать в параметре out / ref, затем тип, а затем, например, имя переменной (out int b).

Когда мы вызываем функцию, мы должны записать / ref и имя переменной (без объявления типа), вот пример того, как вы должны объявлять в функции и вне функции, когда мы используем эти ключевые слова:

public class Program
{
  public static void Main(string[] args)
  {
     int a = 5;
     int b = 6;
     Increase(out b, ref a); //now b = 0, a = 6
     Console.WriteLine(a + " " + b); //prints 6 0
  }
public static void Increase(out int b, ref int a)
  { 
     a++; // increase the value by 1
     b = 0; //requires initializing the value
  }
}

Примечание. Если вы не инициализируете значение параметра out внутри функции, возникнет ошибка.

Область

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

#region sum
int x = 5;
int y = 6;
Console.WriteLine(x + y);
#endregion

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

ПРИМЕЧАНИЕ, что весь код внутри Sum будет выполнен, а не как в комментариях, где это не так.

Nullable ‹T› & T?

В C # мы можем сделать любой тип значения типом, допускающим значение NULL.
Обратите внимание, что ссылочные типы уже допускают значение NULL, поэтому нам не нужно для них ничего делать (ReferenceType? не вызывает ошибку, но Nullable ‹ReferenceType› будет).

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

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

int? num = null; //legal
num = 5; //legal

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

Nullable<int> integer = null; //Example 1
int? integer2 = null // Example 2

Поздравляю! Теперь вы знаете некоторые интересные инструменты, которые может предложить C #.

Надеюсь, вам понравилось :)