A Comprehensive Guide to Data Types in C#

int number = 42;

float pi = 3.14f;

double distance = 123.456;

char grade = 'A';

bool isTrue = true;

byte positiveByte = 255;       // 0 to 255
sbyte signedByte = -128;       // -128 to 127

short shortNumber = -32768;    // -32768 to 32767
ushort unsignedShort = 65535;  // 0 to 65535

int integer = -2147483648;     // -2147483648 to 2147483647
uint unsignedInt = 4294967295; // 0 to 4294967295

long longNumber = -9223372036854775808;     // -9223372036854775808 to 9223372036854775807
ulong unsignedLong = 18446744073709551615; // 0 to 18446744073709551615

float floatValue = 3.14f;
double doubleValue = 3.141592653589793;
decimal decimalValue = 3.14m;

string greeting = "Hello, World!";

char letter = 'A';

bool isTrue = true;

DateTime currentDateTime = DateTime.Now;

int[] numbers = { 1, 2, 3, 4, 5 };

int thirdNumber = numbers[2];

int[,] matrix = { { 1, 2 }, { 3, 4 } };

enum Days { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };

Days today = Days.Monday;
switch (today)
{
    case Days.Sunday:
        // Do something on Sunday
        break;
    case Days.Monday:
        // Do something on Monday
        break;
    // ... other cases
}

int? nullableInt = null;

int? nullableInt = null;

public struct Point
{
    public int X;
    public int Y;
}

public class Person
{
    public string Name;
    public int Age;
}

dynamic dynamicVariable = 10;
dynamicVariable = "Hello, World!";

int intValue = 42;
double doubleValue = intValue; // Implicit conversion

double doubleValue = 3.14;
int intValue = (int)doubleValue; // Explicit conversion

string numberString = "123";
int parsedNumber = int.Parse(numberString); // Using Parse method

// Instead of using 'int' when a smaller type is sufficient
short smallNumber = 123;

// Using 'int' for integer values
int numberOfItems = 42;

// Using 'double' for floating-point numbers
double totalPrice = 99.99;

// Using 'string' for text
string productName = "C# Guidebook";

// Choosing the appropriate type for a collection
List<int> numbers = new List<int>(); // Good for storing a collection of integers

// Avoiding unnecessary use of 'double' when 'float' is sufficient
float temperature = 23.5f; // Sufficient precision for temperature

// Choosing 'enum' for representing days of the week
public enum Days { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };
Days today = Days.Monday;

// Using nullable types when a variable might be in an undefined state
int? nullableValue = null;

// Using 'struct' for a small, immutable point
public struct Point
{
    public int X;
    public int Y;
}

// Using 'class' for a larger, mutable object
public class Person
{
    public string Name;
    public int Age;
}

// Best practice: Using 'string' for library names
string libraryName = "City Library";

// Bad practice: Using 'string' for library names without considering potential memory overhead


// Best practice: Using 'int' for library IDs
int libraryId = 1001;

// Bad practice: Using 'byte' for library IDs, limiting the number of libraries in the system
byte badLibraryId = 255;

// Best practice: Using 'bool' for library status
bool isOpen = true;

// Bad practice: Using 'bool' for library status, limiting future expansion to more complex statuses
bool badIsOpen = false;

// Best practice: Using 'decimal' for budget values
decimal libraryBudget = 50000.50m;

// Bad practice: Using 'float' for budget values, risking precision issues with monetary values
float badLibraryBudget = 50000.50f;

// Best practice: Using 'int' for representing the number of books
int totalBooks = 5000;

// Bad practice: Using 'short' for the number of books, risking an insufficient range
short badTotalBooks = 5000;

// Best practice: Using 'string' for librarian names
string librarianName = "Alice Johnson";

// Bad practice: Using 'char' for librarian names, limiting name length to a single character
char badLibrarianName = 'A';

// Best practice: Using 'char' for library categories
char libraryCategory = 'P'; // 'P' for Public

// Bad practice: Using 'bool' for library categories, sacrificing readability and maintainability
bool isPublic = true;

// Best practice: Using 'bool' for member eligibility status
bool isEligible = false;

// Bad practice: Using 'int' for member eligibility status, risking confusion and hard-to-read code
int badIsEligible = 0;

// Best practice: Using 'DateTime' for membership start dates
DateTime membershipStartDate = DateTime.Now.AddMonths(-6);

// Bad practice: Using 'DateTime' for membership start dates when only the date is relevant
DateTime badMembershipStartDate = DateTime.Now;

// Best practice: Using arrays to store book IDs
int[] bookIds = { 101, 102, 103, 104, 105 };

// Bad practice: Declaring an array without initializing it, leading to potential runtime errors
int[] badBookIds;

// Best practice: Using 'enum' for book genres
public enum BookGenre { Fiction, NonFiction, Mystery, ScienceFiction };

BookGenre genre = BookGenre.Fiction;

// Bad practice: Using 'int' for book genres instead of enums, risking invalid values
int badGenre = 1;

// Best practice: Using nullable types for visitor ages
int? visitorAge = null;

// Bad practice: Using 'int' for nullable visitor ages, making it unclear when a value is undefined
int? badVisitorAge = 0;

// Best practice: Using 'struct' for representing a library branch
public struct LibraryBranch
{
    public int Id;
    public string Name;
    public decimal Budget;
}

LibraryBranch myBranch = new LibraryBranch { Id = 1001, Name = "City Library", Budget = 50000.50m };

// Bad practice: Using 'class' for representing a small, immutable structure, introducing unnecessary overhead
public class BadBranch
{
    public int Id;
    public string Name;
    public decimal Budget;
}

BadBranch badMyBranch = new BadBranch { Id = 1002, Name = "Lib123", Budget = 40000.25m };

// Best practice: Using 'dynamic' for handling different data types
dynamic dynamicVariable = 10;
dynamicVariable = "Hello, World!";

// Bad practice: Overusing 'dynamic' for all variables, sacrificing compile-time checks and readability
dynamic badDynamicVariable = 10;
badDynamicVariable = "Hello, World!";

// Best practice: Implicitly converting 'double' to 'int' without handling potential data loss
double doubleValue = 3.14;
int intValue = (int)doubleValue;

// Bad practice: Implicitly converting 'int' to 'double' without considering potential precision loss
int badIntValue = 42;
double badDoubleValue = badIntValue;