A C#-ban, mint minden magas szintű nyelvben létezik a string típus. Az OOP nyelvekben a string-ekre osztályként tekinthetünk, mivel vannak metódusaik, tulajdonságaik, és minden olyan paraméterük, mely a többi osztálynak, de dolgozni úgy tudunk velük, mint az összes többi programozási nyelv string típusával. Hasonlóan a többi változóhoz, a string-eket is deklarálni kell.

string s;

string w;

Adhatunk nekik értéket:

string a = "hello";

string b = "h";

b += "ello";

s="A2347";

s="1234567890";

Kiolvashatjuk, vagy éppen a képernyőre írhatjuk a bennük tárolt adatokat:

string w=s;

Console.WriteLine(s);

Figyeljük meg, hogy a fent szereplő értékadásban (s="1234567890") számok sorozatát adtuk értékül az s string típusnak. Az s változóban szereplő értékkel ebben az esetben nem számolhatunk, mert az nem numerikus értékként tárolódik, hanem ún.: karakterlánc- literálként, így nem értelmezhetőek rá a numerikus típusoknál használt operátorok.

Igaz, hogy a + művelet értelmezhető a string-ekre is, de működése eltér a számoknál megszokottól. (A fejezet későbbi témáinál kitérünk a + operátor működésére.)

Fontos megemlíteni, hogy a C alapú nyelvekben a \ (backslash) karakter ún.: escape szekvencia. Az s="C:\hello" karakter sorozat hibás eredményt szolgáltat, ha elérési útként szeretnénk felhasználni, mivel a \h -nak nincs jelentése, viszont a rendszer megpróbálja értelmezni. Ilyen esetekben vagy s="C:\\hello" vagy s=@"C:\hello" formulát használjuk! Az első megoldásban az első \ jel elnyomja a második \ jel hatását. A második megoldásnál a @ jel gondoskodik arról, hogy az utána írt string a "C:\hello" formában megmaradjon az értékadásnál, vagy a kiíró utasításokban.

Ha egy string-nek nem adunk értéket, akkor induláskor ’null’ értéke van.

Az üres string-et vagy s=""; formában, vagy s=String.Empty formában jelezhetjük.

A relációk használata kisebb megkötésekkel a string-eknél is megengedett. Az összehasonlításokat elvégezhetjük logikai kifejezésekben, elágazások és logikai ciklusok feltétel részében. A string-ek egyes elemeit tudjuk <, vagy > relációba hozni egymással s[1]<s[2], a teljes sring-re viszont csak a != és a == relációkat alkalmazhatjuk. Ha mégis szeretnénk összehasonlítani két string-et, a következő megoldást használhatjuk:

Str1.CompareTo(str2)

Ezzel a metódussal össze tudjuk hasonlítani két string értékét. A következő példa ezt be is mutatja:

int cmp;

string str1="abc";

string str2="cde";

cmp="szoveg".CompareTo("szoveg");

if ( cmp == 0) {Console.WriteLine("str1 = str2");}

if ( cmp > 0) {Console.WriteLine("str1 < str2");}

if ( cmp < 0) {Console.WriteLine("str1 > str2");}

A két string egynősége esetén a visszatérési érték 0. Ha a kapott érték kisseb, mint 0, akkor az str1 ABC sorrendben előbb van az str2 -nél, ha nagyobb, mint 0, akkor str2 van előbb. A példában a második if feltétele teljesül, mivel az abc karaktersor előbb szerepel a sorrendben, mint a cde.

A strig-eket is használhatjuk konstansként. Ugyanúgy definiáljuk őket, mint a többi típus állandóit.

const string="string konstans";

Ahogy azt már említettük, C# nyelvben a string-ek is rendelkeznek metódusokkal, mint bármely más osztály. Ez némiképp megkönnyíti a használatukat, mert nem a programozónak kell gondoskodnia pl.: a szóközök eltávolításáról, a kis és nagybetűs átalakításról, a keresés metódusainak definiálásáról, és nem kell külső rutinokhoz folyamodnia, mint a Pascal nyelv pos(), vagy copy() eljárásainál.

Az Objektum Orientált megközelítés előnyei jól nyomon követhetőek a string típus esetében. Az egységbezárás lehetővé teszi, hogy rendelkezzen saját metódusokkal. A következő példaprogram bemutatja a string-ek használatának néhány lehetőségét.

using System;

namespace String_01

