Taipkan Hantaran dalam C#

Jenis Casting dalam C# ditakrifkan seolah-olah kami menetapkan mana-mana jenis data kepada jenis data lain kemudian memanggilnya sebagai "Typecasting". Mana-mana bahasa pengaturcaraan nilai jenis data yang lebih rendah secara automatik boleh dimasukkan ke dalam nilai jenis data atas. Dalam keadaan ini tiada kehilangan data, manakala dalam kes nilai jenis data atas ke nilai jenis data yang lebih rendah mungkin terdapat kemungkinan kehilangan data. Jenis data yang lebih rendah kepada jenis data atas boleh secara automatik dilakukan oleh pengkompil C# tetapi jenis data atas untuk penyiapan data yang lebih rendah, kita mesti memerlukan pengetikan yang jelas. Yang dikenali sebagai "Pemutus eksplisit".

Mari kita ambil contoh nilai panjang kepada nilai int ialah penyiapan taip yang eksplisit.

Mengapa penghantaran eksplisit memerlukan jenis data yang lebih besar kepada jenis data yang lebih kecil?

Mari kita pertimbangkan analogi kecil maka anda akan faham dengan sangat jelas, terdapat 2 botol air, satu adalah 1 liter dan satu lagi adalah 2 liter. Kita boleh dengan mudah menuangkan 1 liter air ke dalam 2 liter botol air tanpa melimpah. Begitu juga jika kita cuba menuangkan 2 liter air botol air ke dalam 1 liter maka mungkin ada peluang air melimpah jika botol air 2 liter mengandungi lebih daripada 1 liter air. Jadi, dalam kes ini, botol air 1 liter ialah jenis data yang lebih rendah dan botol air 2 liter ialah jenis data atas. Walaupun ada peluang air melimpah tetap kami nak tuang 2 liter air ke dalam botol air 1 liter yang boleh kami tuang supaya pelanggan mesti terima untuk berbuat demikian. Cara yang sama pembangun mempunyai idea yang jelas walaupun kami cuba menghantar jenis data atas ke jenis data yang lebih rendah mungkin terdapat kehilangan data, jadi dia mesti menerimanya.

Jenis Penghantaran dalam C#

Terdapat 2 jenis pemutus dalam C#.

• Pemutus jenis eksplisit
• Penghantaran jenis tersirat: jenis data yang lebih kecil kepada penukaran jenis data yang lebih besar dikatakan sebagai "Pemutus taip tersirat". Ini secara automatik dilakukan oleh pengkompil C#. Tiada kehilangan data.

1. Hantaran Jenis Tersirat

bait->pendek->int->panjang->apung->ganda

Kod:

Bigger_dataType  variableName=smaller_dataType_Value;

2. Hantaran Jenis Eksplisit

jenis data yang lebih besar kepada penukaran jenis data yang lebih kecil dikatakan sebagai "Penyecoran taip eksplisit". Ini tidak dilakukan secara automatik oleh pengkompil C#. Mungkin ada kehilangan data. Ini mesti dilakukan oleh pembangun secara eksplisit.

bait->pendek, int, panjang, terapung, berganda

pendek->int, panjang, terapung, dua kali ganda

int->panjang, terapung, dua kali ganda

panjang->apung, berganda

apung->ganda

Kod:

Smaller_dataType  variableName=(Smaller_dataType)Bigger_dataType_Value;

Nota: Penghantaran boleh digunakan dengan jenis data yang serasi sahaja, bermakna nombor dengan penukaran nombor sahaja tetapi bukan rentetan dengan nombor sebaliknya, dsb. Saya berbuat demikian mungkin terdapat pengecualian yang tidak disokong berlaku.

Kaedah untuk Penukaran Jenis

• ToBoolean: Ia akan menukar jenis kepada nilai Boolean.
• ToChar: Ia akan menukar jenis kepada nilai aksara.
• ToByte: Ia akan menukar nilai kepada nilai Byte.
• KepadaPerpuluhan: Ia akan menukar nilai kepada nilai titik Perpuluhan.
• ToDouble: Ia akan menukar jenis kepada jenis data berganda.
• ToInt16: Ia akan menukar jenis kepada integer 16-bit
• ToInt32: Ia akan menukar jenis kepada integer 32-bit
• ToInt64: Ia akan menukar jenis kepada integer 64-bit
• ToString: Ia akan menukar jenis yang diberikan kepada String
• ToUInt16: Ia akan menukar jenis kepada integer 16-bit yang tidak ditandatangani
• ToUInt32: Ia akan menukar jenis kepada integer 32-bit yang tidak ditandatangani
• ToUInt64: Ia akan menukar jenis kepada integer 64-bit yang tidak ditandatangani

