Clase și spații de nume

Clasele .NET Framework

Poate cel mai mare beneficiu al scrierii codului gestionat - cel puțin din punctul de vedere al unui dezvoltator - este că puteți folosi Biblioteca clasei de bază .NET .

Clasele de bază .NET oferă o colecție imensă de clase de cod gestionat care vă permit să rezolvați aproape orice problemă care ar putea fi rezolvată anterior folosind API-ul Windows. Toate aceste clase urmează același model de obiect IL cu moștenire unică. Aceasta înseamnă că puteți fie să creați obiecte din oricare dintre clasele de bază .NET, fie să vă moșteniți propriile clase de la acestea.

Ceea ce face diferite clase de bază .NET este faptul că sunt concepute pentru a fi intuitive și ușor de utilizat. De exemplu, pentru a începe un fir trebuie să apelați metoda Start() a clasei Fir. Pentru a face un obiect TextBox indisponibil, setați proprietatea Enabled a obiectului la false. Această abordare, familiară dezvoltatorilor Visual Basic și Java ale căror biblioteci sunt la fel de ușor de utilizat, va fi o ușurare uriașă pentru dezvoltatorii C++ care au petrecut ani de zile luptându-se cu funcții API precum GetDIBits(), RegisterWndClassEx() și IsEqualIID(), precum precum și multe funcții care necesitau trecerea mânerelor de fereastră.

Cu toate acestea, dezvoltatorii C++ au avut întotdeauna acces ușor la setul complet de API-uri Windows, în timp ce dezvoltatorii Visual Basic 6 și Java s-au limitat la funcționalitatea de bază a sistemului de operare pe care o accesează din limbajele lor. Clasele de bază .NET combină ușurința de utilizare a bibliotecilor Visual Basic și Java cu o acoperire relativ completă a setului de caracteristici Windows API. Multe caracteristici Windows nu sunt accesibile prin clasele de bază, iar în aceste cazuri va trebui să recurgeți la funcții API, dar în general acest lucru se aplică doar celor mai exotice funcții. Pentru utilizarea de zi cu zi, un set de clase de bază va fi, în general, suficient. Dar dacă trebuie să apelați o funcție API, atunci .NET oferă așa-numita mecanism de invocare a platformei, care garantează conversia corectă a tipului de date, așa că acum această sarcină nu este mai dificilă decât apelarea acestor funcții direct din codul C++, indiferent de limba în care este scris codul - C#, C++ sau Visual Basic 2010.

Spații de nume

Spații de nume este o modalitate prin care .NET evită conflictele de denumire între clase. Acestea sunt menite să prevină situațiile în care definiți o clasă care reprezintă un client, o numiți Client și apoi altcineva face același lucru (acesta este un scenariu destul de comun).

Un spațiu de nume nu este altceva decât un grup de tipuri de date, dar are ca efect faptul că numele tuturor tipurilor de date din spațiul de nume sunt prefixate automat cu numele spațiului de nume. Spațiile de nume pot fi imbricate unul în celălalt. De exemplu, majoritatea claselor de bază .NET de uz general se găsesc în spațiul de nume Sistem. Clasa de bază Matrice se referă la acest spațiu, deci numele complet este Sistem.Matrice.

Platforma .NET necesită ca toate numele să fie declarate într-un spațiu de nume; de exemplu vă puteți pune clasa Clasa mea la spaţiul de nume Compania mea. Atunci va arăta numele complet al acestei clase MyCompany.MyClass.

Rețineți că, dacă un spațiu de nume nu este specificat în mod explicit, tipul va fi adăugat la spațiul de nume global fără nume.

În majoritatea situațiilor, Microsoft recomandă utilizarea a cel puțin două spații de nume imbricate: primul este numele companiei dvs., iar al doilea este numele tehnologiei sau pachetului software căruia îi aparține clasa, așa că arată cam așa: MyCompany.SomeNamespace .Clasa mea. În cele mai multe cazuri, această abordare va proteja clasele aplicației dvs. de potențiale conflicte cu numele claselor scrise de dezvoltatori din alte companii.

Următorul tabel este o listă scurtă a câtorva (dar cu siguranță nu toate) spațiile de nume oferite în .NET, care au fost împărțite în grupuri în funcție de funcționalitate:

Rolul spațiului rădăcină Microsoft

La examinarea listei din tabel, a fost ușor de observat că spațiul de nume System este rădăcina unui număr decent de spații de nume imbricate (cum ar fi System.IO, System.Data etc.). După cum se dovedește, totuși, pe lângă System, biblioteca clasei de bază oferă și o serie de alte spații de nume rădăcină de nivel superior, dintre care cel mai util este Spațiul de nume Microsoft.

