மாற்றம் என்பது ஒரு வகையின் மதிப்பை மற்றொரு வகைக்கு மாற்றும் செயல்முறையாகும்.System.Convert வகுப்பு ஆதரவு மாற்றங்களுக்கான முழுமையான முறைகளை வழங்குகிறது.
C# வகை மாற்றங்கள் இரண்டாக பிரிக்கப்படுகின்றன, மறைமுக மாற்றங்கள் மற்றும் வெளிப்படையான மாற்றங்கள்.தேவைப்படும்போது மறைமுகமாக அறிவிக்கப்பட்ட மாற்றங்கள் தானாகவே நிகழ்கின்றன மற்றும் வெளிப்படையானவை என அறிவிக்கப்பட்ட மாற்றங்கள் ஒரு cast ஐ அழைக்க வேண்டும்.
1: int num= 10;
2: long cnt= num;
// எண்ணாக வகையிலிருந்து நீண்ட வகைக்கு மறைமுக மாற்றம்
மேலே உள்ள கூற்றுகளிலிருந்து, முதல் வரி ஒரு முழு எண் வகை மாறி num ஐ அறிவித்து அதற்கு 10 ஒதுக்கப்பட்டுள்ளது. இரண்டாவது வரி ஒரு நீண்ட வகை மாறி எண்ணிக்கையை அறிவித்து, num இன் மதிப்பை எண்ணுவதற்கு ஒதுக்குகிறது.இங்கே மாற்றம் தானாக நிகழ்ந்தது.ஏனென்றால் ஒரு முழு எண் வகையை நீண்ட வகையாக மாற்றினோம். இந்த வகை மாற்றம் மறைமுக மாற்றம் என்று அழைக்கப்படுகிறது.
1: int num= 10;
2: long cnt= num;
// எண்ணாக வகையிலிருந்து நீண்ட வகைக்கு மறைமுக மாற்றம்
3: int con= (int)cnt;
// நீண்ட வகையிலிருந்து முழு எண்ணாக வெளிப்படையான மாற்றம்
இரண்டாவது வரிசையில் உள்ளார்ந்த மாற்றம் நிகழ்ந்ததை நாங்கள் ஏற்கனவே பார்த்தோம்.மூன்றாவது வரியை மீண்டும் நீண்ட வகையை ஒரு முழு வகையாக மாற்றினோம்.
இங்கே நாம் நீண்ட வகையை முழு எண்ணாக (int con= (int) எண்ணிக்கை) வெளிப்படையாக மாற்றுகிறோம், இல்லையெனில் கம்பைலர், கம்பைலர் பிழையைக் காண்பிக்கும்.
பிழை 1 'நீண்ட' வகையை மறைமுகமாக 'int' ஆக மாற்ற முடியாது.
வெளிப்படையான மாற்றம் உள்ளதா (நீங்கள் ஒரு castக் காணவில்லையா?).
இந்த வகை மாற்றம் வெளிப்படையான மாற்றம் என்று அழைக்கப்படுகிறது.
பின்வரும் C# மூல குறியீடு System.Convert வகுப்பை எவ்வாறு பயன்படுத்துவது என்பதைக் காட்டுகிறது.
using System;
using System.Windows.Forms;
namespace WindowsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
try
{
string name= "true";
bool phone= System.Convert.ToBoolean(name);
MessageBox.Show("pho value is " + phone);
}
catch (Exception ex)
{
MessageBox.Show("Cannot conver the value" + ex.ToString() );
}
}
}
}