Contoh Untuk Melaksanakan Jenis Casting dalam C#

Di bawah adalah beberapa contoh disebutkan:

Contoh #1

Pemutus jenis tersirat

Kod:

//including System package in C#
using System;
//Creating class
public class ImplicitTypeCasting {
// main method for application to run
public static void Main(String []args)
{
//variable declaration and initialization
int intType = 200;
// Implicit int to long casting
long longType = intType;
// Implicit long to float casting
float floatType = longType;
// Printing output of implicit conversion variables
Console.WriteLine("INT value after Implicit conversion: " +intType);
Console.WriteLine("LONG value after Implicit conversion:" +longType);
Console.WriteLine("FLOAT value after Implicit conversion: " +floatType);
}
}

Output:

Contoh #2

Mencuba jenis yang lebih besar kepada jenis yang lebih rendah Penghantaran jenis tersirat

Kod:

//including System package in C#
using System;
//Creating class
public class ImplicitCastingBiggerToSmaller {
// main method for application to run
public static void Main(String []args)
{
//variable declaration and initialization
int intType = 200;
// Trying to convert int to byte Implicitly but there is compile time error
byte byteType = intType;
// Trying to convert int to short Implicitly but there is compile time error
short shortType = intType;
// Printing output of implicit conversion variables
Console.WriteLine("INT value after Implicit conversion: " +intType);
Console.WriteLine("BYTE value after Implicit conversion:" +byteType);
Console.WriteLine("SHORT value after Implicit conversion: " +shortType);
}
}

Output:

Contoh #3

Penghantaran jenis eksplisit

Kod:

//including System package in C#
using System;
//Creating class
public class ExplicitCastingBiggerToSmaller {
// main method for application to run
public static void Main(String []args)
{
//variable declaration and initialization
int intType = 9999999;
int intType1=120;
// Trying to convert int to byte explicitly
byte byteType = (byte)intType;
byte byteType1 = (byte)intType1;
// Trying to convert int to short explicitly
short shortType = (short)intType;
short shortType1 = (short)intType1;
// Printing output of explicit conversion variables
//Given int range is not in byte and short range so there must be loss of data result into incorrect output
Console.WriteLine("BYTE value after Explicit conversion: " +byteType);
Console.WriteLine("SHORT value after Explicit conversion: " +shortType);
Console.WriteLine("\n");
// Printing output of explicit conversion variables
//Given int range is in byte and short range so there no data loss
Console.WriteLine("BYTE value after Explicit conversion: " +byteType1);
Console.WriteLine("SHORT value after Explicit conversion: " +shortType1);
}
}<strong> </strong>

Output:

Contoh #4

Pemutus jenis eksplisit dengan kaedah yang telah ditetapkan

Kod:

//including System package in C#
using System;
//Creating class
public class ExplicitCastingBiggerToSmaller {
// main method for application to run
public static void Main(String []args)
{
//variable declaration and initialization
int intType = 9999999;
double doubleType=122.23;
float floatType=222.222f;
// Printing output of explicit convertion variables
//By using C# predefined method for type casting
Console.WriteLine("INT to STRING type value with predefined method convertion: "+Convert.ToString(intType));
Console.WriteLine("DOUBLE to INT type value with predefined method convertion: "+Convert.ToInt32(doubleType));
Console.WriteLine("FLOAT to INT type value with predefined method convertion: "+Convert.ToUInt32(floatType));
}
}

Output:

Kesimpulan

C# terdapat 2 jenis tuangan jenis ada, 1^st satu tuangan jenis tersirat dan yang kedua tuangan taip eksplisit. Penghantaran jenis tersirat secara automatik dilakukan oleh pengkompil tetapi pembangun penghantaran jenis eksplisit mesti dilakukan kerana dalam kes ini mungkin terdapat peluang untuk kehilangan data.

Atas ialah kandungan terperinci Taipkan Hantaran dalam C#. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!