Cuprins

1.Introducere …………………………………………2

2.Observații …………………………………………..3

3. Regex.Split……………………………………….…5

4. Clasa Match………………………………………...6

5. Group.Captures……………………………………8

6.Conlcuzie……………………………………………10

7.Bibliografie…………………………………………11

1
 1. Expresiile regulate oferă o modalitate flexibilă, puternică şi eficientă de a
procesa textul. Limbajul expresiilor regulate din C#, proiectat compatibil cu cel din
Perl 5, include caractere literal (normale) şi metacaractere; cele mai utilizate
metacaractere şi semnificaţiile lor sunt prezentate în următorul tabel:

Metacaracter Semnificaţie
. Orice caracter, cu excepţia lui \n.
[listă] Un singur caracter din listă.
[^listă] Un singur caracter, care nu este în listă.
[char1-char2] Un singur caracter, din intervalul specificat.
\w Caracter literă sau cifră: [a-zA-Z0-9]
\W Caracter care nu este literă sau cifră.

\s Caracter spaţiu: [ \n\r\t\f]

\S Caracter care nu este spaţiu.
\d Caracter cifră: [0-9]
\D Caracter care nu este cifră
^ Începutul unei linii de text.
$ Sfârşitul unei linii de text.
\b În limita unui cuvânt.
\B În afara limitei unui cuvânt.
* 0 sau mai multe potriviri.
+ 1 sau mai multe potriviri.
? 0 sau 1 potriviri.
{n} Exact n potriviri.
{n,} Cel puţin n potriviri.
{n,m} Cel puţin n potriviri, dar nu mai mult de m potriviri.
() Capturează subşirul ce se potriveşte, sub forma unui grup.
(?<nume>) Capturează subşirul ce se potriveşte, sub forma unui grup cu nume.
2
| Operaţia SAU logic.

3
2. Observaţii:
• Atunci când un literal şir de caractere conţine metacaractere de forma \c,
deoarece acestea nu sunt secvenţe escape, literalii trebuie prefixaţi cu caracterul
@.
• Pentru a afişa \c se utilizează \\c.

Expresiile regulate sunt implementate în clasa Regex din spaţiul de nume

System.Text.RegularExpression; obiectele Regex sunt şi ele imutabile. Pentru a separa
în cuvinte un şir de caractere, se apelează metoda Regex.Split; de data aceasta, lista
separatorilor se transmite direct constructorului clasei Regex, sub forma unei expresii
regulate:

using System;
using System.Text.RegularExpressions;

