1. Studiu comparativ a librăriilor de procesare a
documentelor RDF
Antochi Anca Mihaela
aantochi@infoiasi.ro
Abstract. Acest document este un studiu comparativ între librăriile SemWeb şi
LinqToRdf de procesare RDF. Sunt comparate metodele de citire şi de scriere a
fişierelor RDF cu ajutorul celor două librării, suportul pentru triple şi
posibilitatea de interogare.
Keywords: RDF, SPARQL, .NET, C#, LINQ
1 Introducere
În încercarea de a găsi librării de procesare RDF pentru framework-ul .Net am
observat că interesul dezvoltatorilor .Net este scăzut, iar librăriile care au fost
dezvoltate nu au mai fost actualizate de un timp îndelungat.
API-ul SemWeb a fost dezvoltat de către Joshua Tauberer şi prima versiune a
apărut în anul 2005. Librăria a fost scrisă în C# pentru versiunile 1.1 şi 2.0 ale
limbajului. Pe data de 19 mai 2009 Joshua Tauberer a anunţat ca renunţă la acest
proiect din cauza interesului scăzut pentru semantică Web a programatorilor .Net1.
Proiectul LinqToRdf este un provider pentru LINQ, ce transformă interogările din
C# în SPARQL şi are ca autor pe Andrew Matthews. În LinqToRdf este folosită
librăria SemWeb dezvoltată de Joshua Tauberer. Se pare că nici LinqToRdf nu a mai
fost actualizat şi ultima versiune a apărut în august 2008.
Codul sursă şi librăriile pentru SemWeb sunt disponibile la
http://razor.occams.info/code/semweb/. La aceeaşi adresă se găsesc documentaţie şi
exemple. Licenţa SemWeb este în termenii GNU GPL şi Creative Commons
Attribution. În proiect sunt folosite şi librării externe: SPARQL engine cu licenţă
GNU LGPL, mecanism de validare Euler sub licenţă W3C Software Licence şi
IKVM care este compatibil GPL.
LinqToRdf poate fi descărcat de la adresa http://code.google.com/p/linqtordf/ sub
forma unui fişier msi ce instalează librăriile necesare şi tot la această adresă se găsesc
documentaţia şi exemplele. Codul sursă se găseşte la http://linqtordf.googlecode.com/
svn/trunk/src/linqtordf. LinqToRdf se află sub licenţă BSD.
1 Anunţul lui Joshua Tauberer găsit la adresa http://razor.occams.info/code/semweb/

2. 2 Suport pentru triple
În proiectul SemWeb triplele din RDF sunt reprezentate de structura Statement.
Spre deosebire de specificaţiile RDF în care triplele sunt construite din subiect,
predicat şi obiect, în Statement există şi un câmp meta. Astfel aş putea spune că
specificaţiile nu au fost întocmai respectate şi a fost ad ăugat meta care este specific
proiectului SemWeb, dar folosirea lui este opţională.
La baza ierarhiei de clase pentru a reprezenta componentele unei triple se află clasa
abstractă Resource. Subiectul poate fi, conform specificaţiilor, referinţă URI sau nod
gol. Acestea sunt reprezentate în SemWeb de clasele Entity şi BNode. Entity este
subclasă directă a clasei Resource, iar BNode moşteneşte Entity. Predicatul poate fi
de tip referinţă URI şi, dupa cum am vazut mai sus, este reprezentat de clasa Entity.
Obiectul, pe lângă referinţă URI şi nod gol, mai poate fi şi literal, care este reprezentat
de clasa Literal, subclasă a clase Resource. Se poate vedea în figura de mai jos
ierarhia acestor clase:

3. După cum putem vedea în diagramă, există o clasă Variable ce poate fi utilizată la
interogări şi reprezintă o variabilă în interogare.
Exemplu de creare a unei triple:
Statement triple = new Statement(
new Entity("http://www.example.org/Maria"),
new Entity("http://www.example.org/hasMother"),
new Literal("Alina") );
Opţional, un literal poate avea tag de limbă sau tipul datei. Tag-ul de limbă şi tipul
se transmit ca parametrii la instanţierea clasei Literal, dar cu restricţia de a fi transmis
doar unul dintre cei doi parametrii:
new Literal("12", null, XSDNS + "#integer");
new Literal("Alina", "ro_RO", null);
LinqToRdf foloşeste librăria SemWeb, la care adăuga suport pentru LINQ. Nu
există în acest proiect clase ce corespund triplelor din RDF şi a componentelor din
triple (subiect, predicat şi obiect). Modul de scriere a interogarilor este foarte
asemănător cu alte tipuri de interogări LINQ (LINQ la SQL sau LINQ la colecţii).
Pentru a crea fişiere RDF şi pentru interograrea acestora este necesar să mapăm
triplele din RDF la clase C# cu ajutorul atributelor OwlResource. Maparea se poate
face manual prin crearea claselor necesare cu attribute sau se pot genera clasele
pornind de la o ontologie cu ajutorul uneltei RdfMetal ce este descărcat împreună cu
LinqToRdf.
Exemplu:
[OwlResource(OntologyName="Genealogy",
RelativeUriReference="Person")]
public class Person : OwlInstanceSupertype
{
[OwlResource(OntologyName = "Genealogy",
RelativeUriReference = "name")]
public string Name { get; set; }
[OwlResource(OntologyName = "Genealogy",
RelativeUriReference="age")]
public string Age { get; set;}
}
3 Citirea fişierelor RDF
Pentru procesarea unui set de triple (obiecte de tip Statement) trebuie să avem o
clasă ce implementează interfaţa StatementSink ce conţine o singură metodă cu
semnătura:
public bool Add(Statement statement);

4. Autorul proiectului nu respectă aici convenţia de nume din C# după care ar fi
trebuit să numească această interfaţă IStatementSink.
De asemenea este necesară o clasă ce implementează interfaţa StatementSource ce
are o singură metodă cu semnătura:
public void Select(StatementSink)
Clasele ce implementează interfaţa StatementSource reprezintă o sursă de obiecte
Statement. Clasa abstractă RdfReader implementează interfaţa StatementSource, iar la
rândul ei este moştenită de clasele RdfXmlReader şi N3Reader.
O clasă ce implementează ambele interfeţe de mai sus este MemoryStore, ce reţine
triplele în memorie.
În exemplul următor se citeşte dintr-un RDF şi triplele se reţin în MemoryStore:
MemoryStore store = new MemoryStore();
using (RdfReader reader = new RdfXmlReader("Test.rdf"))
{
reader.Select(store);
}
În LinqToRdf pentru a citi dintr-un fişier RDF trebuie mai intâi să mapăm datele
din fişier la clase C#. De asemenea este nevoie de o clasă de tip TripleStore pentru a
specifica locaţia triplelor şi tipul de interogare.
Exemplu:
TripleStore store = new
TripleStore(@"http://localhost/genealogy/Family.aspx");
store.QueryType = QueryType.RemoteSparqlStore;
RdfDataContext context = new RdfDataContext(store);
var result = select parent in context.ForType<Parent>()
where parent.Name = “Mary”
select {parent.Name, parent.Age};
Observăm ca in LinqToRdf nu sunt întoarse triple ca urmare a citirii, ci obiecte de
tipul claselor ce au fost mapate la datele din RDF. De asemenea citirea se face ca o
interograe SPARQL, deoarece la execuţie interogarea de mai sus este transformată in
SPARQL. Asemănarea este foarte mare cu o interogare de tip Linq to SQL, doar
maparea datelor fiind diferită.
4 Creare de fişiere RDF
Scriere în fişiere RDF se face în SemWeb cu ajutorul clasei abstracte RdfWriter ce
este extinsă de către clasele XmlTextWriter şi N3Writer. RdfWriter implementează
interfaţa StatementSink. Astfel putem apela metoda Add pentru a adăuga câte o triplă
sau metoda Write ce primeşte ca parametru un obiect de tip StatementSource.
Exemplu:
MemoryStore store = new MemoryStore();
Entity subject = new Entity("http://ex.org/Mary");

5. Entity property = "http://ex.org/hasSon";
Literal obj = new Literal("John", "en_US", null);
store.Add(new Statement(subject, property, obj));
XmlTextWriter xmlWriter = null;
try
{
xmlWriter =
new XmlTextWriter("Test.rdf",Encoding.UTF8);
using (RdfWriter writer = new RdfXmlWriter(xmlWriter))
{
writer.Namespaces.AddNamespace(
"http://ex.org/", "ex");
writer.Write(store);
}
}
catch (Exception ex)
{
Trace.TraceError(ex.Message);
}
finally
{
if (xmlWriter != null)
xmlWriter.Close();
}
Proiectul LinqToRdf conţine şi un designer grafic ce se integrează în Visual Studio
(versiunea 2008 sau următoare). Folosind acest designer este foarte simplu pentru a
crea ontologii şi clasele C# ce sunt mapate la aceste ontologii. LinqToRdfDesigner
crează ontologiile în format N3 şi autorul proiectului precizează în documentaţie că
acest designer este suficient pentru ontologii simple, dar pentru a crea ontologii
complexe sau în alte formate decât N3 am putea considera Protg.
5 Interogări SPARQL
În SemWeb există 3 tipuri de interogări ce pot fi executate: GraphMatch, SPARQL
local şi SPARQL la distanţă. Pentru a executa interogări trebuie să avem un obiect de
tip Query. Clasa Query are metoda Run ce primeşte un parametru de tip
SelectableSource (subclasă a clasei StatementSource) şi un parametru de tip
QueryResultSink. GraphMatch şi SparqlEngine moştenesc clasa Query.
Exemplu:
MemoryStore store = new MemoryStore(new
RdfXmlReader("genealogy.rdf"));
StringBuilder queryBuilder = new StringBuilder();
queryBuilder.AppendLine(@"PREFIX
rdf:<http://www.w3.org/1999/02/22-rdf-syntax-ns#>");
queryBuilder.AppendLine(

6. @"PREFIX g: <http://ex.org/genealogy/>");
queryBuilder.AppendLine(
"SELECT * WHERE { ?women rdf:type g:Woman)");
queryBuilder.AppendLine("?women g:hasSon 'John'}");
SparqlEngine query = new
SparqlEngine(sparqlQuery.toString());
query.Run(store, new SparqlXmlQuerySink(Console.Out));
LinqToRdf transformă toate interogările în SPARQL ce pot fi executate interogări
local sau la distanţă.
6 Documentaţie
Pentru un programator ce a mai utilizat LINQ (la SQL sau la colecţii), LinqToRdf
este mai uşor de utilizat, iar interogările sunt tranformate în SPARQL de către
providerul LinqToRdf fără a fi necesar ca progamatorul să cunoscă SPARQL.
Cu toate acestea, consider că documentaţia proiectul SemWeb este mai bine
structurată şi este împărţită în documentaţie de bază şi documentaţie API. Un minus
care l-am sesizat la documentaţia LinqToRdf este faptul că unele exemple folosesc o
clasă care nu mai există (clasa Rdf), astfel unele exemple sunt incorecte. Această
clasă a apărut în versiuni anterioare ale proiectului, iar apoi a fost înlocuită cu clasa
RdfContext.
7 Referinţe
1. Pagina proiectului SemWeb, http://razor.occams.info/code/semweb/
2. LinqToRdf, http://code.google.com/p/linqtordf/
3. LINQ For Dummies, John Paul Mueller, Wiley Publishing, Inc.