Răspunzând la întrebarea despre ce se utilizează namespace std este, în primul rând, trebuie remarcat că tradus din engleză termenul descris înseamnă un spațiu de nume, care este domeniul de aplicare al declarației, necesar pentru a defini diferite forme de identificare: funcţii şi variabile dependente/independente.

Datorită acesteia, nu există niciun conflict între nume, deoarece există situații în care mai multe variabile iau aceleași valori. De obicei, acest lucru se întâmplă atunci când sunt create biblioteci diferite.

Identificatorii sunt disponibile gratuit unul în raport cu celălalt. Aceștia beneficiază de acces gratuit la membri independenți atunci când folosesc formatul numelui complet.

Pentru aceasta este extrem de important astfel încât obiectul să conțină forma completă a numelui folosind namespace std. Acest lucru este important pentru a înțelege vizual cum arată declarația când este plasată în numele spațiului.

Imaginea prezintă mai multe variante de acces la codificări, situat în interiorul și dincolo de gardurile sale:

1 Așa arată Numele complet:

2 Pentru a completa o reclamă existentă, adauga folosind:

3 Pentru a adăuga toate ID-urile existente, utilizați directiva corespunzătoare:

Utilizarea Directivei

Directiva using permite exploatarea tuturor numelor disponibile care sunt incluse în spațiul de nume.

Nu este nevoie să specificați un calificativ.

Trebuie să utilizați utilizarea într-un fișier în format cpp. Cu toate acestea, o condiție importantă este prezența mai multor identificatori.

În cazul în care există doar câteva nume, crearea unui nume obișnuit va fi relevantă.

Apoi puteți adăuga doar identificatorii necesari și lăsați restul în pace.

Este important de reținut că, dacă numele variabilei locale și cea principală coincid, atunci în acest caz prima va fi în acces ascuns.

Vă rugăm să rețineți că crearea de variabile cu același nume este ilegală.

Sfat! Pentru ușurință în utilizare, directiva using poate fi localizată în partea de sus a fișierului format cpp., sau invers, plasată în biblioteca creată.

Pentru a vă asigura cele mai confortabile condiții de lucru, puteți lucra la plasarea fișierelor necesare.

Dacă nu este absolut necesar, directiva de utilizare nu trebuie plasată în anteturi în fișierul format H.

Acest lucru se datorează faptului că odată cu această acțiune, toți identificatorii vor deveni activi în domeniul vizibilității, crescând probabilitatea de a intra în conflict a unor nume.

Pentru fișiere, cea mai bună soluție este să folosiți numele complet.

În cazul în care se dovedesc a fi prea lungi, puteți folosi abrevieri sub formă de alias.

Declarații de spațiu de nume

Este obișnuit să plasați reclame sub formă de nume de fișiere. În cazul în care execuția funcțiilor specificate se află într-o bibliotecă sau fișier separat, este important să se determine numele complet.

Pentru a înțelege despre ce acțiuni vorbim, merită vezi urmatoarea imagine:

Pentru a implementa funcția contosodata format cpp., este de asemenea important să folosiți numele complet în caz când directiva este la început:

Utilizarea namespace std. poate conține reclame în mai multe secțiuni aflate simultan în același fișier.

Datorită compilatorului, toate elementele sunt combinate în timpul procesării datelor.

Deci, de exemplu, std., de regulă, este declarat în toate anteturile fișierelor accesibile situate în biblioteci accesibile de tip standard.

Membrii desemnați printr-un nume complet calificat pot fi definiți nu numai în spațiul de nume, ci și în afara acestuia, dacă au o calificare explicită.

În ceea ce privește definiția, aceasta trebuie să vină după declarația din spațiul de nume în care este creată.

Ca exemplu vizual, acordați atenție următoarei imagini:

Cel mai adesea, această eroare apare atunci când ordinea definiției este încălcată sau părțile constitutive ale numelui complet sunt incluse imediat în obiectele disponibile.

Când cookie-urile nu sunt declarate într-un anumit spațiu de nume, aparține în mod formal spațiului de tip global.

Sfat! Dacă nu este absolut necesar, se recomandă evitarea includerii membrilor în spațiul de tip global.

O excepție semnificativă de la regulă nu poate fi decât opțiunea principală, implicând includerea obligatorie într-un spațiu vast.

Pentru a crea un identificator de tip global, trebuie să utilizați funcționalitatea de vizibilitate corespunzătoare, sub forma unui nume complet.

Această acțiune va ajuta la crearea unei proprietăți distinctive a unui identificator față de celelalte existente care se află într-un spațiu de nume diferit.

Acest lucru vă va ajuta să înțelegeți codul.

Space std.

Este de remarcat faptul că spațiile pot fi de tip imbricat.

Dacă se înțelege o încorporare obișnuită, atunci are un caracter nelimitat pentru întreg spațiul.

