{"id":115,"date":"2014-05-01T12:33:00","date_gmt":"2014-05-01T11:33:00","guid":{"rendered":"https:\/\/debuggersspace.com\/index.php\/2014\/05\/01\/c-data-types\/"},"modified":"2014-05-01T12:33:00","modified_gmt":"2014-05-01T11:33:00","slug":"c-data-types","status":"publish","type":"post","link":"https:\/\/debuggersspace.com\/index.php\/2014\/05\/01\/c-data-types\/","title":{"rendered":"C# – Data Types?"},"content":{"rendered":"
\n
\n \t<\/i> Read Time:<\/span>3 Minute, 47 Second <\/div>\n\n <\/div>
\n
\n
\nValue types are stored in the Stack.<\/span><\/div>\n
\nExamples : bool, byte, chat, decimal, double, enum , float, int, long, sbyte, short, strut, uint, ulong, ushort.<\/span><\/div>\n
\n
<\/span><\/div>\n
\nReference types are stored in the Heap. <\/span><\/div>\n

<\/span><\/p>\n

\nExamples : class, delegate, interface, object, string.<\/span><\/div>\n

————————————————————————————————————<\/span>
\nIn C#, variables are categorized into the following types:<\/span><\/div>\n

    \n
  • \n
    \nValue types<\/span><\/div>\n<\/li>\n
  • \n
    \nReference types<\/span><\/div>\n<\/li>\n
  • \n
    \nPointer types<\/span><\/div>\n<\/li>\n<\/ul>\n

    \nValue Types<\/span><\/span><\/h2>\n
    \nValue type variables can be assigned a value directly. They are derived from the classSystem.ValueType<\/b>.<\/span><\/div>\n
    \nThe value types directly contain data. Some examples are int, char, float<\/b>, which stores numbers, alphabets, floating point numbers, respectively. When you declare an int<\/b> type, the system allocates memory to store the value.<\/span><\/div>\n
    \nThe following table lists the available value types in C# 2010:<\/span><\/div>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
    Type<\/span><\/th>\nRepresents<\/span><\/th>\nRange<\/span><\/th>\nDefault
    Value<\/span><\/th>\n<\/tr>\n
    bool<\/span><\/td>\nBoolean value<\/span><\/td>\nTrue or False<\/span><\/td>\nFalse<\/span><\/td>\n<\/tr>\n
    byte<\/span><\/td>\n8-bit unsigned integer<\/span><\/td>\n0 to 255<\/span><\/td>\n0<\/span><\/td>\n<\/tr>\n
    char<\/span><\/td>\n16-bit Unicode character<\/span><\/td>\nU +0000 to U +ffff<\/span><\/td>\n‘\u0000’<\/span><\/td>\n<\/tr>\n
    decimal<\/span><\/td>\n128-bit precise decimal values with 28-29 significant digits<\/span><\/td>\n(-7.9 x 1028<\/sup> to 7.9 x 1028<\/sup>) \/ 100 to 28<\/sup><\/span><\/td>\n0.0M<\/span><\/td>\n<\/tr>\n
    double<\/span><\/td>\n64-bit double-precision floating point type<\/span><\/td>\n(+\/-)5.0 x 10-324<\/sup> to (+\/-)1.7 x 10308<\/sup><\/span><\/td>\n0.0D<\/span><\/td>\n<\/tr>\n
    float<\/span><\/td>\n32-bit single-precision floating point type<\/span><\/td>\n-3.4 x 1038<\/sup> to + 3.4 x 1038<\/sup><\/span><\/td>\n0.0F<\/span><\/td>\n<\/tr>\n
    int<\/span><\/td>\n32-bit signed integer type<\/span><\/td>\n-2,147,483,648 to 2,147,483,647<\/span><\/td>\n0<\/span><\/td>\n<\/tr>\n
    long<\/span><\/td>\n64-bit signed integer type<\/span><\/td>\n-923,372,036,854,775,808 to 9,223,372,036,854,775,807<\/span><\/td>\n0L<\/span><\/td>\n<\/tr>\n
    sbyte<\/span><\/td>\n8-bit signed integer type<\/span><\/td>\n-128 to 127<\/span><\/td>\n0<\/span><\/td>\n<\/tr>\n
    short<\/span><\/td>\n16-bit signed integer type<\/span><\/td>\n-32,768 to 32,767<\/span><\/td>\n0<\/span><\/td>\n<\/tr>\n
    uint<\/span><\/td>\n32-bit unsigned integer type<\/span><\/td>\n0 to 4,294,967,295<\/span><\/td>\n0<\/span><\/td>\n<\/tr>\n
    ulong<\/span><\/td>\n64-bit unsigned integer type<\/span><\/td>\n0 to 18,446,744,073,709,551,615<\/span><\/td>\n0<\/span><\/td>\n<\/tr>\n
    ushort<\/span><\/td>\n16-bit unsigned integer type<\/span><\/td>\n0 to 65,535<\/span><\/td>\n0<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
    \nTo get the exact size of a type or a variable on a particular platform, you can use the sizeof<\/b> method. The expression sizeof(type)<\/i> yields the storage size of the object or type in bytes. Following is an example to get the size of int<\/i> type on any machine:<\/span><\/div>\n
    namespace<\/span> <\/span>DataTypeApplication<\/span>\n<\/span>{<\/span>\n   <\/span>class<\/span> <\/span>Program<\/span>\n   <\/span>{<\/span>\n      <\/span>static<\/span> <\/span>void<\/span> <\/span>Main<\/span>(<\/span>string<\/span>[]<\/span> args<\/span>)<\/span>\n      <\/span>{<\/span>\n         <\/span>Console<\/span>.<\/span>WriteLine<\/span>(<\/span>\"Size of int: {0}\"<\/span>,<\/span> <\/span>sizeof<\/span>(<\/span>int<\/span>));<\/span>\n         <\/span>Console<\/span>.<\/span>ReadLine<\/span>();<\/span>\n      <\/span>}<\/span>\n   <\/span>}<\/span>\n<\/span>}<\/span><\/span><\/pre>\n
    \nWhen the above code is compiled and executed, it produces the following result:<\/span><\/div>\n
    Size of int: 4\n<\/span><\/pre>\n
    \nReference Types<\/span><\/span><\/h2>\n
    \nThe reference types do not contain the actual data stored in a variable, but they contain a reference to the variables.<\/span><\/div>\n
    \nIn other words, they refer to a memory location. Using more than one variable, the reference types can refer to a memory location. If the data in the memory location is changed by one of the variables, the other variable automatically reflects this change in value. Example of built-in<\/b> reference types are:object<\/b>, dynamic<\/b> and string<\/b>.<\/span><\/div>\n
    \nOBJECT TYPE<\/span><\/span><\/h3>\n
    \nThe Object Type<\/b> is the ultimate base class for all data types in C# Common Type System (CTS). Object is an alias for System.Object class. So object types can be assigned values of any other types, value types, reference types, predefined or user-defined types. However, before assigning values, it needs type conversion.<\/span><\/div>\n
    \nWhen a value type is converted to object type, it is called boxing<\/b> and on the other hand, when an object type is converted to a value type, it is called unboxing<\/b>.<\/span><\/div>\n
    object<\/span> obj<\/span>;<\/span>\nobj <\/span>=<\/span> <\/span>100<\/span>;<\/span> <\/span>\/\/ this is boxing<\/span><\/span><\/pre>\n
    \nDYNAMIC TYPE<\/span><\/span><\/h3>\n
    \nYou can store any type of value in the dynamic data type variable. Type checking for these types of variables takes place at run-time.<\/span><\/div>\n
    \nSyntax for declaring a dynamic type is:<\/span><\/div>\n
    dynamic<\/span> <\/span><variable_name><\/span> <\/span>=<\/span> value<\/span>;<\/span><\/span><\/pre>\n
    \nFor example,<\/span><\/div>\n
    dynamic<\/span> d <\/span>=<\/span> <\/span>20<\/span>;<\/span><\/span><\/pre>\n
    \nDynamic types are similar to object types except that type checking for object type variables takes place at compile time, whereas that for the dynamic type variables take place at run time.<\/span><\/div>\n
    \nSTRING TYPE<\/span><\/span><\/h3>\n
    \nThe String Type<\/b> allows you to assign any string values to a variable. The string type is an alias for the System.String class. It is derived from object type. The value for a string type can be assigned using string literals in two forms: quoted and @quoted.<\/span><\/div>\n
    \nFor example,<\/span><\/div>\n
    String<\/span> str <\/span>=<\/span> <\/span>\"Tutorials Point\"<\/span>;<\/span><\/span><\/pre>\n
    \nA @quoted string literal looks like:<\/span><\/div>\n
    @<\/span>\"Tutorials Point\"<\/span>;<\/span><\/span><\/pre>\n
    \nThe user-defined reference types are: class, interface, or delegate. We will discuss these types in later chapter.<\/span><\/div>\n
    \nPointer Types<\/span><\/span><\/h2>\n
    \nPointer type variables store the memory address of another type. Pointers in C# have the same capabilities as in C or C++.<\/span><\/div>\n
    \nSyntax for declaring a pointer type is:<\/span><\/div>\n
    type<\/span>*<\/span> identifier<\/span>;<\/span><\/span><\/pre>\n
    \nFor example,<\/span><\/div>\n
    char<\/span>*<\/span> cptr<\/span>;<\/span>\n<\/span>int<\/span>*<\/span> iptr<\/span>;<\/span><\/span><\/pre>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
    Value types are stored in the Stack. Examples : bool, byte, chat, decimal, double, enum , float, int, long, sbyte, short, strut, uint, ulong, ushort. Reference types are stored in the Heap.  Examples : class, delegate, interface, object, string. ———————————————————————————————————— In C#, variables are categorized into the following types: Value types Reference types Pointer types […]<\/p>\n","protected":false},"author":43,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","footnotes":""},"categories":[24],"tags":[],"class_list":["post-115","post","type-post","status-publish","format-standard","hentry","category-c-net"],"uagb_featured_image_src":{"full":false,"thumbnail":false,"medium":false,"medium_large":false,"large":false,"1536x1536":false,"2048x2048":false},"uagb_author_info":{"display_name":"Himanshu Namdeo","author_link":"https:\/\/debuggersspace.com\/author\/admin\/"},"uagb_comment_info":0,"uagb_excerpt":"Value types are stored in the Stack. Examples : bool, byte, chat, decimal, double, enum , float, int, long, sbyte, short, strut, uint, ulong, ushort. Reference types are stored in the Heap.  Examples : class, delegate, interface, object, string. ———————————————————————————————————— In C#, variables are categorized into the following types: Value types Reference types Pointer types…","_links":{"self":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts\/115"}],"collection":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/users\/43"}],"replies":[{"embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/comments?post=115"}],"version-history":[{"count":0,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts\/115\/revisions"}],"wp:attachment":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/media?parent=115"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/categories?post=115"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/tags?post=115"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}