Getting started with C# Language Verbatim Strings Operators Extension Methods Collection Initializers String Interpolation C# 6.0 Features Constructors and Finalizers Keywords Generics Reflection Inheritance Null-Coalescing Operator Using Statement String Escape Sequences Exception Handling Null-conditional Operators Built-in Types Lambda expressions Async-Await Properties Threading Using Directive Methods Yield Keyword Events LINQ Queries Common String Operations Expression Trees Overload Resolution String.Format nameof Operator Unsafe Code in .NET Initializing Properties BindingList<T>ILGenerator Object initializers XML Documentation Comments Preprocessor directives Dynamic type Anonymous types Structs Tuples Enum Access Modifiers Task Parallel Library Attributes Guid Singleton Implementation Delegates Nullable types Garbage Collector in .Net Networking Arrays Equality Operator Lock Statement Action Filters XmlDocument and the System.Xml namespace DateTime Methods BackgroundWorker Polymorphism Static Classes Indexer IDisposable interface Aliases of built-in types Immutability XDocument and the System.Xml.Linq namespace C# 7.0 Features Performing HTTP requests Generating Random Numbers in C#Looping Named Arguments Diagnostics Interfaces IEnumerable Naming Conventions An overview of c# collections Checked and Unchecked Recursion Functional Programming Literals Casting NullReferenceException Func delegates LINQ to XML Hash Functions Handling FormatException when converting string to other types Cryptography (System.Security.Cryptography)INotifyPropertyChanged interface Value type vs Reference type C# 4.0 Features IQueryable interface Task Parallel Library (TPL) Dataflow Constructs Stream Runtime Compile Conditional Statements Interoperability Overflow Equals and GetHashCode Type Conversion Parallel LINQ (PLINQ)String Manipulation String Concatenate Partial class and methods Stopwatches Regex Parsing C# Script C# 3.0 Features Async/await, Backgroundworker, Task and Thread Examples Timers Function with multiple return values Binary Serialization Making a variable thread safe IComparable Code Contracts Iterators AssemblyInfo.cs Examples File and Stream I/O Code Contracts and Assertions Caching C# 5.0 Features Implementing Flyweight Design Pattern StringBuilder Implementing Decorator Design Pattern Accessing Databases T4 Code Generation Microsoft.Exchange.WebServices .NET Compiler Platform (Roslyn)Data Annotation Using SQLite in C#System.Management.Automation FileSystemWatcher System.DirectoryServices.Protocols.LdapConnection Named and Optional Arguments Comments and regions C# Authentication handler Pointers & Unsafe Code Pointers How to use C# Structs to create a Union type (Similar to C Unions)BigInteger Dependency Injection Reactive Extensions (Rx)Creational Design Patterns Creating a Console Application using a Plain-Text Editor and the C# Compiler (csc.exe)Reading and writing .zip files Generic Lambda Query Builder Import Google Contacts Lambda Expressions CLSCompliantAttribute ObservableCollection<T>Synchronization Context in Async-Await ICloneable Read & Understand Stacktraces Linq to Objects ASP.NET Identity Access network shared folder with username and password Asynchronous Socket Structural Design Patterns O(n) Algorithm for circular rotation of an array Creating Own MessageBox in Windows Form Application Including Font Resources Object Oriented Programming In C#Using json.net Getting Started: Json with C#Windows Communication Foundation

Type Conversion

Remarks:

Type conversion is converting one type of data to another type. It is also known as Type Casting. In C#, type casting has two forms:

Implicit type conversion - These conversions are performed by C# in a type-safe manner. For example, are conversions from smaller to larger integral types and conversions from derived classes to base classes.

Explicit type conversion - These conversions are done explicitly by users using the pre-defined functions. Explicit conversions require a cast operator.

MSDN implicit operator example

class Digit
{
    public Digit(double d) { val = d; }
    public double val;

    // User-defined conversion from Digit to double
    public static implicit operator double(Digit d)
    {
        Console.WriteLine("Digit to double implict conversion called");
        return d.val;
    }
    //  User-defined conversion from double to Digit
    public static implicit operator Digit(double d)
    {
        Console.WriteLine("double to Digit implict conversion called");
        return new Digit(d);
    }
}

class Program
{
    static void Main(string[] args)
    {
        Digit dig = new Digit(7);
        //This call invokes the implicit "double" operator
        double num = dig;
        //This call invokes the implicit "Digit" operator
        Digit dig2 = 12;
        Console.WriteLine("num = {0} dig2 = {1}", num, dig2.val);
        Console.ReadLine();
    }
}

Output:

Digit to double implict conversion called
double to Digit implict conversion called
num = 7 dig2 = 12

Live Demo on .NET Fiddle

Explicit Type Conversion

using System;
namespace TypeConversionApplication 
{
   class ExplicitConversion 
   {
      static void Main(string[] args) 
      {
         double d = 5673.74; 
         int i;
         
         // cast double to int.
         i = (int)d;
         Console.WriteLine(i);
         Console.ReadKey();
      }
   }
}

Contributors

Topic Id: 3489

Example Ids: 11684,12056

This site is not affiliated with any of the contributors.