Apropo de membrii părinți, aceștia nu au o astfel de funcție.

Pentru extindere, sunt necesare atașamente încorporate.

Pentru o definire și o înțelegere mai precisă, acordați atenție următoarei imagini:

Încapsulând informații pentru implementare ulterioară, poate face, de asemenea, parte dintr-un spațiu imbricat obișnuit și poate acționa ca o interfață de tip deschis în spațiul părinte.

Comparațiile sunt atașamente obișnuite de tip standard, membri încorporați ai spațiului de nume părinte.

Ca urmare, puteți utiliza căutarea pentru funcții care au un fel de supraîncărcare, unde va exista o dependență a argumentelor.

Pentru a vedea un exemplu despre cum se realizează legarea, Merită să ne referim la următorul exemplu:

Următoarea imagine arată procesul de specializare în șablonul spațiului părinte, care este declarată în spațiul temporar de tip încorporat:

Prin exploatarea spațiilor încorporate, este posibilă gestionarea diferitelor versiuni ale interfeței în biblioteci standard.

Este posibil să creați un singur spațiu parental și să încapsulați fiecare interfață prezentată.

Cu toate acestea, trebuie să fie în formatul unui atașament în spațiul părinte partajat.

Apoi codul de client este atribuit automat noii combinații.

Utilizatorii care sunt obișnuiți să folosească versiunea veche o pot folosi în continuare fără probleme.

Pentru a face acest lucru, trebuie să creați calea completă către atașament.

Pentru a organiza primul anunț, trebuie să utilizați o cheie inline.

Să ne uităm la următorul exemplu de două opțiuni de interfață, în care fiecare are spațiu. Codul client are, de asemenea, capacitatea de a exploata biblioteci noi.

Pentru a vizualiza procesul Să trecem la următoarea imagine:

Toate numele trebuie să fie extrem de unice; prin urmare, lungimea lor crește semnificativ.

Cu toate acestea, nu este posibil să utilizați o directivă de utilizare aici.

Este posibil doar să creați un alias pentru un spațiu de nume.

În acest caz, luați în considerare următorul exemplu:

De asemenea, este posibil să se creeze un spațiu obișnuit, dar nu i se atribuie un alias.

Un astfel de spectru teritorial se numește anonim.

De regulă, este folosit în situațiile în care membrii din declarație trebuie să fie invizibili pentru codificare în alte obiecte.

Întreaga structură, când toți identificatorii pot fi văzuți, totuși, în afara spațiului creat, aceștia vor rămâne invizibili.

Nu valoreaza nimic, că spațiul de nume în sine va fi, de asemenea, invizibil în afara blocului, așa că fiecare utilizator ar trebui să ia notă de acest detaliu în avans.

De obicei, utilizarea cunoștințelor este necesară pentru cei care lucrează în Visual C++.

Folosind exemple de înaltă calitate, va fi mult mai ușor de înțeles acest subiect.

Ce este un spațiu de nume în C++?

Un spațiu de nume este o modalitate de grupare a declarațiilor legate logic împreună sub un nume comun.

Exemplu de spațiu de nume:

// @author Subbotin B.P..h" namespace first ( int a; float b; ) namespace second ( int a; float b; ) int _tmain(int argc, _TCHAR* argv) ( first::a = 1; second:: a = 2; primul::b = 1,23; al doilea::b = 4,56; printf("\nfirst::a = %d\n", first::a); printf("\nsecond::a = %d \n", al doilea::a); printf("\nfirst::b = %.2f\n", primul::b); printf("\nsecond::b = %.2f\n\n", al doilea::b); returnează 0; )

Primim:

În exemplu, sunt create două spații de nume: primul și al doilea. Ambele spații conțin aceleași variabile. Dar tocmai faptul că, de exemplu, variabila a aparține mai întâi spațiului care nu permite să fie confundată cu o variabilă dintr-un alt spațiu de nume. Acest lucru evită conflictele de nume.

înseamnă că este folosită variabila int a declarată în primul spațiu de nume. Acesta este un exemplu de declarație de utilizare. Operatorul :: este numit operator de definire a domeniului.

Spațiile de nume sunt create folosind cuvântul cheie spațiu de nume:

Spațiul de nume mai întâi ( int a; float b; )

Pentru a utiliza toate numele dintr-un spațiu de nume, puteți utiliza directiva using namespace. Exemplu de utilizare a spațiului de nume std:

