Veranderlike

'n Veranderlike kan vergelyk word met 'n stoor kamer, en is onmisbaar vir die ontwikelaar. In C# word 'n veranderlike so geskep:

<data tipe> <name>;

Byvoorbeeld om 'n Text veranderlike te skep lyk so:

string name;

Ons veranderlike is nou geskep op die heel eenvodigste vlak, maar die veranderlike het nog nie 'n waarde nie. Mens kan 'n veranderlike eenige tyd 'n waarde toeskryf of die waarde kan toegeskryf word gelyktydig met die skepping daar van, so:

<data type> <name> = <value>;

As die veranderlike nie deel is van die methode waarme jy werk (bv. 'n klas lid veranderlike), jy sal heelvarskynlik sigbaarheid wil toeken aan die veranderlike:

<sigbaarheid> <data tipe> <name> = <waarde>;

'n vooltooide voorbeeld lyk so:

private string name = "John Doe";

Die sigbaarheid gedeelte is gekoppel an klasse, vir 'n volheedige verduideliking kay na die hoofstuk oor klasse. Ons gaan nou net op die veranderlike gedeelte konsentreer, met 'n voorbeeld waar ons van 'n paar van hulle gebruikmaak:

using System;

namespace ConsoleApplication1
{
    class Program
    {
    static void Main(string[] args)
    {
        string firstName = "John";
        string lastName = "Doe";

        Console.WriteLine("Name: " + firstName + " " + lastName);

        Console.WriteLine("Please enter a new first name:");
        firstName = Console.ReadLine();

        Console.WriteLine("New name: " + firstName + " " + lastName);

        Console.ReadLine();
    }
    }
}

Baie van die kode bo is klaar verduidelik, so ons gaan by die interesante gedeelte inspring. Eerstens skep ons 'n paar veranderlikes met data tipe "string". 'n String bestaan uit text, soos jy kan sien in die voorbeeld bo want die waarde word daadelik toegeken. Folgende skryf ons die text na die skerm, waar ons van al twee gebruik maak. Om die volle text te maak, maak ons gebruik van die "+" karakter om twee text veranderlike bymekaar te voeg.

Daarna vra ons die gebruiker on 'n nuwe eerste naam intetik, ons gebruik die "ReadLine()" metode om van die skerem af die ingetikte eerste naam aan die FirstName verandelike toeteken, dit gebeur as die gebruiker die "Enter" knoppie druk, daarna word die nuwe eerste name + die van na die skerm geskryf. Ons het so pas gebruikgemaak van ons eerste veranerlike. Die belangrike ding wat hierdie voorbeeld wys is 'n veranderlike se waarde kan verander word terwyl dir program loop.

Nog 'n interesante voorbeeld is as mens wiskunde will doen. In die voorige voorbeeld as ons die data tipe verander na 'n nomer tipe "integer":

int number1, number2;

Console.WriteLine("Please enter a number:");
number1 = int.Parse(Console.ReadLine());

Console.WriteLine("Thank you. One more:");
number2 = int.Parse(Console.ReadLine());

Console.WriteLine("Adding the two numbers: " + (number1 + number2));

Console.ReadLine();

Verander ons "Main" methode sodat hy soos die kode bo lyk. Die eenigste verandering is daar is 'n metode wat geroep word, naamlik int.Parse(). Al wat hierdie methode doen is hy lees 'n text end verander dit in 'n heel nomer. As mens iets intik war nie in 'n nomer verander kan word, word 'n uitsondering geskep. Ons sal later verder hieroor uitbrei.

Veranderlike & sigbaarheid

Tot dus ver he ons net van plaaslike veranderlike gebruikgemaak, dit wil se veranderlike wat geskep word binnein die selwde metode. In C#, 'n veranderlike wat binnein 'n metode geskep word, is nie sigbaar buite die metode, dis hoekom dit plaaslik genoem word. As jy ondervinding het in 'n ander programerings taal is jy dalk bewis van globale veranderlike, wat van oorals in 'n klas sigbaar is. Maar C# maak nie gebruik van die konsep van 'n globale veranderlike nie. Instede daarvan kan jy 'n veranderlike skep as deel van die klas (nie die metode nie), hierdie veranderlike is dan sigbaar van al die metode in die spesifike klas. Dis makliker om te wys met 'n voorbeeld:

using System;

namespace VariableScope
{
    class Program
    {
    private static string helloClass = "Hello, class!";

    static void Main(string[] args)
    {
        string helloLocal = "Hello, local!";
        Console.WriteLine(helloLocal);
        Console.WriteLine(Program.helloClass);
        DoStuff();
    }

    static void DoStuff()
    {
        Console.WriteLine("A message from DoStuff: " + Program.helloClass);
    }
    }
}

Jy sal agterkom die helloClass lid, geskep is in die klas en nie binne die metode nie - dit laat ons toe om van die Main() methode so wel as ons eie DoStuff() methode. As ons die twee veranderlike vergelyk helloLocal en helloClass kan jy sien die HelloLocal is binne in die Main metode geskep daarom is dit net sigbaar, binne die Main metode terwyl die MainClass veranderlike word geskep as deel is van die klas, en is sigbaar vir beide die Main en DoStuff metode.

Die konsep van waar 'n veranderlike geskep word, word scoping genoem en dit verhoed dat die skepping an gebruik van veranderlike te deurmekaar raak met veranderlike wat oorals sigbaar is en in teveel plekke verander kan word. Nog 'n tegnik is genoem lid sigbaarheid (in die geval gebruik ons die Private sleutelwoord), ons sal later verder hieroor praat as ons by die klas hoofstuk kom.

Opsomming

Veranderlike laat dit toe om data van vreskillend tipe, tydelik te stoor. Daar is plaaslike veranderlike, wat net binne die metode sigbaar is waar dit geskep word. en daar is daar klas veranderlike wat sigbaar is van all metode in die klas, en selfs buite die klas afhangede van die sigbaarheit (visibility ) wat gestel word.