Data Types

Primitive vs Non-Primitive

• All primitive types are structures.
• Example: sbyte is a primitive type, which is equivalent to System.SByte (can also be written as SByte structure).
• In C#, it is recommended to always use primitive types instead of structure names.
• Data type are specific to C# but their structure/class are specific to .NET

Reference and Value

VS

Boxing

It is a process of converting a value from "Value-Type Data Type" to "Reference-Type Data Type", if they are compatible data types.

This can be done automatically (no need for any syntax).

// primitive variable
int x = 10;

// boxing (value-type to reference-type)
object obj = x;

System.Console.WriteLine(x);   // Output: 10
System.Console.WriteLine(obj); // Output: 10

Unboxing

It is a process of converting a value from "Reference-Type Data Type" to "Value-Type Data Type", if they are compatible data types.

This should be done explicitly (by using explicit casting).

// reference type variable
object obj = 10;

// unboxing (reference-type to value-type)
int x = (int)obj;

System.Console.WriteLine(x);   // Output: 10
System.Console.WriteLine(obj); // Output: 10

When we aren't sure about the incoming type, we will store it in a variable with object type and after that we will using unboxing for converting it to the proper type

Types

Byte

Short

Int

Long

Float

Double

Decimal

Char

Important ASCII/Unicode Numbers for Characters:

• 65 to 90: A-Z
• 97 to 122: a-z
• 48 to 57: 0-9
• 32: Space
• 8: Backspace
• 13: Enter

String

Boolean

Type Conversion

Classification

Type Conversion is a process of converting a value from one type (source type) to another type (destination type).

• Implicit Casting: from lower-numerical-type to higher-numerical-type
• Explicit Casting: from higher-numerical-type to lower-numerical-type
• Parsing / TryParse: from string to numerical-type
• Conversion Methods: from any-primitive-type to any-primitive-type

Implicit Casting

Explicit Casting

MyType a = (MyType)myObj;  // throws an exception if type is wrong
MyType a = myObj as MyType;  // return null if type is wrong

Parsing

String to any numerical type

Syntax:

DestinationDataType.Parse(SourceValue)

Try Parsing

The string value can be converted into any numerical data type, by using the "TryParse" technique (same as "parse"); but it checks the source value before attempting to parse.

• If the source value is invalid, it returns false; It doesn't raise any exception in this case.
• If the source value is valid, it returns true (indicates conversion is successful).
• It avoids FormatException.

Syntax:

bool variable = DestinationType.TryParse(SourceValue, out DestinationVariable)

Conversion Methods

Conversion method is a pre-defined method, which converts any primitive type (and also "string") to any other primitive type (and also "string").

• The System.Convert is a class that contains a set of pre-defined methods.
• It raises FormatException if the source value is invalid.
• For each data type, we have a conversion method.
• All conversion methods are static methods.

Syntax:

type destinationVariable = Convert.ConversionMethod(SourceValue)

Conversion table:

System.Object

The "System.Object" is a pre-defined class, which is the "Ultimate super class (base class)" in .NET.

All the classes and other types are inherited from System.Object directly or indirectly.

Class hierarchy:

class System.Object
├── class System.ValueType
│   ├── Structures
│   └── Enumerations
├── Classes
└── Interfaces

Code definition:

namespace System {
    class Object
    {
        virtual bool Equals( object value );
        virtual int GetHashCode( );
        Type GetType( );
        virtual string ToString( );
    }
}

Class methods:

• bool Equals( object value )

  • Compares the current object with the given argument object; returns true if both are the same objects; returns false if both are different objects.

• int GetHashCode( object value )

  • Returns a number that represents the object. It is not guaranteed that the hash code is unique, by default.

• Type GetType( )

  • Returns the name of the class (including namespace path), based on which the object is created.

• string ToString( )

  • By default, it returns the name of the class (including namespace path), based on which the object is created.
  • It is a virtual method, which can be overridden in the child class.

Nullable Type

Converting Value-Types to Nullable-Types example:

Nullable<int> x = null;
// or
int? x = null;

Pattern Matching

It allows you to declare a variable while checking the data type (class) of a reference variable, and automatically type-casts the reference variable into the specified data type (class).

The classic way to check data type:

if (referenceVariable is Class1) {
    Class1 c1 = (Class1)referenceVariable;
    c1.Property....;
}

The Pattern-Matching way to check data type:

if (referenceVariable is Class1 c1) {
    c1.Property....;
}

Implicit Typed Variables

The variables that are declared with var keyword are called 'implicitly-typed variables' (a.k.a type-inference).

Implicitly-typed variables are declared without specifying the type explicitly, so the C# compiler automatically identifies the appropriate data type at compilation-time based on the value assigned at the time of declaration.

Example:

var variableName = value;

• Is good when the type name is long
• Is good when we don't know the output type (For example the LINQ query result)

• It is not possible to declare multiple implicitly typed variables in the same statement.

  // Example:
  var x = 10, y = 20;  // error
  

• It is not possible to assign "null" to implicitly typed variables during declaration.

  // Example:
  var x = null;  // error
  

Dynamically Typed Variables

Dynamically Typed Variables are the variables that are declared with the dynamic keyword.

Example:

dynamic variableName = value;

• Declared without specifying the type explicitly.
• There is no fixed type for the variable.
• You can assign any type of value to these variables.
• C# compiler skips "type-checking" at compilation time; instead, it resolves the data types of its values at run-time.

• The dynamic type variables are converted as object type in most cases:

  dynamic dynamicVariable = 100;  // Equivalent to: object dynamicVariable = 100;
  

• The Dynamically Typed Variable can change its data type, any number of times, at run-time.

• Methods and other members of dynamically typed variables will not be checked by the compiler at compilation time; it will be checked by the CLR at runtime.

  • If the method or other member is not available, it would not cause a compile-time error; it raises a run-time error when the execution flow encounters that particular statement.

  dynamicVariable.NonExistingMethod();  // run-time error (exception)
  

• The Dynamically Typed Variables need not be initialized while declaring.