folosind namespace std; int _tmain(int argc, _TCHAR* argv) ( cout<<"\n using namespace std \n"<

folosind namespace std vă permite să utilizați nume din spațiul de nume std. std este numele bibliotecii standard C++.

Dacă în ultimul exemplu eliminăm șirul de conexiune cu spațiul de nume folosind namespace std, atunci va trebui să specificăm numele spațiului de nume în mod explicit:

// @author Subbotin B.P..h" #include int _tmain(int argc, _TCHAR* argv) ( std::cout<<"\n using namespace std \n"<

Spațiul de nume definește domeniul de aplicare. Exemplele au definit în mod explicit spațiile de nume. Iată și alte exemple de spații de nume. Domeniul de aplicare din cadrul unei funcții este, de asemenea, un spațiu de nume. Domeniul de aplicare al variabilelor globale este, de asemenea, un spațiu de nume. O clasă este, de asemenea, un spațiu de nume.

Este posibil să creați un spațiu de nume fără nume. Exemplu:

// @author Subbotin B.P..h" namespace ( int a; int b; ) int _tmain(int argc, _TCHAR* argv) ( a = 5; b = 8; printf("\n a = %d\n", a ); printf("\n b = %d\n\n", b); return 0; )

Aceasta implică utilizarea directivei using namespace. Astfel de spații de nume sunt necesare pentru a evita posibilele conflicte de nume.

Dacă numele spațiului de nume este prea lung, puteți crea un alias al spațiului de nume. Exemplu:

// @author Subbotin B.P..h" namespace underground ( int a; int b; ) namespace ug = underground; int _tmain(int argc, _TCHAR* argv) ( ug::a = 5; ug::b = 8; printf ("\n ug::a = %d\n", ug::a); printf("\n ug::b = %d\n\n", ug::b); return 0; )

namespace ug = underground;

introduce alias-ul ug pentru spațiul de nume subteran. În continuare lucrăm cu aliasul.

Dacă intenționați să utilizați doar o parte a numelor din spațiul de nume, atunci puteți selecta această parte într-un spațiu de nume nou și o puteți utiliza. Exemplu:

// @author Subbotin B.P..h" namespace underground ( int a; int b; int c; float d; double e; ) namespace ug ( using underground::a; using underground::b; ) int _tmain(int argc, _TCHAR* argv) ( ug::a = 5; ug::b = 8; printf("\n ug::a = %d\n", ug::a); printf("\n ug::b = %d\n\n", ug::b); returnează 0; )

Aici, din cele cinci variabile ale spațiului de nume subteran, presupunem că folosim doar două. Creăm un nou spațiu de nume ug, care conține două declarații de utilizare. În continuare lucrăm cu spațiul de nume ug.

Spațiul de nume poate fi modificat, adică adăugați-i reclame noi. Exemplu:

// @author Subbotin B.P..h" namespace underground ( int a; int b; ) namespace underground ( float c; ) int _tmain(int argc, _TCHAR* argv) ( underground::a = 5; underground::b = 8 ; subteran::c = 1,2; printf("\n subteran::a = %d\n", subteran::a); printf("\n subteran::b = %d\n", subteran::b ); printf("\n subteran::c = %.1f\n\n", subteran::c); return 0; )

Primim:

Spațiile de nume pot fi imbricate Exemplu:

// @author Subbotin B.P..h" namespace upper ( int a; int b; namespace inner ( float c; ) ) int _tmain(int argc, _TCHAR* argv) ( upper::a = 5; upper::b = 8 ; upper::inner::c = 1,2; printf("\n upper::a = %d\n", upper::a); printf("\n upper::b = %d\n", upper ::b); printf("\n upper::inner::c = %.1f\n\n", upper::inner::c); return 0; )

Primim:

În exemplu, spațiul de nume de sus conține spațiu de nume interior. Observați cum este accesat câmpul spațiului de nume intern:

superior::interior::c = 1,2;

Să ne uităm la spațiul de nume global. Aici se folosește operatorul:: fără a specifica numele spațiului. Spațiul de nume global conține declarații globale, inclusiv directivele de utilizare corespunzătoare. Exemplu de spațiu de nume global:

// @author Subbotin B.P..h" #include folosind namespace std; int nVar; int _tmain(int argc, _TCHAR* argv) ( int nAnotherVar = 1; ::nVar = 5; cout<<"\n nAnotherVar = "<

Este important să vedem diferența dintre utilizarea declarațiilor și utilizarea directivelor.
O declarație de utilizare face disponibilă o variabilă în domeniul local, de exemplu. are loc declararea numelui local. Există două moduri de a declara o variabilă locală: normală sau folosind o declarație using.

O directivă de utilizare pune la dispoziție toate numele într-un spațiu de nume dat, dar nu le declară local.

O declarație de utilizare are prioritate față de o directivă de utilizare.

Să ne uităm la un exemplu:

// @author Subbotin B.P..h" namespace sbp ( int a; int b; int c; ) int a; int _tmain(int argc, _TCHAR* argv) ( int a; folosind namespace sbp; a = 1; sbp:: a = 2; ::a = 3; printf("\n a = %d\n", a); printf("\n sbp::a = %d\n", sbp::a); printf(" \n::a = %d\n\n", ::a); returnează 0; )

Primim:

folosind namespace sbp;

Aceasta este o directivă de utilizare care face disponibile toate numele din spațiul de nume sbp.

Aceasta funcționează cu variabila locală a. Pentru a atribui valori variabilei a din spațiul sbp, trebuie să indicați în mod explicit spre sbp:

Același lucru este valabil și pentru variabila globală a.

Variabila locală a închide variabilele globale cu același nume.

Acum un exemplu pentru o declarație de utilizare:

// @author Subbotin B.P..h" namespace sbp ( int a; int b; int c; ) int a; int _tmain(int argc, _TCHAR* argv) ( int a; a = 1; folosind sbp::b; b = 2; ::a = 3; printf("\n a = %d\n", a); printf("\n sbp::b = %d\n", sbp::b); printf("\ n::a = %d\n\n", ::a); returnează 0; )

Primim:

Aceasta este o declarație de utilizare. Aici variabila b este declarată local din spațiul de nume sbp. După acest anunț, puteți lua următoarele acțiuni:

dar declarația de utilizare pentru a

ne-ar conduce la o eroare, deoarece în exemplu variabila locală a este deja definită.

Va ajuta.
Calea către suportul pentru spațiile de nume în PHP a fost una dificilă. Dar, din fericire, a fost adăugat limbajului în PHP 5.3, iar structura codului PHP s-a îmbunătățit semnificativ de atunci. Dar cum anume ar trebui să le folosim?

Ce sunt spațiile de nume?

„Nu uitați bara oblică inversă când stocați numele spațiului de nume ca șir!”

Spații de nume, ajutor! Puteți declara aceeași funcție, clasă, interfață și defini constantă în spații de nume separate fără a primi erori fatale. În esență, spațiile de nume nu sunt altceva decât blocuri de cod etichetate ierarhic care conțin cod PHP obișnuit.

Le folosești!

Spațiul de nume global stochează, de asemenea, toate definițiile interne ale PHP, cum ar fi mysqli_connect() și clasa Exception. Deoarece spațiul de nume global nu are un nume unic de identificare, acesta este cel mai frecvent denumit spațiu de nume global.

Vă rugăm să rețineți că utilizarea unui spațiu de nume este opțională.
Scriptul dumneavoastră PHP va funcționa bine fără ele, iar acest comportament nu se va schimba foarte curând.

Definiția spațiului de nume

Spațiile de nume sunt declarate folosind cuvântul rezervat spațiu de nume. Spațiile de nume urmează aceleași reguli ca și alți identificatori în PHP. Deci spațiul de nume ar trebui începe cu o literă sau liniuță de subliniere urmată de orice număr de litere, cifre sau liniuțe de subliniere.

Dacă doriți să definiți un bloc de cod într-un spațiu global, puteți utiliza cuvântul cheie namespace fără a adăuga un nume.

Puteți utiliza mai multe spații de nume într-un singur fișier.

De asemenea, puteți utiliza același spațiu de nume pentru mai multe fișiere diferite; procesul de conectare la fișiere le va îmbina automat. Este o bună practică de codificare să limitați numărul de definiții de spațiu de nume la un singur fișier, așa cum ați face cu clasele.

Spațiile de nume sunt folosite pentru a evita definițiile inconsistente și pentru a introduce mai multă flexibilitate și organizare în codul programului.

Subnamespaces

Pentru flexibilitate, este înțelept să stocați spații de nume imbricate în subdirectoare. Acest lucru ajută la structurarea proiectului și îl face mult mai ușor de utilizat pentru încărcătoarele automate care urmează standardul PSR-4.

PHP folosește backslash ca separator de spațiu de nume.

Fapt interesant: în RFC, pentru a decide ce separator de spațiu de nume să folosească, s-a luat în considerare opțiunea de a folosi o emoticon.

// myproject/database/connection.phpPuteți utiliza câte spații de nume imbricate doriți.

Definirea unui subnamespace cu blocuri de cod imbricate nu este acceptată. Următorul exemplu va returna o eroare fatală: „Declarațiile de spațiu de nume nu pot fi imbricate”.

Cod de apel dintr-un spațiu de nume

• Nume necalificat
• Nume calificat
• Nume complet calificat

Nume incomplet

Numele complet

Exemplul de mai jos va returna o eroare fatală: „Eroare fatală: Clasa „MyProject\Database\MyProject\FileAccess\Input” nu a fost găsită”, deoarece MyProject\FileAccess\Input nu este relevantă pentru spațiul de nume în care vă aflați.

Nume absolut

Dacă doriți să accesați o funcție, clasă sau constantă care se află la un nivel superior al ierarhiei, atunci trebuie să utilizați numele complet - o cale absolută, nu una relativă. Apelul trebuie să înceapă cu o bară oblică inversă. Acest lucru îi permite PHP să știe că acest apel ar trebui să fie făcut din spațiul global, mai degrabă decât să îl acceseze în raport cu locația dvs. actuală.

Nu trebuie să folosim numele complet pentru funcțiile interne PHP. Numele necalificate pentru funcții și constante vor fi definite în spațiul de nume global dacă nu sunt definite în spațiul de nume curent.

Știind acest lucru, acum putem supraîncărca funcțiile PHP interne, în timp ce putem apela funcția inițială (sau constanta).

"; }

Apeluri dinamice

cuvânt cheie spatiu de nume

__NAMESPACE__ constantă

Această constantă este destul de utilă atunci când începeți să învățați un spațiu de nume; este, de asemenea, foarte util pentru depanare. Deoarece este un șir, acesta poate fi utilizat împreună cu apelurile de cod dinamic discutate mai sus.

Importați sau creați un alias de nume

nu este necesar să fie utilizat în spațiile de nume

Importurile sunt un aspect foarte util și fundamental al spațiilor de nume. Acest lucru vă oferă posibilitatea de a utiliza pachete externe, cum ar fi bibliotecile, fără să vă faceți griji cu privire la conflictele de nume. Importul se face folosind cuvântul cheie use. Dacă doriți, puteți specifica un alias personalizat folosind cuvântul cheie as.

Foloșește ca

Cum să-l folosească

O alternativă este alocarea unui alias cu un alt nume

De asemenea, puteți importa clase globale, cum ar fi Exception. Când importați, nu trebuie să scrieți numele său absolut.

Rețineți că pentru numele dintr-un spațiu de nume nu este necesară o bară oblică inversă și prezența acesteia acolo nu este recomandată, deoarece numele importate trebuie să fie absolute și nu sunt analizate în raport cu spațiul de nume curent.

Deși există suport pentru invocarea dinamică a spațiului de nume, importul dinamic nu este acceptat.

Concluzie

Adnotare: Această secțiune descrie utilizarea și declararea spațiilor de nume. Sunt prezentate principalele caracteristici ale RDF, XML-Data, Document Content Description (DCD), Schema for Object-Oriented XML (SOX), Document Definition Markup Language (DDML, cunoscut anterior ca XSchema).

Am descris anterior câteva dintre dezavantajele definițiilor DTD, acestea fiind legate:

1. sintaxa acestor definiții diferă de sintaxa XML (în special, așa-numitul extins Forma Backus-Naur, Formular Backus Naur extins);
2. aceste definiții nu sunt suficient de expresive;
3. Deoarece fiecare utilizator își poate crea propriile etichete, este foarte probabil ca oamenii să folosească aceleași nume de elemente pentru a se referi la lucruri diferite. Chiar dacă semnificațiile elementelor sunt aceleași, conținutul lor posibil poate varia în funcție de definiție. Deci avem nevoie de o modalitate de a defini utilizări specifice ale unui element, mai ales dacă amestecăm diferite tipuri de vocabulare în același document. Pentru a rezolva problema, W3C a lansat o specificație numită XML Namespaces, care vă permite să definiți contextul unui element dintr-un namespace.
4. Există situații în care este necesară combinarea documentelor XML din surse diferite corespunzătoare diferitelor definiții DTD. De exemplu, această situație apare atunci când descrieți un volum mare de informații, dacă DTD-urile individuale nu sunt suficiente pentru a acoperi întregul volum sau sunt greu de înțeles. De asemenea, apare în sistemele de comerț electronic atunci când încercați să combinați datele partenerului dvs. de afaceri cu ale dvs. De asemenea, poate apărea o situație când trebuie pur și simplu să adăugați setările la un DTD existent pentru a schimba unele informații într-un format standard. Din păcate, recomandarea XML nu oferă o modalitate de a combina mai multe DTD-uri într-un singur document fără a le modifica sau a crea un nou DTD (folosind referințe externe).

Acest capitol acoperă următoarele două concepte - spatiu de numeși scheme XML. Spațiile de nume permit dezvoltatorilor XML să despartă o problemă complexă în bucăți mici și să combine mai multe vocabulare într-un singur document pentru a o descrie complet. Folosind scheme, designerii de dicționar creează definiții mai precise decât era posibil în DTD-uri și fac acest lucru folosind sintaxa XML.

Aceste două instrumente ajută la rezolvarea problemelor complexe care apar la utilizarea XML. Spațiile de nume și schemele permit designerilor și programatorilor XML să:

• Organizați mai bine vocabularele pentru a rezolva probleme complexe;
• A pastra tastare puternică date în timpul transformărilor către și de la XML;
• Descrieți vocabulare mai precis și mai flexibil decât a fost posibil cu DTD;
• Citiți regulile dicționarului în XML, accesând definițiile acestuia fără a complica analizatorul.

Amestecarea dicționarelor

Când proiectați un dicționar, poate avea sens să împărțiți problema globală în mai multe părți componente. Acest lucru necesită modalități de a segmenta o problemă mare în mai multe vocabulare. Cu toate acestea, adevărata problemă care trebuie rezolvată este îmbinarea DTD-urilor separate în corpul unui singur document. Această problemă poate apărea și dacă, de exemplu, lucrați pentru o corporație în care, cel mai probabil, există deja un set de definiții DTD și utilizarea lor poate facilita foarte mult munca, deoarece ei descriu problema așa cum o înțeleg alții. Este adesea utilă și reutilizarea definițiilor DTD, de ex. Folosind constructe comune din definițiile DTD create anterior. Dacă dezvoltați o aplicație care trebuie să comunice cu software-ul unui partener extern, nu aveți de ales decât să reutilizați conceptele existente. Definițiile existente ale DTD constituie un limbaj comun care trebuie vorbit pentru a fi înțeles. Dacă un concept există deja, trebuie să lucrezi pentru a fi înțeles în termenii acelui concept.

Când utilizați definiții care vă sunt utile din DTD-uri ale altor dezvoltatori sau când combinați DTD-uri segmentate pentru a crea un document care descrie o problemă complexă, dacă documentele dvs. folosesc elemente cu aceleași nume, riscați să întâlniți probleme de ambiguitatea și ciocnirile de nume.

Problema este exacerbată și mai mult atunci când se utilizează instanțe de nume din mai multe DTD-uri. În acest caz, nu știm la ce element, la care se referă definiția DTD, această problemă a documentelor bine formate se numește ambiguitate. Mai mult, dacă numele din document cer verificări de valabilitate, putem face aplicația noastră foarte confuză. Această problemă se numește coliziune de nume.

Spații de nume

Spațiile de nume pot ajuta utilizatorul în două moduri foarte importante. Cu ajutorul lor poți:

• combinați documente din două sau mai multe surse fără a pierde încrederea că programul va distinge din ce sursă este luat un element sau atribut;
• Dacă este posibil, permiteți agentului utilizator accesul la materiale suplimentare, cum ar fi definiția tipului de document (DTD) sau altă descriere a elementelor și atributelor.

Un spațiu de nume este o colecție de anumite valori sau caracteristici care pot fi utilizate în documentele XML ca nume de elemente sau atribute. Spațiile de nume în XML sunt definite de un Uniform Resource Identifier (URI) (puteți folosi adresa DTD de pe server ca URI). Acesta permite fiecărui spațiu de nume să fie unic.

Deci, pentru a utiliza în mod eficient spațiile de nume într-un document care combină elemente din diferite surse, trebuie să definim:

• O referință la un URI care descrie utilizarea elementului.
• Un alias care ne permite să înțelegem din ce spațiu de nume provine elementul nostru. Acest alias este sub forma unui prefix de element (de exemplu, dacă aliasul pentru un element obscur Book este catalog , atunci elementul va fi numit ).

Utilizarea și declararea spațiilor de nume

Declarație de spațiu de nume

Deoarece în diferite limbaje de marcare - implementări XML - pot fi găsite aceleași nume de etichete și atributele acestora, având semnificații complet diferite, este necesar să se poată distinge cumva între ele. Pentru a face acest lucru, numele etichetelor și atributelor primesc un prefix scurt, care este separat de nume prin două puncte. Prefixul numelui este asociat cu un identificator care definește spațiul de nume. Toate numele de etichete și atribute ale căror prefixe sunt asociate cu același identificator formează un singur spațiu de nume, în care numele trebuie să fie unice.

Deoarece dorim ca toată lumea să poată recunoaște o declarație de spațiu de nume atunci când o vedem, îi rezervăm un cuvânt special. Conform recomandării spațiilor de nume, cuvântul este xmlns . Valoarea atributului este un URI care specifică spațiul de nume de utilizat. Aceasta este adesea adresa URL a definiției DTD, dar nu trebuie să fie întotdeauna așa. Prefixul și identificatorul spațiului de nume sunt definite de atributul xmlns după cum urmează:

După cum puteți vedea, prefixul ntb tocmai a fost definit, dar poate fi folosit deja în numele ntb: notebook . În viitor, numele etichetelor și atributelor pe care dorim să le atribuim spațiului de nume http://some.firm.com/2003/ntbml sunt prefixate cu ntb, de exemplu:

Gorelovo

În plus, mai multe spații de nume pot apărea într-o singură etichetă. Mai jos este un exemplu de amestecare a mai multor spații de nume:

Elementul carte provine din spațiul de nume de catalog, iar atributul ISBN provine din order .

Numele împreună cu un prefix, de exemplu

numit un nume extins, calificat sau calificat (OName. Nume calificat). Partea numelui scrisă după două puncte se numește partea locală a numelui.

Nomenclatura numelor de resurse Web poate fi confuză. Localizator uniform de resurse ( Localizator uniform de resurse, URL) indică o resursă în ceea ce privește protocolul de acces și locația rețelei. Identificator uniform de resurse ( Identificator uniform de resurse, URI) este un nume unic pentru o resursă. Priviți un URI pur și simplu ca pe un șir unic de caractere care identifică un spațiu de nume.

Conform regulilor SGML și XML, două puncte pot fi folosite în nume ca un caracter obișnuit, deci un nume cu un prefix este doar un truc; orice program care nu „știe” spațiul de nume, analizând documentul, tratează denumirea calificată ca denumire obișnuită. Rezultă, în special, că în declarație tip document Prefixele de nume (Declarație de tip de document) nu pot fi omise.

Atributul xmlns poate apărea pe orice element XML, nu doar pe elementul rădăcină. Prefixul pe care îl definește poate fi folosit în elementul în care este scris atributul xmlns și în toate elementele imbricate în el. Mai mult, mai multe spații de nume pot fi definite într-un singur element.

În elementele imbricate, spațiul de nume poate fi suprascris prin asocierea prefixului cu un alt identificator.

Apariția unui nume de etichetă fără prefix într-un document care utilizează un spațiu de nume înseamnă că numele aparține spațiului de nume implicit.

Un document bine conceput ar trebui să folosească spații de nume pentru toate elementele sale.

În orice caz, prefixele care încep cu caractere xml sunt rezervate limbajului XML însuși. Prefixul xmlns este folosit pentru a asocia un alt prefix definit cu identificatorul său de spațiu de nume. Prefixul xmlns nu trebuie definit, este introdus prin recomandarea „Spații de nume în XML” și este asociat acolo cu identificatorul spațiului de nume http://www.w3.ori/2000 /xmlns/.

Un alt prefix, xml, este asociat în aceeași recomandare cu identificatorul http://www.w3.org/XML/1998/namespace. De asemenea, nu trebuie să fie definit în documentul XML. Niciun alt prefix nu poate fi asociat cu acești identificatori.preserve instrucționează pentru a păstra intacte caracterele cu spații albe. Acest lucru este important pentru unele texte, cum ar fi codurile de program. Valoarea implicită lasă spații albe la latitudinea handlerului.

Domeniul de aplicare

Declarațiile de spații de nume au un domeniu de aplicare, la fel ca declarațiile de variabile în limbajele de programare. Acest lucru este important deoarece spațiile de nume nu sunt întotdeauna declarate la începutul unui document XML; uneori sunt declarate în secțiunile ulterioare. O declarație de spațiu de nume se aplică elementului în care apare, precum și descendenților acelui element, chiar dacă nu este definită în mod explicit acolo. Un nume se poate referi la un spațiu de nume numai dacă este utilizat în domeniul de aplicare al declarației sale.

Cu toate acestea, va trebui, de asemenea, să amestecăm domeniile spațiilor de nume cu elemente care altfel ar moșteni alte spații de nume. În acest sens, sunt definite două moduri de declarare a domeniului de aplicare: implicit și calificat.

Domeniu implicit

După cum v-ați putea aștepta, a trebui să prefixați fiecare nume dintr-un document devine rapid obositor. De fapt, prin introducerea conceptului de domeniul de aplicare al numelui, putem amesteca un număr mare de prefixe în documentul nostru. Dacă definim un spațiu de nume implicit, se presupune că acesta deține toate numele necalificate din domeniul de aplicare al declarației sale. Astfel, spațiul de nume implicit declarat în elementul rădăcină este considerat implicit pentru întregul document și poate fi înlocuit doar de un spațiu de nume mai specific declarat în document.

Pentru a face dintr-un spațiu de nume spațiul de nume implicit pentru un domeniu, pur și simplu omiteți declarația de prefix.

Dacă un prefix este declarat și apoi utilizat împreună cu un nume, se spune că spațiul de nume este stabilit în mod explicit. Pentru a atribui un nume necalificat unui spațiu de nume, trebuie să declarați un spațiu implicit care include numele necalificat (fără prefix).

Domeniu calificat

Metoda de mai sus funcționează bine dacă vă puteți separa clar spațiile de nume. Dar uneori este necesar să includeți într-un document nume individuale din spații de nume externe. În loc să declarați spații de nume pentru un întreg domeniu, puteți utiliza nume calificate. Declarați spațiile de nume de care aveți nevoie la începutul documentului și apoi calificați-le la punctul de utilizare.