Статьи

Обнуляемые типы и оператор объединения нулей в C #

Сентябрь 19, 2017

Это фундаментальная концепция в программировании на C #. Здесь я собираюсь объяснить обнуляемые типы, оператор обнуления в C # и как мы можем использовать этот оператор в  LINQ .

Типы данных в C # делятся на две основные категории:  тип значения  и  ссылочный тип . 

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

Давайте проверим, что произойдет, когда мы присвоим значение null типу значения.

Поэтому, когда я пытаюсь присвоить пустое значение целому числу, появляется следующая ошибка:  «Невозможно преобразовать нулевое значение в Int, потому что это тип значения, не допускающий значения NULL».  

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

  • Nullable <int> x = null;

  • инт? х = ноль;
  • Выше показаны два способа преобразования необнуляемого типа значения в тип значения NULL в C #. Из этого мы заключаем, что: тип называется обнуляемым, если ему может быть присвоено значение или ему может быть присвоено значение null, что означает, что тип не имеет значения вообще. По умолчанию все ссылочные типы, такие как строки, могут иметь значение NULL, а все типы значений, такие как Int32, — нет.
  • Есть два члена обнуляемого типа. 1:  HasValue: HasValue  имеет логическое значение типа. Он имеет значение true, если переменная содержит ненулевое значение.
static void Main(string[] args)  
{  
 int? x = 5;  
 if(x.HasValue)  
  {  
    Console.WriteLine("contain not nullable value.");  
  }  
 else  
  {  
    Console.WriteLine("contain Null value.");  
  }  
    Console.ReadLine();  
}

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

2.  Значение: Value  имеет логический тип. Он содержит данные, хранящиеся в обнуляемом типе.

static void Main(string[] args)  
{  
int? x = 5;  
if(x.HasValue)  
{  
Console.WriteLine(x.Value.ToString());  
}  
else  
{  
Console.WriteLine("contain Null value.");  
}  
Console.ReadLine();

Здесь вывод будет -5. 

Это все о Nullable типах в C #. Теперь я собираюсь обсудить оператор Null Coalescing в C #.

Null-Collation

Null-collation ( ??) является важным оператором в C #. Согласно определению MSDN:  ?? Оператор называется оператором слияния нулей и используется для определения значения по умолчанию для типов значений, допускающих значение NULL, или ссылочных типов. Возвращает левый операнд, если операнд не равен нулю; в противном случае он возвращает правильный операнд. C # Null Coalescing Operator ( ??) — это бинарный оператор, который упрощает проверку на нулевые значения. Он используется для назначения значения по умолчанию переменной, когда значение равно нулю.

class Program  
    {  
        static void Main(string[] args)  
        {  
            string name = null;  
            string myname = name ?? "Laxmi";  
            Console.WriteLine(myname);  
            Console.ReadLine();  
        }  
    }

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

В свойстве также мы можем использовать нулевой оператор слияния, как этот.

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
using System.Threading.Tasks;  

namespace NullCollation  
{  
    class employee  
    {  

    }  
    class Program  
    {  

        static string _name;  

        static string Name  
        {  
            get  
            {  
                return _name ?? "Kailash";  
            }  
            set  
            {  
                _name = value;  
            }  
        }  
        public int age { get; set; }  
        static void Main(string[] args)  
        {  

            Console.WriteLine(Name);  
            Console.ReadLine();  
        }  
    }  
}

Теперь я покажу вам, как этот оператор используется в LINQ.

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
using System.Threading.Tasks;  
  
namespace NullCollation  
{  
    public class Employee  
    {  
        public int Id { get; set; }  
        public int age { get; set; }  
        public string name { get; set; }  
        public string gender { get; set; }  
    }  
    class Program  
    {  
  
        static void Main(string[] args)  
        {  
            List<Employee> li = new List<Employee>();  
            li.Add(new Employee { Id = 1, age = 19, name = "Ritesh", gender = "M" });  
            li.Add(new Employee { Id = 2, age = 20, name = "sujit", gender = "M" });  
            li.Add(new Employee { Id = 3, age = 23, name = "Kabir", gender = "F" });  
            li.Add(new Employee { Id = 4, age = 3, name = null, gender = "F" });  
            li.Add(new Employee { Id = 5, age = 24, name = "Kamlesh", gender = "M" });  
            li.Add(new Employee { Id = 6, age = 28, name = "Manoj", gender = "M" });  
  
            var Data = from emp in li where emp.Id == 4 select new { Name = emp.name ?? "No name" };  
  
            foreach (var obj in Data)  
            {  
                Console.WriteLine(obj.Name);  
            }  
            Console.ReadLine();  
  
        }  
    }  
}

Таким образом, мы можем использовать нулевой оператор Coalescing в LINQ Queries.

28
Share: