C# Version HisotryC# Language FeaturesInstalling Visual StudioC# Basic Project StructureHello Wolrd, first C# program
Variables in C# Explicitly typed variables in C#Implicitly typed variables in C#Constants in C#Data types in C#Integral data types in C#Floating-point data types in C#Comparison between Float, Double and DecimalChar data type in C#String data type in C#Boolean data type in C#DateTime data type in C#Enumeration data type in C#Array data type in C#Object data type in C#Dynamic data type in C#Anonymous data type in C#Nullable data type in C#Type casting in C#Type safety in C#Literals in C#Operators in C#Ternary Operator in C#Null coalescing Operator in C#Tilde(~) Operator in C#Keywords in C#Namespace in C#Nullable Types in C#Nullable Helper Class in C#Characteristics of Nullable typesC# Difference between "int" and "int?"
Block statement in C#Empty statement in C#Jump statements in C#Break statement in C#Continue statement in C#Difference between continue and breakGoto statement in C#Return statement in C#Throw statement in C#Yield keyword in C#Checked statement in C#Unchecked statement in C#Lock statement in C#Using statement in C#Enum/Enumeration in C#If-Else statement in C#Switch statement in C#What is a loop in C#?For loop in C#While loop in C#Do while loop in C#Foreach loop in C#Nested loop in C#Infinite loop in C#
C# Method or FunctionC# Method Parameters and ArgumentsC# Method OverloadingC# Return StatementsC# Static vs. Instance MethodsC# Method ModifiersC# Method Signatures and Naming ConventionsC# Function Documentation and CommentsC# Value Type ParametersC# Ref Type ParametersDifference between Value and Ref TypeC# Out ParametersDifference between Ref and out parametersC# Optional parametersAre Nullable types reference types in C#"
Exception Handling in C#Types of exception in C#Try catch finally in C#finally block in C#try block without catch blockMultiple catch blocks in exceptionCatch multiple exceptions in C#Base class of exception in C#finally block execution in C#finally block execution in case of errorFinally and return statementWays to use try-catch-finallyException throw from finally block"throw" and "throw ex" in C#Differene between finalize() and finallyInner exception in C#Error types in C#Catch multi exception by single catch blockUser defined/custom excetion in C#Compile and run time exception in C#Difference between "error" and "exception"System and application exception in C#Exception handling abuse in c#?
C# String BasicsC# String ManipulationC# String FormattingC# String Comparison and SearchingC# StringBuilder ClassC# Regular ExpressionsC# Unicode and EncodingC# String Parsing and ConversionDifference between "string" and "String"C# String Escape SequenceC# Mutable and Immutable ConceptProve that string is immutableString value stored in memoryDifference between string and stringbuilderOverride the tostring() method
Enum/enumeration in C#Can you inherit enum in C#?Convert enum to stringConvert enum to list in C#Cast int value to enum in C#Get int value from enum in C#Convert string to enum in C#Usage of enum in switch case statementLoop through all enum valuesUse tilde(~) with Enum
Main() method basics in C#More than one "Main()" method in C#Static Main() method in C#Overload Main() method in C#Override Main() method in C#Access modifiers of Main() method in C#Non-static method in C#Main() method arguments and return typeasync Main() method in C#Class without Main() method in C#Main() method rules in C#
Recursion in C#Base condition in recursion in C#Recursive Algorithms in C#Tree traversal using recursion in C#Stack overflow error in recursionBack tracking using recursionIndirect recursion in C#Recursive data structures in C#Tail Recursion in C#Recursive problem solvingRecursion vs Iteration
C# File and File InfoC# StreamReader and StreamWriterC# FileStream and BinaryReader/BinaryWriterC# Directory and DirectoryInfo ClassesC# File PathsC# File and Directory OperationsC# File Exceptions and Error HandlingC# File Serialization and DeserializationC# File System Watcher
What is array?Single dimension arrayMulti dimension arrayJagged arrayParam arrayArray with multi data typesDifferent data types from object arrayArray with non-default valuesArray methods and propertiesArray manipulation techniquesArray sorting algorithmsArray Searching algorithms(linear, binary search)Array finding maximum and minimumArray of Reference Types
C# GenericsC# Generic Constraints
C# ArrayListC# Array vs ArrayListC# ListC# SortedListC# DictionaryC# HashtableC# Dictionary vs HashtableC# HashSetC# Hashtable vs HashSetC# StackC# Queue
C# IEnumerableC# IEnumeratorC# ICollectionC# IListC# IDictionaryC# IDisposableC# IComparableC# IEquatableC# ICloneableC# IQueryableC# INotifyPropertyChangedC# INotifyCollectionChangedC# IFormattableC# IAsyncResultC# IComparerC# IEqualityComparerC# IHttpHandlerC# IHttpModule
C# DelegatesC# Single-Cast DelegateC# Multi-Cast DelegateC# Generic DelegatesC# Func DelegateC# Action DelegateC# Predicate DelegateC# Anonymous MethodsC# EventsDifference Between Event & DelegateDifference Between Interface & DelegateC# Covariance and Contravariance
Previous
Next

