Shulou(Shulou.com)06/02 Report--

This article will explain in detail what the specific .NET data types are, and the content of the article is of high quality, so the editor will share it with you for reference. I hope you will have some understanding of the relevant knowledge after reading this article.

.net data type string (String)

String

Represents text, which is a series of Unicode characters. A string is an ordered collection of Unicode characters used to represent text. The String object is an ordered collection of System.Char objects that represent strings. The value of the String object is the content of the ordered collection, and the value is immutable (that is, read-only). The * size of the String object is 2 GB or about 1 billion characters in memory.

Keyword

String

Value range

A set of characters

Analytical value

Int number = Convert .ToInt32 (strNumber)

Formatting

Keep 2 decimal places

Bc.FRetailPrice = String.Format ("{0:N2}", Convert.ToDecimal (double.Parse (dgvBarcode.Rows [I] .cells ["FRetailPrice"] .Value.ToString (), 2)) .ToString ()

Common methods

Trim: removes specified characters from the beginning and end of a string

Concat: string concatenation

Escape character

\ 'single quotation marks

\ "double quotation marks

\\ backslash

\ 0 empty

\ a warning

\ b backspace

\ f Page change

\ nWrap

\ r enter

\ t horizontal tabs

\ v Vertical tab character

Verbatim string

String prefixed with @

Compare

String.IsNullOrEmpty (str1)

S = = string.Empty

S.Length = = 0

S = ""

Compare null value

Comparison of equality

When comparing using the = = and! = operators, the reference type compares objects in memory, but string's equality operator is redefined to compare the value of the string.

Immutability

Once the string is initialized, it cannot be changed, and the modification results in a new string object, so the abuse of string is extremely inefficient.

StringBuilder

Use StringBuilder to modify the string, modifying the object rather than generating a new object.

.net data types and so on (Class)

Class

Class is the most powerful data type in C#. Like structures, classes define the data and behavior of data types. The programmer can then create objects that are instances of this class. Unlike structures, classes support inheritance, which is a fundamental part of object-oriented programming.

Constructor function

Constructors are class methods that are executed when an object of a given type is created, and are called at run time rather than compile time, including instance constructors and static constructors. The constructor is the same as the class name and cannot have a return value.

Constructor chain

Using the this keyword to make concatenated constructor calls, you can use optional arguments instead of constructor chains, but the syntax for optional parameters can only be run in the .NET 4 environment.

Static constructor

Destructor (Terminator)

The destructor is used to destruct the instance of the class and to reconstruct the object's Finalize () method. You cannot define a destructor in a structure. Destructors can only be used on classes. A class can have only one destructor. The destructor cannot be inherited or overloaded. Unable to call destructor. They are called automatically. Destructors have neither modifiers nor parameters and are implicitly protected.

Keyword

New: creating new object

This: instance object

Base: base class object

Static: static

Default access modifier

Classes: implicit internals

Default constructor: implicitly private

Object

Class instantiation, instantiated using the new keyword

Object initializer

The object initializer can create an object and set some properties and public fields with only a small amount of code, using {} when initializing the object, and internally using a comma-separated list of specified values. each member in the initialization list is mapped to a public field or public property in the object being initialized.

Code example

Point p = new Point {Xue1mai Yin2}

Object

The object type is an alias for Object in the .NET Framework. In C# 's unified type system, all types (predefined types, user-defined types, reference types, and value types) inherit directly or indirectly from Object. You can assign any type of value to a variable of type object.

Boxing

The process of converting a variable of a value type to an object is called boxing.

Unpacking

The process of converting a variable of an object type to a value type is called unboxing.

Pointer type of .NET data type (type*)

Pointer type

In an unsafe context, a type can be a pointer type and a value type or a reference type. Pointer types do not inherit object, and there is no conversion between pointer types and object. In addition, boxing and unboxing do not support pointers. However, conversions between different pointer types and between pointer types and integers are allowed. When multiple pointers are declared in the same declaration, * is used only with the underlying type, not as a prefix for each pointer name. A pointer cannot point to a reference or a structure that contains a reference, because even if there is a pointer to an object reference, the object reference may be garbage collected. GC does not pay attention to whether there are any types of pointers to objects.

Grammar

Type* identifier;void* identifier; int* p1, p2, p3; int number;int* p = & number; char* charPointer = stackalloc char [123]; for (int I = 65; I

< 123; i++){charPointer[i] = (char)i;} 指针类型声明 示例说明 int* p p 是指向整数的指针 int** p p 是指向整数的指针的指针 int*[] p p 是指向整数的指针的一维数组 char* p p 是指向字符的指针 void* p p 是指向未知类型的指针 指针相关的运算符和语句 运算符/语句用途 * 执行指针间接寻址。 ->

Access members of the structure through pointers.

[]

Index the pointer.

&

Gets the address of the variable.

+ + and--

Increment or decrease the pointer.

Add and subtract

Execute the pointer algorithm.

=,!, =

Compare pointers.

Stackalloc

Allocate memory on the stack.

Fixed statement

Temporarily fix the variable so that its address can be found.

Pointer conversion

Implicit pointer conversion

From to

Any pointer type

Void*

Null

Any pointer type

Display pointer conversion

From to

Any pointer type

All other pointer types

Sbyte, byte, short, ushort, int, uint, long or ulong

Any pointer type

Any pointer type

Sbyte, byte, short, ushort, int, uint, long or ulong

Code example

Pointer access member

Pointer accesses array elements

Pointer copy byte array

Class TestCopy

{

Static unsafe void Copy (byte [] src, int srcIndex, byte [] dst, int dstIndex, int count)

{

If (src = = null | | srcIndex

< 0 || dst == null || dstIndex < 0 || count < 0) { throw new System.ArgumentException(); } int srcsrcLen = src.Length; int dstdstLen = dst.Length; if (srcLen - srcIndex < count || dstLen - dstIndex < count) { throw new System.ArgumentException(); } fixed (byte* pSrc = src, pDst = dst) { byte* ps = pSrc; byte* pd = pDst; for (int i = 0 ; i < count / 4 ; i++) { *((int*)pd) = *((int*)ps); pd += 4; ps += 4; } for (int i = 0; i < count % 4 ; i++) { *pd = *ps; pd++; ps++; } } } static void Main() { byte[] a = new byte[100]; byte[] b = new byte[100]; for (int i = 0; i < 100; ++i) { a[i] = (byte)i; } Copy(a, 0, b, 0, 100); System.Console.WriteLine("The first 10 elements are:"); for (int i = 0; i < 10; ++i) { System.Console.Write(b[i] + " "); } System.Console.WriteLine("\n"); } } class Pointers { unsafe static void Main() { char* charPointer = stackalloc char[123]; for (int i = 65; i < 123; i++) { charPointer[i] = (char)i; } System.Console.WriteLine("Uppercase letters:"); for (int i = 65; i < 91; i++) { System.Console.Write(charPointer[i]); } System.Console.WriteLine(); System.Console.WriteLine("Lowercase letters:"); for (int i = 97; i < 123; i++) { System.Console.Write(charPointer[i]); } } } truct CoOrds{ public int x; public int y; } class AccessMembers { static void Main() { CoOrds home; unsafe { CoOrds* p = &home; p->

X = 25

P-> y = 12

System.Console.WriteLine ("The coordinates are: X = {0}, y = {1}", p-> x, p-> y)

}

}

}

Dynamic types of .NET data types (Dynamic)

Dynamic

In operations implemented through the dynamic type, the purpose of this type is to bypass compile-time type checking and instead resolve these operations at run time. The dynamic type simplifies access to COM API (such as Office Automation API), dynamic API (such as IronPython libraries), and HTML document object Model (DOM).

In most cases, the dynamic type behaves the same as the object type. However, operations that contain dynamic type expressions are not parsed or type checked by the compiler. The compiler packages information about the operation together, and that information is later used to calculate run-time operations. During this process, a variable of type dynamic is compiled into a variable of type object. Therefore, the type dynamic exists only at compile time, but not at run time.

Code example

In the declaration, the type as a property, field, indexer, parameter, return value, or type constraint. The following class definition uses dynamic in several different declarations.

Class ExampleClass

{

Static dynamic field

Dynamic prop {get; set;}

Public dynamic exampleMethod (dynamic d)

{

Dynamic local = "Local variable"

Int two = 2

If (d is int)

{

Return local

}

Else

{

Return two

}

}

}

In an explicit type conversion, as the target type of the conversion.

Static void convertToDynamic () {dynamic d; int i = 20; d = (dynamic) I; Console.WriteLine (d); string s = "Example string."; d = (dynamic) s; Console.WriteLine (d); DateTime dt = DateTime.Today; d = (dynamic) dt; Console.WriteLine (d);}

In any context where the type is used as a value (such as to the right of the is operator or the as operator) or becomes part of the constructed type as an argument to the typeof. For example, you can use dynamic in the following expression.

Int I = 8; dynamic d; d = i as dynamic; Console.WriteLine (typeof (List))

Anonymous types of .NET data types (var)

Anonymous type

Anonymous types provide a convenient way to encapsulate a set of read-only properties into a single object without first explicitly defining a type. Type names are generated by the compiler and cannot be used at the source code level. The type of each attribute is inferred by the compiler.

Anonymous types can be created by using the new operator and object initialization.

Restriction condition

There are no names that control anonymous types

Anonymous types inherit from Object

Fields and properties of anonymous types are always read-only

Anonymous types do not support events, custom methods, custom operators, and custom overrides

Anonymous types are implicitly closed

Instance creation of anonymous types uses only the default constructor

Grammar

Var v = new {Amount = 108, Message = "Hello"}

Var anonArray = new [] {new {name = "apple", diam = 4}, new {name = "grape", diam = 1}}

Var productQuery =

From prod in products

Select new {prod.Color, prod.Price}

Foreach (var v in productQuery)

{

Console.WriteLine ("Color= {0}, Price= {1}", v.Color, v.Price)

}

About the specific .NET data types are shared here, I hope that the above content can be of some help to you, can learn more knowledge. If you think the article is good, you can share it for more people to see.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.