{

class Class1

{

[STAThread]

static void Main(string[] args)

{

string s;

s="alma";

Console.WriteLine("{0} - A string elejéről levágtuk az

a karaktereket.",s.TrimStart('a'));

Console.WriteLine("{0} - A string végéről levágtuk az a

karaktereket.",s.TrimEnd('a'));

Console.WriteLine("{0} - Nagybetűssé alakítottuk a

sztringet.",s.ToUpper());

Console.WriteLine("{0} - Kisbetűssé alakítottuk a

sztringet.",s.ToLower());

Console.ReadLine();

}

}

}

A program futása a következő:

Az első WriteLine- ban az s string TrimStart() metódusát használtuk, mely eltávolítja a szöveg elejéről a paraméter listájában megadott karakter összes előfordulását. (Az aaalma string- ből az lma stringet állítja elő.)

A TrimStart(), TrimEnd() és a Trim() metódusuk paraméterek nélkül a string elejéről és végéről levágják a szóközöket.

A következő metódus a TrimEnd(). Ez a string végéről vágja el a megadott karaktereket.

A ToUpper() és a ToLower() metódusokkal a kis- és nagybetűs átalakításról gondoskodhatunk.

Vegyük észre, hogy az s=”alma” utasításnál a string-et macskakörmök (”…”) közé tettük, míg a TrimStart() és TrimEnd() metódusok paramétereit aposztrófok (’…’) zárják közre, mivel az első esetben string-et, a másodikban karaktert definiáltunk. Gyakori hiba, hogy a kettőt felcseréljük. Ilyenkor a fordító hibát jelez, mivel a karakterek nem kezelhetőek stringként és fordítva.

A string-ből kimásolhatunk részeket a Substring() metódussal, melynek paraméter listájában meg kell adni a kezdő indexet, ahonnan kezdjük a másolást, és a másolandó karakterek számát. A következő példa megmutatja a Substring() használatát.

Console.WriteLine("Az eredeti szó= alma, a kiemelt részlet ={0} ",s.Substring(1,2));

Ha a Substring() csak egy paramétert kap és a paraméter értéke belül van a string index tartományán, akkor az adott indextől a string végéig az összes karaktert kimásoljuk. A paraméterezéskor ügyeljünk arra, hogy mindig csak akkora indexet adjunk meg, ahány eleme van a string-nek. Arra is figyelni kell, hogy a string első eleme a 0. indexű elem, az utolsó pedig a karakeszám-1.

A stringek-re a + műveletet is értelmezhető, de ilyenkor öszefűzésről beszélünk. Amennyiben a fenti példában szereplő s stringek közé a + operátort írjuk, akkor:

s=”alma”

s=s+” a fa alatt”;

az s tartalma megváltozik, kiegészül a + jel után írt sring- konstanssal. Az eredmény: ”alma a fa alatt”. Amennyiben a fenti értékadásban szereplő változót és konstanst felcseréljük, s=”a fa alatt”+s, eredményül az ” a fa alattalma” karaktersort kapjuk. Ez azt jelenti, hogy az adott string-hez jobbról és balról is hozzáfűzhetünk más string-eket.

A keresés művelete is szerepel a metódusok között. Az IndexOf() függvény -1 értéket ad vissza, ha a paraméter listájában megadott karakter, vagy karaktersorozat nem szerepel a string- ben, 0, vagypozitív értéket, ha szerepel. Mivel a stringek 0- tól vannak indexelve, találat esetén 0-tól a string hosszáig kaphatunk visszatérési értéket, ami a találat helyét, vagyis a kezdő indexét jelenti a keresett karakternek, vagy karakterláncnak.

A következő példa bemutatja, hogyan használhatjuk az IndexOf() metódust. A program beolvas egy tetszőleges mondatot és az abban keresendő szót. Amennyiben a szó szerepel a mondatban, a képernyőre írja a mondatot, a szót és azt, hogy a szó szerepel-e vagy sem a mondatban. A C# nyelv kis-nagybetű érzékeny (case-sensitive), ezért a vizsgálat előtt a beolvasott adatokat nagybetűssé alakítjuk, hogy a tényleges tartalom alapján döntsünk.

namespace string_02

{

class Class1

{

[STAThread]

static void Main(string[] args)

{

string s;

string w;

Console.WriteLine("Gépeljen be egy tetszőleges mondatot

: ");

s=Console.ReadLine();

Console.WriteLine("Adja meg a keresendő szót : ");

w=Console.ReadLine();

s=s.ToUpper();

w=w.ToUpper();

if (s.IndexOf(w)>-1)

{

Console.WriteLine("A(z) {0} szó szerepel a(z) {1}

mondatban",w,s);

}

else

{

Console.WriteLine("A(z) {0} szó nem a(z) {1}

mondatban");

}

Console.ReadLine();

}

}

}

A program futásának eredménye:

A programunk megfelelően működik, de az Output-ja nem tökéletes, mivel az eredeti mondatot nagybetűsre alakítja, majd ezt a formáját írja vissza a képernyőre, a felhasználó által begépelt kis- nagy betűket vegyesen tartalmazó forma helyett.

A problémára több megoldás is létezik. Az egyik, hogy az eredeti változókat megőrizzük, azok tartalmát segédváltozókban tároljuk, amiket átalakíthatunk nagybetűssé, műveleteket végezhetünk velük, majd a program végén az eredeti változók tartalmát írjuk ki a képernyőre. (Ezen megoldás elkészítése a kedves Olvasó feladata. Nincs más dolga, csak két újabb változót bevezetnie, és ezekben átmásolni az eredeti változók tartalmát…)