C# - object data type

In C#, the object data type is a fundamental data type that serves as the base type for all other types in the C# type system. It's a versatile data type that can store values of any other data type. Essentially, it's a way to represent data in a generic, non-specific manner.

Here's a simple example to illustrate the use of the object data type in C#:


using System;

class Program
{
    static void Main()
    {
        // Using the object data type to store various types of data
        object genericData; // Declare a variable of type "object"

        genericData = 10; // Store an integer
        Console.WriteLine("Stored integer: " + genericData);

        genericData = "Hello, C#"; // Store a string
        Console.WriteLine("Stored string: " + genericData);

        genericData = 3.14; // Store a double
        Console.WriteLine("Stored double: " + genericData);
    }
}

In this example:

  1. We declare a variable named genericData of type object.
  2. We store different types of data in genericData, including an integer, a string, and a double.
  3. The Console.WriteLine statements display the stored data.

The output of this program will be:


Stored integer: 10
Stored string: Hello, C#
Stored double: 3.14

As you can see, we can store various types of data in an object variable, making it a versatile choice when you need to work with different data types in a generic way.

Characteristics of the object Type in C#

  1. Universal Base Type: The object type is the ultimate base type for all other types in C#. This means that every data type, whether it's a value type (e.g., int, double) or a reference type (e.g., string, class), can be implicitly cast to the object type.
  2. Boxing and Unboxing: When a value type is assigned to an object type, it undergoes a process called boxing. Boxing is the conversion of a value type to a reference type (i.e., it's wrapped in an object). Conversely, unboxing is the process of extracting a value type from an "object." These operations can impact performance and should be used judiciously.
  3. Dynamic Type: The object type allows you to store data of any type dynamically. This can be useful when the type of data you're working with is not known at compile-time. However, it comes at the cost of compile-time type safety, as you lose the ability to access members of the object without explicit casting.
  4. Lack of Compile-Time Type Checking: Since the object type can store any type of data, the compiler doesn't provide type checking at compile-time. This can lead to runtime errors if you attempt to perform operations on an object without proper casting.
  5. Common Use Cases: The object type is often used in scenarios where you need to work with mixed types of data, such as creating collections (e.g., List<object>) that can hold various types of objects. It's also used in reflection to work with unknown types at runtime.
  6. Reference Semantics: When you store a reference type (e.g., a class instance) in an object variable, it still retains its reference semantics. This means that changes made to the object through the object variable will affect the original object.
  7. Value Semantics for Value Types: When you store a value type (e.g., int, struct) in an object variable, it's treated as a value. This means that changes made to the object variable won't affect the original value.
  8. Limited Compile-Time Support: When working with object types, you lose compile-time support, such as IntelliSense and type-specific methods. You'll need to cast objects to their original types to access their members.
  9. Potential for Runtime Errors: Because of the lack of compile-time type checking, using object types can lead to runtime errors if not used carefully. It's important to ensure that the object contains the expected type before performing operations on it.
Previous
Next