Da
bi smo odgovorili na ovo pitanje, napravićemo jednu Console App .Net Core aplikaciju u Visual Studio Code-u instaliranom na Kali Linux distro; koji će
nam predstaviti sve tipove podataka, njihove maksimalne i minimalne vrednosti.
Takođe ćemo programu dodati i jednu konstantu i videćemo rezultate. Zatim ćemo
isti kod proveriti u Visual Studio .Net 2019 Community. Ali krenimo redom.
Programiranje je u suštini veština da Vi svojim kodom koji računar razume saopštite
računaru da se ponaša na određen način. Da bi ste se bavili programiranjem,
neophodno je da imate računar, operativni sistem, Internet konekciju, IDE –
razvojno okruženje i da poznajete određeni programski jezik. U našem slučaju to
je C# programski jezik koji trenutno učimo, Visual Studio Code instaliran na
Linux operativnom sistemu; Kali distro instaliranom na jednom starijem laptop-u.
U vašem slučaju to može biti drugačije, da na primer pravite .Net Core aplikacije
u drugačijem operativnom sistemu. Važno je da shvatite da učenje C# programskog
jezika nije previše tehnički, softverski i finansijski zahtevno. Moj savet Vam
je kad god imate stariji računar ili računar slabije konfiguracije;
instalirajte na njega Linux operativni sistem. I koristite ga za učenje. Da bi
računar razumeo Vaš kod, vi računaru prosleđujete naredbe u vidu jedne linije
koda ili više grupisani redova koda koje zovemo iskazi koje računar razume.
Iskaze grupišete u metode, metode u klase i sve to radite što jednostavnije,
preciznije i bez i jedne greške. Svaki deo koda mora biti bez greške,
optimizovan i testiran. Takođe uvek se trudite da se kod uvek piše samo jednom
dok se isti kod koristi i poziva više puta u projektu. Ali gde se tu uklapaju
tipovi promenjivi, promenjive, njihove vrednosti i konstantne?
Otvorite Visual Studio Code i
napravite novi projekat; nazovite ga variables. Ukoliko ne znate kako da
to uradite, pogledajte prethodni post
ovde. Izbrišite sledeću liniju koda.
using static System.Console;
WriteLine("\t\tDATA TYPES, VARIABLES AND CONSTANTS IN C#\n");
System.Console.WriteLine("…");
Console.WriteLine("…");
WriteLine("…");
Write("…");
System.Console.WriteLine("\t\tDATA TYPES, VARIABLES AND CONSTANTS IN C#" + Environment.NewLine);
WriteLine("bool or System.Boolean ... {0}, {1}", true, false);
WriteLine($"bool or System.Boolean ... {true}, {false}");
WriteLine("byte or System.Byte ... {0}, {1}", 0, 255);
WriteLine("sbyte or System.SByte ... {0}, {1}", -128, 127);
WriteLine("char or System.Char ... {0}, {1}", "A", 9);
WriteLine();
decimal decimalVariable = decimal.MinValue;
WriteLine("decimal or System.Decimal ... {0},\n\t\t\t {1}\n",
decimalVariable, decimalVariable = decimal.MaxValue);
decimal money = 99.99M;
decimal money = 99.99;
U C# programskom jeziku unapred definisani tipovi podataka su strukture i klase i
kao takve imaju mnoge metode. Kada želite da koristite metode koje ima tip
podataka decimal, onda napišete tip podatka, otkucate tačku i koristite neku od
metoda iz IntelliSense-a koje Vam trebaju. U predhodnom kodu mi
koristimo MinValue() metodu tipa podataka decimal da nam kaže koja je najmanja
decimalna vrednost i dodeljujemo tu vrednost promenjivoj decimalVariable koju
ćemo koristiti da nam prikaže minimalnu vrednost u konzoli. Unesite sledeću
liniju koda:
double doubleVariable = double.MinValue;
WriteLine("double or System.Double ... {0}, \n\t\t\t {1}\n",
doubleVariable, doubleVariable = double.MaxValue);
0.2 + 0.1 does Not equal 0.3
float floatVariable = float.MinValue;
WriteLine("float or System.Single ... {0}, \n\t\t\t {1}\n",
floatVariable, floatVariable = float.MaxValue);
int intVariable = int.MinValue;
WriteLine("int or System.Int32 ... {0}, \n\t\t\t {1}\n",
intVariable, intVariable = int.MaxValue);
integer tip podataka je najčešće korišćeni tip podataka za cele brojeve. Ako ste sigurni da ćete u programu vršiti neke proračune u rangu od -2147483648 do 2147483647 onda je integer tip podataka odličan izbor. Unesite sledeće linije koda:
uint uintVariable = uint.MaxValue;
WriteLine("uint or System.UInt32 ... {0}, \n\t\t\t {1}\n",
uintVariable, uintVariable = uint.MaxValue);
long longVariable = long.MinValue;
WriteLine("long or System.Int64 ... {0}, \n\t\t\t {1}\n",
longVariable, longVariable = long.MaxValue);
ulong ulongVariable = ulong.MinValue;
WriteLine("ulong or System.UInt64 ... {0}, \n\t\t\t {1}\n",
ulongVariable, ulongVariable = ulong.MaxValue);
short shortVariable = short.MinValue;
WriteLine("short or System.Int16 ... {0}, \n\t\t\t {1}\n",
shortVariable, shortVariable = short.MaxValue);
ushort ushortVariable = ushort.MinValue;
WriteLine("ushort or System.UInt16 ... {0}, \n\t\t\t {1}\n",
ushortVariable, ushortVariable = ushort.MaxValue);
Svi ovi celebrojni tipovi podataka se razlikuju jedino po rangu koje skladište. Tipovi podataka uint, ushort i ulong su tipovi celobrojni brojeva bez predznaka -. Unesite sledeće linije koda.
string stringVariable = "A string can have 2GB or over 1 billion charaters.";
WriteLine("string or System.String ... {0}\n", stringVariable);
Tip podataka string se takođe najčešće koristi u skoro svim programima. To je referentni tip podataka i može da sadrži preko billion karaktera. Koristi se za bilo kakav tekst dok njegovo zauzeće memorije zavisi od broja karaktera koje koristite u stringu. U C# programskom jeziku, tip podataka string nije samo niz tipa char već ozbiljna klasa koja sadrži mnogo korisnih metoda koje ćete koristiti u radu sa tekstom. Unesite sledeće linije koda.
object objectVariable = "An object can hold any type";
WriteLine("object or System.Object ... {0}\n", objectVariable);
Tip podataka object je specijalni tip koji skladišti bilo koji tip podataka. Međutim, ovaj tip podataka treba da izbegavate kad god je to moguće zbog loših perfomansi. Unesite sledeće linije koda:
const decimal PI = 3.14159265359M;
WriteLine("You cannot change constant value after initalization.\n Constant PI = {0} always.\n", PI);
// ReadLine();
// ReadKey();
I za kraj smo ostavili da vidite kako se deklarišu konstante. Kao što smo već rekli, koristite ključnu reč const, zatim tip promenjive i dodelite joj vrednost. U prehodnom kodu vrednost PI se ne može menjati. Možda se pitate da li u C# programskom jeziku postoji još tipova podataka. Odgovor je da mnogo; poput generičkih tipova i drugi klasa kao što je struktura DateTime zadužena za rad sa datumima i vremenom. U suštini to znači da vi već mnoge stvari koje želite da programirate već imate isprogramirane i možete koristiti u vašim programima ali isto tako možete praviti i vaše vlastite tipove podataka. Obratite pažnju na zadnje komentarisane linije koda. To su metode koje zaustavljaju tok programa i očekuju od korisnika bilo kakav unos podataka. Kada kodirate u Visual Studio .net razvonom okruženju i ne koristite ni jednu od predhodnih komandi, vaš program kad se pokrene će otvoriti konzolu, izvršiti program i zatim zatvoriti konzolu toliko brzo da nećete ništa videti. Ako kodirate u Visual Studio Code-u, panel sa terminalom ili powershell se neće zatvoriti i vi ćete moći videte rezultate vašeg programa. Pogledajte celi kod programa:
using System;
using static System.Console;
namespace variables
{
class Program
{
static void Main(string[] args)
{
System.Console.WriteLine("\t\tDATA TYPES, VARIABLES AND CONSTANTS IN C#\n");
WriteLine($"bool or System.Boolean ... {true}, {false}");
WriteLine("byte or System.Byte ... {0}, {1}", 0, 255);
WriteLine("sbyte or System.SByte ... {0}, {1}", -128, 127);
WriteLine("char or System.Char ... {0}, {1}", "A", 9);
WriteLine();
decimal decimalVariable = decimal.MinValue;
WriteLine("decimal or System.Decimal ... {0},\n\t\t\t {1}\n",
decimalVariable, decimalVariable = decimal.MaxValue);
double doubleVariable = double.MinValue;
WriteLine("double or System.Double ... {0}, \n\t\t\t {1}\n",
doubleVariable, doubleVariable = double.MaxValue);
float floatVariable = float.MinValue;
WriteLine("float or System.Single ... {0}, \n\t\t\t {1}\n",
floatVariable, floatVariable = float.MaxValue);
int intVariable = int.MinValue;
WriteLine("int or System.Int32 ... {0}, \n\t\t\t {1}\n",
intVariable, intVariable = int.MaxValue);
uint uintVariable = uint.MaxValue;
WriteLine("uint or System.UInt32 ... {0}, \n\t\t\t {1}\n",
uintVariable, uintVariable = uint.MaxValue);
long longVariable = long.MinValue;
WriteLine("long or System.Int64 ... {0}, \n\t\t\t {1}\n",
longVariable, longVariable = long.MaxValue);
ulong ulongVariable = ulong.MinValue;
WriteLine("ulong or System.UInt64 ... {0}, \n\t\t\t {1}\n",
ulongVariable, ulongVariable = ulong.MaxValue);
short shortVariable = short.MinValue;
WriteLine("short or System.Int16 ... {0}, \n\t\t\t {1}\n",
shortVariable, shortVariable = short.MaxValue);
ushort ushortVariable = ushort.MinValue;
WriteLine("ushort or System.UInt16 ... {0}, \n\t\t\t {1}\n",
ushortVariable, ushortVariable = ushort.MaxValue);
string stringVariable = "A string can have 2GB or over 1 billion charaters.";
WriteLine("string or System.String ... {0}\n", stringVariable);
object objectVariable = "An object can hold any type";
WriteLine("object or System.Object ... {0}\n", objectVariable);
const decimal PI = 3.14159265359M;
WriteLine("You cannot change constant value after initalization.\n Constant PI = {0} always.\n", PI);
// ReadLine();
}
}
}
Kada pokrenemo naš program sa dotnet run komandom u terminal panelu, dobićete sledeći rezultat:
( Program Variables pokrenut u Visual Studio .Net-u )
( Unapred definisani tipovi podataka u C# programskom jeziku )
Variables
– promenjive su reči koje opisuju mesto u memoriji gde se nalaze vrednosti koje
možete menjati. Da bi ste to razumeli najbolje da promenjivu zamislite kao neku
malu kutiju koja čuva neku određenu vrednost u memoriji. Tako postoje razne
kutije. Na primer postoji kutija integer ili tip podataka integer u koju možete
staviti celi broj. Isto tako postoji kutija decimal ili tip podataka decimal gde možete
staviti decimalni broj. Postoji kutija boolean u koju možete staviti samo true
ili false; da je nešto tačno ili netačno. Ali vi ne možete staviti celobrojni
broj u kutiju boolean. Znači vi stavljate vrednosti u određene kutije za tu
vrednost koje čuvaju vašu vrednost u RAM memoriji računara. Tako program pamti
podatke koje obrađuje. Da bi ste kontrolisali upotrebu memorije i brzinu obrade
podataka treba uvek da razmislite koliko prostora vaša promenjiva će da koristi
i da odaberete za nju adekvatan tip podataka. Šta je onda konstanta? Constant - konstanta
je specijalna kutija ili specijalni tip podataka koji mora da sadrži i tip
podataka. To znači dok kreirate konstantu vi određujete takođe i njen tip
podataka. Promenjive mogu da menjaju
vrednost, ali konstanta ne može. Promenjivoj možete dodati ili oduzeti neki
broj dok je konstanta je uvek ista. Ona se koristi kada imate neku vrednost poput
Pi u matematici. Njena vrednost je 3.14159265359; ali da Vi ne biste
stalno pisali ovakav broj kad god vam treba u programu; jednostavno napravite konstantu
Pi tipa decimal i dodelite joj vrednost 3.14159265359.
Pa kad vam treba ova vrednost, Vi pišete Pi u vašem kodu, dok program zna da je
vrednost Pi isto kao da ste napisali 3.14159265359. Da bi ste videli kako se to
radi, prelazimo na pisanje programa koje sadrži već definisane tipove koji se
koriste u C# programskom jeziku.
Kako se deklarišu i inicijalizuju
promenjive?
Console.WriteLine("Hello World!");
Kod skoro svakog programa, prvo ćemo brisati prethodni kod, zatim
ćete dodati sledeću liniju koda:
Na početku svakog programa
koristimo using iskaze kako bi smo dali instrukcije kompajleru gde da pronađe
klase koje se koriste u programu. Iskazi using se ne izvršavaju; oni nam pomažu
da skratimo kucanje. Međutim, ukoliko želite da koristite using sa statičkim
klasama, onda morate koristiti static direktivu. U našem programu Console je
statička klasa, što takođe znači da su i svi njeni članovi statički. O statičkim klasama, funkcijama
i poljima ćemo učiti kad naučite klase. Do tada treba samo da znate da postoje
statičke klase, funkcije i polja. Takođe, i promenjive se mogu deklarisati kao
statičke kad to ima smisla da se učini. Upišite sledeće liniju koda unutar
funkcije Main() koja će odštampati naslov našeg programa na konzoli:
WriteLine("\t\tDATA TYPES, VARIABLES AND CONSTANTS IN C#\n");
Zato što koristimo using iskaz
sa statičkom klasom Console, mi sad možemo kraće da kucamo umesto:
ili
ili samo:
Takođe ovo važi za sve funkcije
u klasi Console. U prvoj liniji koda u funkciji Main(), kažemo programu da
napravi razmak od dva taba \t\t ili 8 karaktera, ispiše na konzoli naslov
programa i da preskoči jedan red. Ukoliko koristite Windows operativni sistem i
program se izvršava u Powershell-u, onda će jedan tab \t brojati 8 karaktera. Za
ispis teksta na konzoli, vi možete da koristite i funkciju:
Funkcija WriteLine() ispisuje
tekst u jednom redu. Na primer ako dvaput koristite funkciju WriteLine(), ta
funkcija će ispisati dva teksta jedan ispod drugog. Međutim, ako koristite
funkciju Write(), ta funkcija će ispisati obadva teksta u istom redu. Razlika
je samo što funkcija WriteLine() posle vašeg teksta, automatski ubacuje i izlaznu
sekvencu \n iza vašeg teksta prilikom izvršavanja, koji vi naravno ne vidite u
kodu. Izlazna sekvenca \n vam
je isto kao da ste pritisnuli Enter taster na tastaturi. Vi možete u vašem
tekstu koristiti više istih ili različiti izlazni sekvenci. Pogledajte sledeću
tabelu izlaznih sekvenci.
( Tabela izlazni sekvenci u C# programskom jeziku )
Pogledajte sledeću liniju koda:
Umesto
izlazne sekvence \n koristili smo properti NewLine() klase Environment. Ponekad programeri
u kodu koriste ovaj properti umesto izlazne sekvence \n radi bolje čitljivosti koda.
Unapred
definisani tipovi podataka
C# programski jezik ima unapred
definisane tipove podataka koje često koristimo. Oni se nalaze u imenskom
prostoru System. Vi možete napraviti i svoj vlastiti tip podataka i to ćete
često raditi kada budete pravili i koristili klase ili strukture. Unapred
definisani tipovi u C# programskom jeziku su:
·
Vrednosni tipovi
a)
Logički – bool
b)
Numerički
1.
Celobrojni sa predznakom –
sbyte, short, int, long
2.
Celobrojni bez predznaka – byte,
ushort, uint, ulong
3.
Realni brojevi – float, double,
decimal
c)
Znak – char
·
Referentni tipovi
a)
Znakovni - string
b)
Objekat - object
( Unapred definisani tipovi podataka u C# programskom jeziku )
Postoji još jedan tip podataka;
dynamic koji nećete videti u IntelliSense-u dok kucate kod i koji ne
preporučujem da koristite. Suštinska razlika između vrednosni i referentnih
tipova je u načinu kako se oni obrađuju u memoriji. Vrednosni tipovi podataka čuvaju
vrednost u memoriji dok su referentni tipovi podataka složeniji. Oni pored
vrednosti sadrže i referencu na tu vrednost. Referentni tipovi se najčešće
koriste kada radite sa stringovima, klasama, delegatima itd. Pogledajte prvo
logički tip podataka. Napišite sledeću liniju koda u vaš program:
WriteLine("bool or System.Boolean ... {0}, {1}", true, false);
Logički operator može imati
vrednost jedino true ili false. Najčešće se koristi kada hoćete da ispitate neku
vrednost ili iskaz da li je tačna ili pogrešna. Kada hoćete da prikažete neku
vrednost ili vrednost neke promenjive na ekranu, onda to trebate uraditi tako
da stavite vitičaste zagrade {} i njihov indeks bilo gde u tekstu između
navodnika. Vrednosti ili promenjive redate iza teksta u navodnicima. To je
stariji način kako se to radi. Istu liniju koda možete pisati i ovako:
Ukoliko želite da dodelite nekoj
promenjivoj celobrojni broj bez predznaka minus i sigurni ste da taj broj neće
nikad biti veći od 255, tada će te za vašu promenjivu izabrati da bude byte tip
podataka. Unesite sledeću liniju koda:
WriteLine("byte or System.Byte ... {0}, {1}", 0, 255);
byte tip podataka se često
koristi u nizovima koji sadrže sliku. Nizove ćete učiti kasnije. Bitno je da
razumete da byte tip podataka može da bude bilo koji celi broj od 0 do 255.
Svaki drugi broj će izazvati grešku. Unesite sledeću liniju koda:
Za razliku od byte tip
podataka sbyte se koristi za celobrojne brojeve sa predznakom. Međutim njegov
rang je manji i zato prihvata samo celi broj od -128 do 127. Unesite sledeću liniju
koda:
Vrednosni tip podataka, znak je
char predstavlja jedan Uncode znak i zauzima samo 2 bajta. Ovaj tip podataka
može da sadrži samo jedan karakter. To može biti slovo, broj ili bilo koji
karakter u nizu Uncode znakova. Koristi se često u pretragama stringova, može
da sadrži i neku od izlazni sekvenci ili heksadecimalni karakter. Preskočite
jedan red i unesite sledeće linije koda:
decimal decimalVariable = decimal.MinValue;
WriteLine("decimal or System.Decimal ... {0},\n\t\t\t {1}\n",
decimalVariable, decimalVariable = decimal.MaxValue);
Tip podataka sa pokretnim
zarezom decimal se uglavnom koristi za finansijske proračune, gde su potrebna
tačna aritmetika i visoka preciznost pri obradi brojeva sa osnovom 10. U
prethodnom kodu smo prvo deklarisali promenjivu decimal i dodelili joj najmanju
moguću vrednost koju ovaj tip podataka sadrži. Kao što vidite, deklaracija
promenjive se deklariše na sledeći način:
Prvo stavite tip podataka, zatim
sami nazovete promenjivu kako god vi hoćete i onda joj uz pomoć karaktera =
dodelite vrednost bez navodnika kada dodeljujete brojeve. Ako se pitate šta je
M u vrednosti, to vam je numerički sufiks. Neke promenjive imaju svoj sufiks da
bi se mogli razlikovati od drugih tipova podataka. Da ste na primer ovako
deklarisali promenjivu money:
Dobili bi ste grešku. Jer po
defaultu, kompajler bi pomislio da promenjivoj decimal money dodeljujete
vrednost tipa double. Zato morate koristiti numeričke sufikse. Numerički
sufiksi u C# programskom jeziku su:
·
F – float
·
D – double
·
M – decimal
·
L – long
·
U – unsigned
·
UL – unsigned long
Kada
zadajete ime nekoj promenjivoj postoje i ograničenja. Prvo vaša promenjiva ne
sme da sadrži specijalne znakove osim donje crte _ . Zatim naziv vaše
promenjive ne sme da počinje brojem 1money. Vaša promenjiva ne može da sadrži
dve ili više reči odvojeno my money. Ovo bi ste pisali ovako myMoney ili
MyMoney ili my_money itd. Vaša promenjiva ne može da ima isti naziv kao neka od
ključnih reči u C# programskom jeziku. Pogledajte sledeću sliku:
( Ključne reči u C# programskom jeziku )
WriteLine("double or System.Double ... {0}, \n\t\t\t {1}\n",
doubleVariable, doubleVariable = double.MaxValue);
Tip podataka double za razliku od decimal je duplo
veći dok koristi duplo manje prostora u memoriji. Međutim, tip podataka double
nije garantovano tačan. Koristi se kad Vam nije bitna preciznost.
Unesite sledeće linije koda:
WriteLine("float or System.Single ... {0}, \n\t\t\t {1}\n",
floatVariable, floatVariable = float.MaxValue);
Tip podataka float se često koristi kada imate neke
manje brojeve sa pokretnim zarezom. Na primer kada pravite program koji konvertuje
temperature. Kad koristite ovaj tip podataka obavezno koristite i njegov
numerički sufiks F. Unesite sledeće linije koda:
WriteLine("int or System.Int32 ... {0}, \n\t\t\t {1}\n",
intVariable, intVariable = int.MaxValue);
uint uintVariable = uint.MaxValue;
WriteLine("uint or System.UInt32 ... {0}, \n\t\t\t {1}\n",
uintVariable, uintVariable = uint.MaxValue);
long longVariable = long.MinValue;
WriteLine("long or System.Int64 ... {0}, \n\t\t\t {1}\n",
longVariable, longVariable = long.MaxValue);
ulong ulongVariable = ulong.MinValue;
WriteLine("ulong or System.UInt64 ... {0}, \n\t\t\t {1}\n",
ulongVariable, ulongVariable = ulong.MaxValue);
short shortVariable = short.MinValue;
WriteLine("short or System.Int16 ... {0}, \n\t\t\t {1}\n",
shortVariable, shortVariable = short.MaxValue);
ushort ushortVariable = ushort.MinValue;
WriteLine("ushort or System.UInt16 ... {0}, \n\t\t\t {1}\n",
ushortVariable, ushortVariable = ushort.MaxValue);
WriteLine("string or System.String ... {0}\n", stringVariable);
WriteLine("object or System.Object ... {0}\n", objectVariable);
WriteLine("You cannot change constant value after initalization.\n Constant PI = {0} always.\n", PI);
// ReadLine();
// ReadKey();
using static System.Console;
namespace variables
{
class Program
{
static void Main(string[] args)
{
System.Console.WriteLine("\t\tDATA TYPES, VARIABLES AND CONSTANTS IN C#\n");
WriteLine($"bool or System.Boolean ... {true}, {false}");
WriteLine("byte or System.Byte ... {0}, {1}", 0, 255);
WriteLine("sbyte or System.SByte ... {0}, {1}", -128, 127);
WriteLine("char or System.Char ... {0}, {1}", "A", 9);
WriteLine();
decimal decimalVariable = decimal.MinValue;
WriteLine("decimal or System.Decimal ... {0},\n\t\t\t {1}\n",
decimalVariable, decimalVariable = decimal.MaxValue);
double doubleVariable = double.MinValue;
WriteLine("double or System.Double ... {0}, \n\t\t\t {1}\n",
doubleVariable, doubleVariable = double.MaxValue);
float floatVariable = float.MinValue;
WriteLine("float or System.Single ... {0}, \n\t\t\t {1}\n",
floatVariable, floatVariable = float.MaxValue);
int intVariable = int.MinValue;
WriteLine("int or System.Int32 ... {0}, \n\t\t\t {1}\n",
intVariable, intVariable = int.MaxValue);
uint uintVariable = uint.MaxValue;
WriteLine("uint or System.UInt32 ... {0}, \n\t\t\t {1}\n",
uintVariable, uintVariable = uint.MaxValue);
long longVariable = long.MinValue;
WriteLine("long or System.Int64 ... {0}, \n\t\t\t {1}\n",
longVariable, longVariable = long.MaxValue);
ulong ulongVariable = ulong.MinValue;
WriteLine("ulong or System.UInt64 ... {0}, \n\t\t\t {1}\n",
ulongVariable, ulongVariable = ulong.MaxValue);
short shortVariable = short.MinValue;
WriteLine("short or System.Int16 ... {0}, \n\t\t\t {1}\n",
shortVariable, shortVariable = short.MaxValue);
ushort ushortVariable = ushort.MinValue;
WriteLine("ushort or System.UInt16 ... {0}, \n\t\t\t {1}\n",
ushortVariable, ushortVariable = ushort.MaxValue);
string stringVariable = "A string can have 2GB or over 1 billion charaters.";
WriteLine("string or System.String ... {0}\n", stringVariable);
object objectVariable = "An object can hold any type";
WriteLine("object or System.Object ... {0}\n", objectVariable);
const decimal PI = 3.14159265359M;
WriteLine("You cannot change constant value after initalization.\n Constant PI = {0} always.\n", PI);
// ReadLine();
}
}
}
DATA
TYPES, VARIABLES AND CONSTANTS IN C#
bool
or System.Boolean ... True, False
byte
or System.Byte ... 0, 255
sbyte
or System.SByte ... -128, 127
char
or System.Char ... A, 9
decimal
or System.Decimal ... -79228162514264337593543950335,
79228162514264337593543950335
double
or System.Double ... -1.79769313486232E+308,
1.79769313486232E+308
float
or System.Single ... -3.402823E+38,
3.402823E+38
int
or System.Int32 ... -2147483648,
2147483647
uint
or System.UInt32 ... 4294967295,
4294967295
long
or System.Int64 ... -9223372036854775808,
9223372036854775807
ulong
or System.UInt64 ... 0, 18446744073709551615
short
or System.Int16 ... -32768, 32767
ushort
or System.UInt16 ... 0, 65535
string
or System.String ... A string can have 2GB or over 1 billion charaters.
object
or System.Object ... An object can hold any type
You
cannot change constant value after initalization.
Constant
PI = 3.14159265359 always.
U vašim rezultatima možete
da vidite najmanju i najveću vrednost svih unapred definisanih tipova podataka. Kako
ovaj program izgleda možete pogledati i na video:
( C# & .NET Core - 2. Variables, Types and Constants )
Kada pišete iskaz ili
jednu liniju koda, prazan prozor nije toliko bitan jer se iskaz završava tačka
zarezom ; U video-u možete
videti kada prelomite iskaz u drugu liniju koda ponekad može doći do greške.
Zašto? Zato što smo
prelomili iskaz gde je tekst u navodnicima. Morate paziti gde prelamate iskaz.
I za kraj ovog posta želimo da odgovorimo na naše pitanje; Da li unapred
definisani tipovi podataka imaju drugačije vrednosti u .Net Core? Kopiraćemo
ovaj program, prebaciti ga u Visual Studio .net pokrenuti i odgovor možete
videti kada uporedite naše vrednosti sa vrednostima sa slike. One su iste!
Nema komentara:
Objavi komentar