namespace pnoro{

class Aplicatie{
public static void Main(){
string s = "Dreambox 500s is running Linux!";
//acceasi problema: despartirea intre 2 spatii
consecutive Regex er1 = new Regex(" ");
foreach (string cuvant in
er1.Split(s))
Console.WriteLine(cuvant);
//utilizam o alta expresie
regulata:
[ ]+ Regex er2 = new Regex("[ ]
+");
foreach (string cuvant in er2.Split(s))
Console.WriteLine(cuvant);//se generalizeaza pentru
orice caracter spatiu: [\s]+ Regex er3 = new
Regex(@"[\s]+");
foreach (string cuvant in
er3.Split(s))
Console.WriteLine(cuvant);
Console.ReadLine();
}
};
}

3. Regex.Split
Se observă că Regex.Split elimină caracterele spaţiu; ce se întâmplă dacă
asupra şirului de caractere trebuie să operăm doar nişte modificări şi trebuie să
păstrăm delimitatorii pentru alte procesări. Se utilizează (), care capturează/păstrează
un subşir sub forma unui grup:
using System;
using System.Text.RegularExpressions;

namespace
pnoro{ class
Aplicatie{
public static void Main(){
//un singur spatiu intre 500s si is
string s = "Dreambox 500s is running
Linux!"; //pastreaza spatiul
Regex er1 = new Regex("( )");
foreach(string cuvant in
er1.Split(s))
Console.WriteLine(cuvant);
//pasteaza orice caracter
spatiu Regex er2 = new
Regex(@"(\s)"); foreach(string
cuvant in er2.Split(s))
Console.WriteLine(cuvant);
Console.ReadLine();
}
};
}

Un obiect Match reprezintă rezultatul unei operaţii de căutare/potrivire a unui

şablon descris de o expresie regulată. Un obiect Match este imutabil, iar clasa Match
nu posedă nici un constructor public; din acest motiv, un obiect Match se poate obţine
doar apelând metoda Regex.Match.
 4. Clasa Match
Clasa Match păstrează şi oferă acces la subşirurile extrase în procesul de
căutare, la şirul în care se caută şi la expresia regulată în uz, făcând astfel posibilă
reînceperea căutării din punctul în care căutarea anterioară s-a oprit (în cazul în care
şablonul este prezent de mai multe ori în şirul în care se caută) prin intermediul
metodei Match.NextMatch. Acest proces poate fi descris mai simplu utilizând clasa
MatchCollection, ale cărei instanţe sunt returnate de Regex.Matches:

using System;
using

System.Text.RegularExpressions

; namespace pnoro{

class Aplicatie{
public static void Main(){
//un singur spatiu intre 500s si is
string s = "Dreambox 500s is running
Linux!"; //cauta prima aparitie a lui
'in'
Regex er = new
Regex("in"); Match m1
= er.Match(s);
if (m1.Success)
Console.WriteLine("Am gasit \'{0}\' la pozitia
{1}.",m1.Value, m1.Index); //cauta toate apairiile lui 'in'
Match m2;
for(m2=er.Match(s);m2.Success;m2=m2.Next
Match())
Console.WriteLine("Am gasit \'{0}\' la pozitia {1}.",
m2.Value, m2.Index); //cauta toate aparitiile lui 'in'
utilizand MatchCollection MatchCollection mc = er.Matches(s);
foreach (Match m in mc)
Console.WriteLine("Am gasit \'{0}\' la pozitia {1}",
m.Value, m.Index); Console.ReadLine();
}
};
}
 O expresie regulată poate fi descompusă în mai multe grupuri; de exemplu,
şablonul “(i(n))g” conţine grupurile ‘n’, ‘in’ şi ‘ing’. Un astfel de grup este descris de
către clasa Group. Clasa Match pune la dispoziţie proprietatea Groups, care
returnează un obiect GroupCollection, prin intermediul căruia pot fi accesate
grupurile individuale:
using System;
using
System.Text.RegularExpressions
; namespace pnoro{
class Aplicatie{
public static void Main(){
string s1 = "Dreambox 500s is running
Linux!"; //cauta prima aparitie a lui
'ing' //grupurile ‘n’ ‘in’ si ’ing’
Regex er1 = new
Regex("(i(n))g"); Match m1
= er1.Match(s1);
GroupCollection gc =
m1.Groups; foreach(Group g
in gc)
Console.WriteLine("Am gasit \'{0}\' la pozitia {1}",
g.Value, g.Index); string s2 = "Dreambox:Linux";
//grupuri cu nume
//primul grup se numeste 'NUME', al doilea grup se
numeste 'SO' Regex er2 = new Regex("(?<NUME>\\w+):(?
<SO>\\w+)");
Match m2 = er2.Match(s2);
//colectia de grupuri este
indexata //index sir de
caractere
Console.WriteLine("{0} <-> {1}",
m2.Groups["NUME"].Va
lue,
m2.Groups["SO"].Valu
e);
Console.ReadLine();
}
};
}
 5. Group.Captures
Proprietatea Group.Captures returnează un obiect CaptureCollection; explicit,
se poate scrie astfel:
using System;
using
System.Text.RegularExpressions
; namespace pnoro{
class Aplicatie{
public static void Main(){
string s = "Dreambox 500s is running
Linux ing!"; //cauta prima aparitie a
lui 'ing'
Regex er = new
Regex("(i(n))g"); Match m
= er.Match(s);
GroupCollection gc =
m.Groups; //parcurge
colectia de grupuri
foreach(Group g in gc)
Console.WriteLine("Am gasit \'{0}\' la pozitia {1}",
g.Value, g.Index); //alternativ
//parcurge colectia de
grupuri foreach (Group g
in gc){
//parcurge colecţia de
capturi CaptureCollection cc
= g.Captures; foreach
(Capture c in cc)
Console.WriteLine("Am gasit \'{0}\' la pozitia
{1}", c.Value,
c.Index);
}
Console.ReadLine();
}
};
}
Regex.Replace este o metodă ce poate fi utilizată pentru ştergerea spaţiilor,
despărţirea în cuvinte, ştergerea sau înlocuirea unor subşiruri; de exemplu:
using System;
using
System.Text.RegularExpressions
; namespace pnoro{
class Aplicatie{
public static void Main(){
string s = " spatii
sterse"; Regex er1 = new
Regex(@"^\s*");
Console.WriteLine(er1.Replace(s
 , "")); Console.ReadLine();
}
}
}

• Clase Regex pune la dispoziţie şi variantele statice ale metodelor Split,

Replace şi Match - acestea pot fi folosite fără a iniţializa obiecte Regex.

Există şi o versiune supraîncarcată a constructorului clasei Regex care acceptă

un al doilea argument, de tipul RegexOptions; printre valorile acestui tip enumerare se
regăsesc IgnoreCase şi RightToLeft.

Concluzie:
În cazul în care funcțiile din clasa String nu sunt suficient de
puternice,namespace–ul System.Text.RegularExpresions pune la dispoziție o clasă de
lucru cu expresii regulate numită Regex.

Bilbiografie:
1) https://ro.wikipedia.org/wiki/Expresie_regulat%C4%83
2)https://www.devexpress.com/Products/NET/Controls/WinForms/Spreadsheet
/?
gclid=Cj0KEQiAzO6zBRC25Ju1idGJiZkBEiQAP3Sf6OIHjW7F2yU2wuZWgcUqE
_5r8O25FOSJ6ttWkJiUyxwaAvz38P8HAQ
3) http://www.cs.ubbcluj.ro/~vcioban/Bistrita/Manuale/CursDotNetSassu.pdf