C# Literals

In C#, a literal is a fixed value used in a program. These values are directly written into the code and can be used by variables. A literal can be an integer, floating-point number, string, character, boolean, or even null.

Example:

// Here 100 is a constant/literal.
int x = 100;

Types of Literals in C#

The main types of literals in C# include:

• Integer Literals
• Floating-point Literals
• Character Literals
• String Literals
• Null Literals
• Boolean Literals

1. Integer Literals 

A literal of integer type is known as the integer literal. It can be decimal, binary, or hexadecimal constant. No prefix is required for the decimal numbers. A suffix can also be used with the integer literals like U or u are used for unsigned numbers while l or L are used for long numbers. By default, every literal is of int type. For Integral data types (byte, short, int, long), we can specify literals in the ways:

Decimal literals (Base 10): In this form, the allowed digits are 0-9.

int x = 101;

Hexa-decimal literals (Base 16): In this form, the allowed digits are 0-9 and characters are a-f. We can use both uppercase and lowercase characters. As we know that c# is a case-sensitive programming language but here c# is not case-sensitive.

// The hexa-decimal number should be prefix
// with 0X or 0x.
int x = 0X123Face;

Binary literals (Base 2): In this form, the allowed digits are only 1’s and 0’s.

// The binary number should be prefix with 0b.
int x = 0b101

Examples: 

045uu // invalid: suffix (u) is repeated
0b105 // invalid: 5 is not a binary digit
0b101 // valid binary literal
456 // valid decimal literal
0x65d // valid hexadecimal literal
12356 // valid int literal
304U // valid unsigned int literal
3078L // valid long literal
965UL // valid unsigned long literal

Program:

// C# program to illustrate the use of Integer Literals using System;   class Geeks{    public static void Main(String[] args)  {     // decimal-form literal  int a = 101;    // Hexa-decimal form literal  int c = 0xFace;    // binary-form literal  int x = 0b101;    Console.WriteLine(a);  Console.WriteLine(c);  Console.WriteLine(x);  } } 

101 64206 5 

2. Floating-point Literals 

The literal which has an integer part, a decimal point, a fractional part, and an exponent part is known as the floating-point literal. These can be represented either in decimal form or exponential form.

Examples:  

Double d = 3.14145 // Valid
Double d = 312569E-5 // Valid
Double d = 125E // invalid: Incomplete exponent
Double d = 784f // valid
Double d = .e45 // invalid: missing integer or fraction

Program:

// C# program to illustrate the use of // floating-point literals using System;   class Geeks {    public static void Main(String[] args)  {  // decimal-form literal  double a = 101.230;    // It also acts as decimal literal  double b = 0123.222;    Console.WriteLine(a);  Console.WriteLine(b);  } } 

101.23 123.222 

Note: By default, every floating-point literal is of double type and hence we can’t assign directly to float variable. But we can specify floating-point literal as float type by suffixed with f or F. We can specify explicitly floating-point literal as the double type by suffixed with d or D, of course, this convention is not required.

3. Character Literals

For character data types we can specify literals in 3 ways:

Single quote: We can specify literal to char data type as single character within single quote.

char ch = 'a';

Unicode Representation: We can specify char literals in Unicode representation ‘\uxxxx’. Here xxxx represents 4 hexadecimal numbers.

char ch = '\u0061';// Here /u0061 represent a.

Escape Sequence: Every escape character can be specified as char literals.

char ch = '\n';

Example:

// C# program to illustrate the use of char literals using System;   class Geeks {  public static void Main(String[] args)  {    // character literal within single quote  char ch = 'a';    // Unicode representation  char c = '\u0061';    Console.WriteLine(ch);  Console.WriteLine(c);    // Escape character literal  Console.WriteLine("Hello\n\nGeeks\t!");  } } 

a a Hello Geeks	! 

4. String Literals

Literals which are enclosed in double quotes(“”) or starts with @”” are known as the String literals. 

Examples:  

String s1 = "Hello Geeks!";

String s2 = @"Hello Geeks!";

Program:

// C# program to illustrate the use of String literals using System;   class Geeks {    public static void Main(String[] args)  {    String s = "Hello Geeks!";  String s2 = @"Hello Geeks!";    // If we assign without "" then it  // treats as a variable  // and causes compiler error  // String s1 = Geeks;  Console.WriteLine(s);  Console.WriteLine(s2);  } } 

Hello Geeks! Hello Geeks! 

5. Boolean Literals

Only two values are allowed for Boolean literals i.e. true and false.

Example: 

bool b = true;
bool c = false;

Program:

// C# program to illustrate the use // of boolean literals using System;   class Geeks {  public static void Main(String[] args)  {  bool b = true;  bool c = false;    // these will give compile time error  // bool d = 0;  // bool e = 1;  // Console.WriteLine(d);  // Console.WriteLine(e);  Console.WriteLine(b);  Console.WriteLine(c);  } } 

True False