public static RDFGraph WaltDisneyGraphBuild()
{
RDFResource donaldduck = new RDFResource("http://www.waltdisney.com/donald_duck");
RDFPlainLiteral donaldduck_name = new RDFPlainLiteral("Donald Duck");
//create typed literal
// "85"^^xsd:integer
RDFTypedLiteral mickeymouse_age = new RDFTypedLiteral("85", RDFModelEnums.RDFDatatypes.XSD_INTEGER);
RDFTypedLiteral donaldduck_age = new RDFTypedLiteral("85", RDFModelEnums.RDFDatatypes.XSD_INTEGER);
//create triples
// "Mickey Mouse is 85 years old"
RDFTriple mickeymouse_is85yr = new RDFTriple(new RDFResource("http://www.waltdisney.com/mickey_mouse"),
RDFVocabulary.FOAF.AGE,
mickeymouse_age);
// "Donald Duck has English-US name "Donald Duck""
RDFTriple donaldduck_name_enus_triple = new RDFTriple(donaldduck,
RDFVocabulary.FOAF.NAME,
donaldduck_name);
// "Donald Duck is 85 years old"
RDFTriple donaldduck_is85yr = new RDFTriple(donaldduck,
RDFVocabulary.FOAF.AGE,
donaldduck_age);
List <RDFTriple> triples = new List <RDFTriple> {
mickeymouse_is85yr, donaldduck_name_enus_triple, donaldduck_is85yr
};
RDFGraph waltdisney = new RDFGraph(triples);
waltdisney.SetContext(new Uri("http://waltdisney.com/"));
return(waltdisney);
}
private void WorkingWithRdfModels()
{
// CREATE RESOURCE
var donaldduck = new RDFResource("http://www.waltdisney.com/donald_duck");
// CREATE BLANK RESOURCE
var disney_group = new RDFResource();
// CREATE PLAIN LITERAL
// "Donald Duck"
var donaldduck_name = new RDFPlainLiteral("Donald Duck");
// CREATE PLAIN LITERAL WITH LANGUAGE TAG
// "Donald Duck"@en-US
var donaldduck_name_enusLiteral = new RDFPlainLiteral("Donald Duck", "en-US");
// CREATE TYPED LITERAL
// "85"^^xsd:integer
var mickeymouse_age = new RDFTypedLiteral("85", RDFModelEnums.RDFDatatypes.XSD_INTEGER);
// CREATE TRIPLES
// "Mickey Mouse is 85 years old"
RDFTriple mickeymouse_is85yr
= new RDFTriple(
new RDFResource("http://www.waltdisney.com/mickey_mouse"),
new RDFResource("http://xmlns.com/foaf/0.1/age"),
new RDFTypedLiteral("85", RDFModelEnums.RDFDatatypes.XSD_INTEGER));
// "Donald Duck has english (US) name "Donald Duck""
RDFTriple donaldduck_name_enus = new RDFTriple(
new RDFResource("http://www.waltdisney.com/donald_duck"),
new RDFResource("http://xmlns.com/foaf/0.1/name"),
new RDFPlainLiteral("Donald Duck", "en-US"));
// CREATE EMPTY GRAPH
var another_graph = new RDFGraph();
var waltdisney_filled = new RDFGraph();
// CREATE GRAPH FROM A LIST OF TRIPLES
var triples = new List <RDFTriple> {
mickeymouse_is85yr, donaldduck_name_enus
};
var waltdisney = new RDFGraph(triples);
// SET CONTEXT OF A GRAPH
waltdisney.SetContext(new Uri("http://waltdisney.com/"));
// GET A DATATABLE FROM A GRAPH
var waltdisney_table = waltdisney.ToDataTable();
// GET A GRAPH FROM A DATATABLE
var waltdisney_newgraph = RDFGraph.FromDataTable(waltdisney_table);
// ITERATE TRIPLES OF A GRAPH WITH FOREACH
foreach (var t in waltdisney)
{
Console.WriteLine("Triple: " + t);
Console.WriteLine(" Subject: " + t.Subject);
Console.WriteLine(" Predicate: " + t.Predicate);
Console.WriteLine(" Object: " + t.Object);
}
// ITERATE TRIPLES OF A GRAPH WITH ENUMERATOR
var triplesEnum = waltdisney.TriplesEnumerator;
while (triplesEnum.MoveNext())
{
Console.WriteLine("Triple: " + triplesEnum.Current);
Console.WriteLine(" Subject: " + triplesEnum.Current.Subject);
Console.WriteLine(" Predicate: " + triplesEnum.Current.Predicate);
Console.WriteLine(" Object: " + triplesEnum.Current.Object);
}
// GET COUNT OF TRIPLES CONTAINED IN A GRAPH
var triplesCount = waltdisney.TriplesCount;
// MULTIPLE SELECTIONS
var multiple_selections_graph =
waltdisney.SelectTriplesBySubject(new RDFResource("http://www.waltdisney.com/donald_duck"))
.SelectTriplesByPredicate(new RDFResource("http://xmlns.com/foaf/0.1/name"));
// SET OPERATIONS
var set_operations_graph = waltdisney.IntersectWith(waltdisney_filled).UnionWith(another_graph);
/*
* var ntriplesFormat = RDFModelEnums.RDFFormats.NTriples;
* // READ N-TRIPLES FILE
* var graph = RDFGraph.FromFile(ntriplesFormat, "C:\\file.nt");
* // READ N-TRIPLES STREAM
* var graph = RDFGraph.FromStream(ntriplesFormat, inStream);
* // WRITE N-TRIPLES FILE
* graph.ToFile(ntriplesFormat, "C:\\newfile.nt");
* // WRITE N-TRIPLES STREAM
* graph.ToStream(ntriplesFormat, outStream);
*/
/*
* var turtleFormat = RDFModelEnums.RDFFormats.Turtle;
* // READ TURTLE FILE
* var graph = RDFGraph.FromFile(turtleFormat, "C:\\file.ttl");
* // READ TURTLE STREAM
* var graph = RDFGraph.FromStream(turtleFormat, inStream);
* // WRITE TURTLE FILE
* graph.ToFile(turtleFormat, "C:\\newfile.ttl");
* // WRITE TURTLE STREAM
* graph.ToStream(turtleFormat, outStream);
*/
/*
* var xmlFormat = RDFModelEnums.RDFFormats.RdfXml;
* // READ RDF/XML FILE
* var graph = RDFGraph.FromFile(xmlFormat, "C:\\file.rdf");
* // READ RDF/XML STREAM
* var graph = RDFGraph.FromStream(xmlFormat, inStream);
* // WRITE RDF/XML FILE
* graph.ToFile(xmlFormat, "C:\\newfile.rdf");
* // WRITE RDF/XML STREAM
* graph.ToStream(xmlFormat, outStream);
*/
// CREATE NAMESPACE
var waltdisney_ns = new RDFNamespace("wd", "http://www.waltdisney.com/");
// USE NAMESPACE IN RESOURCE CREATION
var duckburg = new RDFResource(waltdisney_ns + "duckburg");
var mouseton = new RDFResource(waltdisney_ns + "mouseton");
RDFNamespaceRegister.AddNamespace(waltdisney_ns);
// Retrieves a namespace by seeking presence of its prefix (null if not found). Supports prefix.cc
var ns1 = RDFNamespaceRegister.GetByPrefix("dbpedia", false); //local search
var ns2 = RDFNamespaceRegister.GetByPrefix("dbpedia", true); //search prefix.cc service if no result
// GET DEFAULT NAMESPACE
var nSpace = RDFNamespaceRegister.DefaultNamespace;
// SET DEFAULT NAMESPACE
RDFNamespaceRegister.SetDefaultNamespace(waltdisney_ns); //new graphs will default to this context
// ITERATE NAMESPACES OF REGISTER WITH FOREACH
foreach (var ns in RDFNamespaceRegister.Instance)
{
Console.WriteLine("Prefix: " + ns.NamespacePrefix);
Console.WriteLine("Namespace: " + ns.NamespaceUri);
}
// ITERATE NAMESPACES OF REGISTER WITH ENUMERATOR
var nspacesEnum = RDFNamespaceRegister.NamespacesEnumerator;
while (nspacesEnum.MoveNext())
{
Console.WriteLine("Prefix: " + nspacesEnum.Current.NamespacePrefix);
Console.WriteLine("Namespace: " + nspacesEnum.Current.NamespaceUri);
}
// CREATE TRIPLES WITH VOCABULARY FACILITIES
// "Goofy Goof is 82 years old"
RDFTriple goofygoof_is82yr = new RDFTriple(
new RDFResource(new Uri("http://www.waltdisney.com/goofy_goof").ToString()),
RDFVocabulary.FOAF.AGE,
new RDFPlainLiteral("82")
);
// "Donald Duck knows Goofy Goof"
RDFTriple donaldduck_knows_goofygoof = new RDFTriple(
new RDFResource(new Uri("http://www.waltdisney.com/donald_duck").ToString()),
RDFVocabulary.FOAF.KNOWS,
new RDFResource(new Uri("http://www.waltdisney.com/goofy_goof").ToString())
);
// CREATE TYPED LITERALS
var myAge = new RDFTypedLiteral("34", RDFModelEnums.RDFDatatypes.XSD_INT);
var myDate = new RDFTypedLiteral("2017-01-07", RDFModelEnums.RDFDatatypes.XSD_DATE);
var myDateTime = new RDFTypedLiteral("2017-01-07T23:11:05", RDFModelEnums.RDFDatatypes.XSD_DATETIME);
var myXml = new RDFTypedLiteral("<book>title</book>", RDFModelEnums.RDFDatatypes.RDF_XMLLITERAL);
var myLiteral = new RDFTypedLiteral("generic literal", RDFModelEnums.RDFDatatypes.RDFS_LITERAL);
/*
* The given list of items may be incomplete.
* A container is semantically opened to the possibility of having further elements
*
* Alt: unordered semantic, duplicates not allowed;
* Bag: unordered semantic, duplicates allowed;
* Seq: ordered semantic, duplicates allowed;
*/
// CREATE CONTAINER AND ADD ITEMS
RDFContainer beatles_cont = new RDFContainer(RDFModelEnums.RDFContainerTypes.Bag, RDFModelEnums.RDFItemTypes.Resource);
beatles_cont.AddItem(new RDFResource("http://beatles.com/ringo_starr"));
beatles_cont.AddItem(new RDFResource("http://beatles.com/john_lennon"));
beatles_cont.AddItem(new RDFResource("http://beatles.com/paul_mc_cartney"));
beatles_cont.AddItem(new RDFResource("http://beatles.com/george_harrison"));
/*
* The given list of items may not be incomplete.
* A collection is semantically closed to the possibility of having further elements
*/
// CREATE COLLECTION AND ADD ITEMS
RDFCollection beatles_coll = new RDFCollection(RDFModelEnums.RDFItemTypes.Resource);
beatles_coll.AddItem(new RDFResource("http://beatles.com/ringo_starr"));
beatles_coll.AddItem(new RDFResource("http://beatles.com/john_lennon"));
beatles_coll.AddItem(new RDFResource("http://beatles.com/paul_mc_cartney"));
beatles_coll.AddItem(new RDFResource("http://beatles.com/george_harrison"));
// ADD CONTAINER/COLLECTION TO GRAPH
waltdisney.AddContainer(beatles_cont);
waltdisney.AddCollection(beatles_coll);
// REIFY TRIPLE AND MERGE IT INTO A GRAPH
RDFGraph reifGraph = goofygoof_is82yr.ReifyTriple();
waltdisney = waltdisney.UnionWith(reifGraph);
// ASSERT SOMETHING ABOUT REIFIED TRIPLE
waltdisney.AddTriple(new RDFTriple(
new RDFResource("http://www.wikipedia.com/"),
new RDFResource("http://example.org/verb_state"),
goofygoof_is82yr.ReificationSubject
));
var existingGraph = new RDFGraph();
// REIFY CONTAINER
existingGraph.AddContainer(beatles_cont);
existingGraph.AddTriple(new RDFTriple(
new RDFResource("http://www.thebeatles.com/"),
RDFVocabulary.FOAF.GROUP,
beatles_cont.ReificationSubject
));
// REIFY COLLECTION
existingGraph.AddCollection(beatles_coll);
existingGraph.AddTriple(new RDFTriple(
new RDFResource("http://www.thebeatles.com/"),
RDFVocabulary.FOAF.GROUP,
beatles_coll.ReificationSubject
));
// WORKING WITH RDF STORES
// CREATE CONTEXT FROM STRING
var wdisney_ctx = new RDFContext("http://www.waltdisney.com/");
// CREATE CONTEXT FROM URI
var wdisney_ctx_uri = new RDFContext(new Uri("http://www.waltdisney.com/"));
// CREATE DEFAULT CONTEXT (DEFAULT NAMESPACE)
var wdisney_ctx_default = new RDFContext();
// CREATE QUADRUPLES
// "From Wikipedia.com: Mickey Mouse is 85 years old"
RDFQuadruple wk_mickeymouse_is85yr = new RDFQuadruple(
new RDFContext("http://www.wikipedia.com/"),
new RDFResource("http://www.waltdisney.com/mickey_mouse"),
RDFVocabulary.FOAF.AGE,
new RDFTypedLiteral("85", RDFModelEnums.RDFDatatypes.XSD_INTEGER)
);
// "From WaltDisney.com: Mickey Mouse is 85 years old"
RDFQuadruple wd_mickeymouse_is85yr = new RDFQuadruple(
new RDFContext("http://www.waltdisney.com/"),
new RDFResource("http://www.waltdisney.com/mickey_mouse"),
RDFVocabulary.FOAF.AGE,
new RDFTypedLiteral("85", RDFModelEnums.RDFDatatypes.XSD_INTEGER)
);
// "From Wikipedia.com: Donald Duck has english name "Donald Duck""
RDFQuadruple wk_donald_duck_name_enus = new RDFQuadruple(
new RDFContext("http://www.wikipedia.com/"),
new RDFResource("http://www.waltdisney.com/donald_duck"),
RDFVocabulary.FOAF.NAME,
new RDFPlainLiteral("Donald Duck", "en")
);
// CREATE EMPTY MEMORY STORE
var wdStore = new RDFMemoryStore();
// CREATE MEMORY STORE FROM A LIST OF QUADRUPLES
var quadruples = new List <RDFQuadruple> {
wk_mickeymouse_is85yr, wk_mickeymouse_is85yr
};
var wdStoreFilled = new RDFMemoryStore();
foreach (var q in quadruples)
{
wdStoreFilled.AddQuadruple(q);
}
// GET A DATATABLE FROM A MEMORY STORE (any kind of store can be exported to datatable)
var wdStore_table = wdStoreFilled.ToDataTable();
// GET A MEMORY STORE FROM A DATATABLE
var wdStore_new = RDFMemoryStore.FromDataTable(wdStore_table);
// ITERATE QUADRUPLES OF A MEMORY STORE WITH FOREACH
foreach (var q in wdStore)
{
Console.WriteLine("Quadruple: " + q);
Console.WriteLine(" Context: " + q.Context);
Console.WriteLine(" Subject: " + q.Subject);
Console.WriteLine(" Predicate: " + q.Predicate);
Console.WriteLine(" Object: " + q.Object);
}
// ITERATE QUADRUPLES OF A MEMORY STORE WITH ENUMERATOR
var quadruplesEnum = wdStore.QuadruplesEnumerator;
while (quadruplesEnum.MoveNext())
{
Console.WriteLine("Quadruple: " + quadruplesEnum.Current);
Console.WriteLine(" Context: " + quadruplesEnum.Current.Context);
Console.WriteLine(" Subject: " + quadruplesEnum.Current.Subject);
Console.WriteLine(" Predicate: " + quadruplesEnum.Current.Predicate);
Console.WriteLine(" Object: " + quadruplesEnum.Current.Object);
}
var nquadsFormat = RDFStoreEnums.RDFFormats.NQuads;
// READ N-QUADS FILE
//var myStore = RDFMemoryStore.FromFile(nquadsFormat, "C:\\file.nq");
// READ N-QUADS STREAM
//var myStore = RDFMemoryStore.FromStream(nquadsFormat, inStream);
// WRITE N-QUADS FILE
wdStoreFilled.ToFile(nquadsFormat, @"C:\TEMP\newfile.nq");
// WRITE N-QUADS STREAM
//myStore.ToStream(nquadsFormat, outStream);
var trixFormat = RDFStoreEnums.RDFFormats.TriX;
// READ TRIX FILE
//var memStore = RDFMemoryStore.FromFile(trixFormat, "C:\\file.trix");
// READ TRIX STREAM
//var memStore = RDFMemoryStore.FromStream(trixFormat, inStream);
// WRITE TRIX FILE
wdStoreFilled.ToFile(trixFormat, @"C:\TEMP\newfile.trix");
// WRITE TRIX STREAM
//myStore.ToStream(trixFormat, outStream);
// CONNECT TO SQLSERVER STORE WITH CONNECTION STRING
//var sqlServer = new RDFSQLServerStore(sqlServerConnectionString);
// CREATE EMPTY FEDERATION
var fed = new RDFFederation();
/*
* // CREATE FEDERATION FROM A LIST OF STORES
* var stores = new List<RDFStore>{ waltDisneyStore, waltDisneyStoreFilled };
* var fedFilled = new RDFFederation();
* foreach(var store in stores)
* {
* fedFilled.AddStore(store);
* }
*/
// ITERATE STORES OF A FEDERATION
foreach (var s in fed)
{
Console.WriteLine("Store: " + s);
Console.WriteLine(" Type: " + s.StoreType);
}
}
public static RDFGraph WaltDisneyGraphBuild()
{
RDFGraph waltdisney = new RDFGraph();
waltdisney.SetContext(new Uri("http://waltdisney.com/"));
// https://en.wikipedia.org/wiki/Mickey_Mouse_universe#Minnie_Mouse_family
// Create triples
// "Mickey Mouse is 85 years old"
RDFTriple mickeyMouse_is85yr = new RDFTriple(mickeyMouse, RDFVocabulary.FOAF.AGE, new RDFTypedLiteral("85", RDFModelEnums.RDFDatatypes.XSD_INTEGER));
RDFTriple mickeyMouse_isMale = new RDFTriple(mickeyMouse, RDFVocabulary.FOAF.GENDER, new RDFPlainLiteral("Male", "en"));
RDFTriple mickeyMouseNameEn = new RDFTriple(mickeyMouse, RDFVocabulary.FOAF.NAME, new RDFPlainLiteral("Mickey Mouse", "en"));
RDFTriple mickeyMouseFamilyNameEn = new RDFTriple(mickeyMouse, RDFVocabulary.FOAF.FAMILY_NAME, new RDFPlainLiteral("Mouse", "en"));
RDFTriple mickeyMouse_boyFriendOf_MinnieMouse = new RDFTriple(mickeyMouse, boyFriendOf, minnieMouse);
List <RDFTriple> mickeyMouseTriples = new List <RDFTriple> {
mickeyMouse_is85yr, mickeyMouse_isMale, mickeyMouseNameEn, mickeyMouseFamilyNameEn, mickeyMouse_boyFriendOf_MinnieMouse
};
RDFGraph mickeyMouseGraph = new RDFGraph(mickeyMouseTriples);
foreach (var triple in mickeyMouseGraph)
{
waltdisney.AddTriple(triple);
}
RDFTriple minnieMouse_is82yr = new RDFTriple(minnieMouse, RDFVocabulary.FOAF.AGE, new RDFTypedLiteral("82", RDFModelEnums.RDFDatatypes.XSD_INTEGER));
RDFTriple minnieMouse_isFemale = new RDFTriple(minnieMouse, RDFVocabulary.FOAF.GENDER, new RDFPlainLiteral("Female", "en"));
RDFTriple minnieMouseNameEn = new RDFTriple(minnieMouse, RDFVocabulary.FOAF.NAME, new RDFPlainLiteral("Minnie Mouse", "en"));
RDFTriple minnieMouseFamilyNameEn = new RDFTriple(minnieMouse, RDFVocabulary.FOAF.FAMILY_NAME, new RDFPlainLiteral("Mouse", "en"));
RDFTriple minnieMouseGirlFriendOfMickeyMouse = new RDFTriple(minnieMouse, girlFriendOf, mickeyMouse);
List <RDFTriple> minnieMouseTriples = new List <RDFTriple> {
minnieMouse_is82yr, minnieMouse_isFemale, minnieMouseNameEn, minnieMouseFamilyNameEn, minnieMouseGirlFriendOfMickeyMouse
};
foreach (var triple in minnieMouseTriples)
{
waltdisney.AddTriple(triple);
}
// Figaro is based on and acts like an immature and spoiled little boy.
RDFTriple figaro_isMale = new RDFTriple(figaro, RDFVocabulary.FOAF.GENDER, new RDFPlainLiteral("Male", "en"));
RDFTriple figaroNameEn = new RDFTriple(figaro, RDFVocabulary.FOAF.NAME, new RDFPlainLiteral("Figaro", "en"));
// Figaro is now Minnie's pet.
RDFTriple figaroCatOfMinnieMouse = new RDFTriple(figaro, catOf, minnieMouse);
RDFTriple figaroIsPetOfMinnieMouse = new RDFTriple(figaro, isPetOf, minnieMouse);
List <RDFTriple> figaroTriples = new List <RDFTriple> {
figaro_isMale, figaroNameEn, figaroCatOfMinnieMouse, figaroIsPetOfMinnieMouse
};
foreach (var triple in figaroTriples)
{
waltdisney.AddTriple(triple);
}
RDFTriple pluto_isMale = new RDFTriple(pluto, RDFVocabulary.FOAF.GENDER, new RDFPlainLiteral("Male", "en"));
RDFTriple plutoNameEn = new RDFTriple(pluto, RDFVocabulary.FOAF.NAME, new RDFPlainLiteral("Pluto", "en"));
// Pluto is Mickey Mouse's pet
RDFTriple plutoDogOfMickeyMouse = new RDFTriple(pluto, dogOf, mickeyMouse);
RDFTriple plutoIsPetOfMickeyMouse = new RDFTriple(pluto, isPetOf, mickeyMouse);
List <RDFTriple> plutoTriples = new List <RDFTriple> {
pluto_isMale, plutoNameEn, plutoDogOfMickeyMouse, plutoIsPetOfMickeyMouse
};
foreach (var triple in plutoTriples)
{
waltdisney.AddTriple(triple);
}
RDFTriple goofy_isMale = new RDFTriple(goofy, RDFVocabulary.FOAF.GENDER, new RDFPlainLiteral("Male", "en"));
RDFTriple goofyNameEn = new RDFTriple(goofy, RDFVocabulary.FOAF.NAME, new RDFPlainLiteral("Goofy Goof", "en"));
RDFTriple goofyFamilyNameEn = new RDFTriple(goofy, RDFVocabulary.FOAF.FAMILY_NAME, new RDFPlainLiteral("Goof", "en"));
// Goofy is a close friend of Mickey Mouse and Donald Duck
RDFTriple goofyFriendOfMickeyMouse = new RDFTriple(goofy, RDFVocabulary.FOAF.KNOWS, mickeyMouse);
RDFTriple goofyFriendOfDonaldDuck = new RDFTriple(goofy, RDFVocabulary.FOAF.KNOWS, donaldDuck);
List <RDFTriple> goofyTriples = new List <RDFTriple> {
goofy_isMale, goofyNameEn, goofyFamilyNameEn, goofyFriendOfMickeyMouse, goofyFriendOfDonaldDuck
};
foreach (var triple in goofyTriples)
{
waltdisney.AddTriple(triple);
}
RDFTriple donaldDuckNameEn = new RDFTriple(donaldDuck, RDFVocabulary.FOAF.NAME, new RDFPlainLiteral("Donald Duck", "en"));
// "Donald Duck is 85 years old"
RDFTriple donaldDuck_is85yr = new RDFTriple(donaldDuck, RDFVocabulary.FOAF.AGE, new RDFTypedLiteral("85", RDFModelEnums.RDFDatatypes.XSD_INTEGER));
RDFTriple donaldDuck_isMale = new RDFTriple(donaldDuck, RDFVocabulary.FOAF.GENDER, new RDFPlainLiteral("Male", "en"));
RDFTriple donaldDuckFamilyNameEn = new RDFTriple(donaldDuck, RDFVocabulary.FOAF.FAMILY_NAME, new RDFPlainLiteral("Duck", "en"));
RDFTriple donaldDuck_boyFriendOf_daisyDuck = new RDFTriple(donaldDuck, boyFriendOf, daisyDuck);
List <RDFTriple> donaldDuckTriples = new List <RDFTriple> {
donaldDuckNameEn, donaldDuck_is85yr, donaldDuck_isMale, donaldDuckFamilyNameEn, donaldDuck_boyFriendOf_daisyDuck
};
foreach (var triple in donaldDuckTriples)
{
waltdisney.AddTriple(triple);
}
RDFTriple daisyDuckNameEn = new RDFTriple(daisyDuck, RDFVocabulary.FOAF.NAME, new RDFPlainLiteral("Daisy Duck", "en"));
RDFTriple daisyDuck_isFemale = new RDFTriple(daisyDuck, RDFVocabulary.FOAF.GENDER, new RDFPlainLiteral("Female", "en"));
RDFTriple daisyDuckFamilyNameEn = new RDFTriple(daisyDuck, RDFVocabulary.FOAF.FAMILY_NAME, new RDFPlainLiteral("Duck", "en"));
RDFTriple daisyDuckGirlFriendOfDonaldDuck = new RDFTriple(daisyDuck, girlFriendOf, donaldDuck);
List <RDFTriple> daisyDuckTriples = new List <RDFTriple> {
daisyDuckNameEn, daisyDuck_isFemale, daisyDuckFamilyNameEn, daisyDuckGirlFriendOfDonaldDuck
};
foreach (var triple in daisyDuckTriples)
{
waltdisney.AddTriple(triple);
}
RDFTriple dellaDuckNameEn = new RDFTriple(dellaDuck, RDFVocabulary.FOAF.NAME, new RDFPlainLiteral("Della Duck", "en"));
RDFTriple dellaDuck_isFemale = new RDFTriple(dellaDuck, RDFVocabulary.FOAF.GENDER, new RDFPlainLiteral("Female", "en"));
RDFTriple dellaDuckFamilyNameEn = new RDFTriple(dellaDuck, RDFVocabulary.FOAF.FAMILY_NAME, new RDFPlainLiteral("Duck", "en"));
RDFTriple dellaDuckSisterOfDonaldDuck = new RDFTriple(dellaDuck, sisterOf, donaldDuck);
List <RDFTriple> dellaDuckTriples = new List <RDFTriple> {
dellaDuckNameEn, dellaDuck_isFemale, dellaDuckFamilyNameEn, dellaDuckSisterOfDonaldDuck
};
foreach (var triple in dellaDuckTriples)
{
waltdisney.AddTriple(triple);
}
return(waltdisney);
}
/// <summary>
/// Deserializes the given Xml filepath to a graph.
/// </summary>
internal static RDFGraph Deserialize(String filepath) {
try {
#region deserialize
XmlReaderSettings xrs = new XmlReaderSettings();
xrs.IgnoreComments = true;
xrs.DtdProcessing = DtdProcessing.Ignore;
RDFGraph result = new RDFGraph();
using(XmlReader xr = XmlReader.Create(new StreamReader(filepath, Encoding.UTF8), xrs)) {
#region load
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(xr);
#endregion
#region root
//Prepare the namespace table for the Xml selections
var nsMgr = new XmlNamespaceManager(new NameTable());
nsMgr.AddNamespace(RDFVocabulary.RDF.PREFIX, RDFVocabulary.RDF.BASE_URI);
//Select "rdf:RDF" root node
XmlNode rdfRDF = RDFModelUtilities.GetRdfRootNode(xmlDoc, nsMgr);
#endregion
#region prefixes
//Select "xmlns" attributes and try to add them to the namespace register
var xmlnsAttrs = RDFModelUtilities.GetXmlnsNamespaces(rdfRDF, nsMgr);
//Try to get the "xml:base" attribute, which is needed to resolve eventual relative #IDs in "rdf:about" nodes
//If it is not found, set it to the graph Uri
Uri xmlBase = null;
if (xmlnsAttrs != null && xmlnsAttrs.Count > 0) {
var xmlBaseAttr = (rdfRDF.Attributes["xml:base"] ?? rdfRDF.Attributes["xmlns"]);
if (xmlBaseAttr != null) {
xmlBase = RDFModelUtilities.GetUriFromString(xmlBaseAttr.Value);
}
}
//Always keep in synch the Context and the xmlBase
if (xmlBase != null) {
result.SetContext(xmlBase);
}
else {
xmlBase = result.Context;
}
#endregion
#region elements
//Parse resource elements, which are the childs of root node and represent the subjects
if (rdfRDF.HasChildNodes) {
var subjNodesEnum = rdfRDF.ChildNodes.GetEnumerator();
while (subjNodesEnum != null && subjNodesEnum.MoveNext()) {
#region subj
//Get the current resource node
XmlNode subjNode = (XmlNode)subjNodesEnum.Current;
RDFResource subj = RDFModelUtilities.GetSubjectNode(subjNode, xmlBase, result);
if (subj == null) {
continue;
}
#endregion
#region predObjList
//Parse pred elements, which are the childs of subj element
if (subjNode.HasChildNodes) {
IEnumerator predNodesEnum = subjNode.ChildNodes.GetEnumerator();
while (predNodesEnum != null && predNodesEnum.MoveNext()) {
//Get the current pred node
RDFResource pred = null;
XmlNode predNode = (XmlNode)predNodesEnum.Current;
if (predNode.NamespaceURI == String.Empty) {
pred = new RDFResource(xmlBase + predNode.LocalName);
}
else {
pred = (predNode.LocalName.StartsWith("autoNS") ?
new RDFResource(predNode.NamespaceURI) :
new RDFResource(predNode.NamespaceURI + predNode.LocalName));
}
#region object
//Check if there is a "rdf:about" or a "rdf:resource" attribute
XmlAttribute rdfObject =
(RDFModelUtilities.GetRdfAboutAttribute(predNode) ??
RDFModelUtilities.GetRdfResourceAttribute(predNode));
if (rdfObject != null) {
//Attribute found, but we must check if it is "rdf:ID", "rdf:nodeID" or a relative Uri
String rdfObjectValue = RDFModelUtilities.ResolveRelativeNode(rdfObject, xmlBase);
RDFResource obj = new RDFResource(rdfObjectValue);
result.AddTriple(new RDFTriple(subj, pred, obj));
continue;
}
#endregion
#region typed literal
//Check if there is a "rdf:datatype" attribute
XmlAttribute rdfDatatype = RDFModelUtilities.GetRdfDatatypeAttribute(predNode);
if (rdfDatatype != null) {
RDFDatatype dt = RDFModelUtilities.GetDatatypeFromString(rdfDatatype.Value);
RDFTypedLiteral tLit = new RDFTypedLiteral(HttpUtility.HtmlDecode(predNode.InnerText), dt);
result.AddTriple(new RDFTriple(subj, pred, tLit));
continue;
}
//Check if there is a "rdf:parseType=Literal" attribute
XmlAttribute parseLiteral = RDFModelUtilities.GetParseTypeLiteralAttribute(predNode);
if (parseLiteral != null) {
RDFTypedLiteral tLit = new RDFTypedLiteral(HttpUtility.HtmlDecode(predNode.InnerXml), RDFDatatypeRegister.GetByPrefixAndDatatype(RDFVocabulary.RDFS.PREFIX, "Literal"));
result.AddTriple(new RDFTriple(subj, pred, tLit));
continue;
}
#endregion
#region plain literal
//Check if there is a "xml:lang" attribute, or if a unique textual child
XmlAttribute xmlLang = RDFModelUtilities.GetXmlLangAttribute(predNode);
if (xmlLang != null || (predNode.HasChildNodes && predNode.ChildNodes.Count == 1 && predNode.ChildNodes[0].NodeType == XmlNodeType.Text)) {
RDFPlainLiteral pLit = new RDFPlainLiteral(HttpUtility.HtmlDecode(predNode.InnerText), (xmlLang != null ? xmlLang.Value : String.Empty));
result.AddTriple(new RDFTriple(subj, pred, pLit));
continue;
}
#endregion
#region collection
//Check if there is a "rdf:parseType=Collection" attribute
XmlAttribute rdfCollect = RDFModelUtilities.GetParseTypeCollectionAttribute(predNode);
if (rdfCollect != null) {
RDFModelUtilities.ParseCollectionElements(xmlBase, predNode, subj, pred, result);
continue;
}
#endregion
#region container
//Check if there is a "rdf:[Bag|Seq|Alt]" child node
XmlNode container = RDFModelUtilities.GetContainerNode(predNode);
if (container != null) {
//Distinguish the right type of RDF container to build
if (container.LocalName.Equals(RDFVocabulary.RDF.PREFIX + ":Bag", StringComparison.Ordinal) || container.LocalName.Equals("Bag", StringComparison.Ordinal)) {
RDFModelUtilities.ParseContainerElements(RDFModelEnums.RDFContainerTypes.Bag, container, subj, pred, result);
}
else if (container.LocalName.Equals(RDFVocabulary.RDF.PREFIX + ":Seq", StringComparison.Ordinal) || container.LocalName.Equals("Seq", StringComparison.Ordinal)) {
RDFModelUtilities.ParseContainerElements(RDFModelEnums.RDFContainerTypes.Seq, container, subj, pred, result);
}
else if (container.LocalName.Equals(RDFVocabulary.RDF.PREFIX + ":Alt", StringComparison.Ordinal) || container.LocalName.Equals("Alt", StringComparison.Ordinal)) {
RDFModelUtilities.ParseContainerElements(RDFModelEnums.RDFContainerTypes.Alt, container, subj, pred, result);
}
}
#endregion
}
}
#endregion
}
}
#endregion
}
return result;
#endregion
}
catch (Exception ex) {
throw new RDFModelException("Cannot deserialize Xml because: " + ex.Message, ex);
}
}
/// <summary>
/// Deserializes the given TriX stream to a graph.
/// </summary>
internal static RDFGraph Deserialize(Stream inputStream)
{
try {
#region deserialize
RDFGraph result = new RDFGraph();
using(StreamReader streamReader = new StreamReader(inputStream, Encoding.UTF8)) {
using(XmlTextReader trixReader = new XmlTextReader(streamReader)) {
trixReader.DtdProcessing = DtdProcessing.Ignore;
trixReader.Normalization = false;
#region document
XmlDocument trixDoc = new XmlDocument();
trixDoc.Load(trixReader);
#endregion
#region graph
if (trixDoc.DocumentElement != null) {
if (trixDoc.DocumentElement.ChildNodes.Count > 1) {
throw new Exception(" given TriX file seems to encode more than one graph.");
}
var graphEnum = trixDoc.DocumentElement.ChildNodes.GetEnumerator();
while(graphEnum != null && graphEnum.MoveNext()) {
XmlNode graph = (XmlNode)graphEnum.Current;
if (!graph.Name.Equals("graph", StringComparison.Ordinal)) {
throw new Exception(" a \"<graph>\" element was expected, instead of unrecognized \"<" + graph.Name + ">\".");
}
#region triple
var encodedUris = 0;
var tripleEnum = graph.ChildNodes.GetEnumerator();
while (tripleEnum != null && tripleEnum.MoveNext()) {
XmlNode triple = (XmlNode)tripleEnum.Current;
#region uri
if (triple.Name.Equals("uri", StringComparison.Ordinal)) {
encodedUris++;
if (encodedUris > 1) {
throw new Exception(" given file encodes a graph with more than one \"<uri>\" element.");
}
result.SetContext(RDFModelUtilities.GetUriFromString(triple.ChildNodes[0].InnerText));
}
#endregion
#region triple
else if(triple.Name.Equals("triple", StringComparison.Ordinal) && triple.ChildNodes.Count == 3) {
#region subj
//Subject is a resource ("<uri>") or a blank node ("<id>")
if (triple.ChildNodes[0].Name.Equals("uri", StringComparison.Ordinal) ||
triple.ChildNodes[0].Name.Equals("id", StringComparison.Ordinal)) {
//Sanitize eventual blank node value
if (triple.ChildNodes[0].Name.Equals("id", StringComparison.Ordinal)) {
if (!triple.ChildNodes[0].InnerText.StartsWith("bnode:")) {
triple.ChildNodes[0].InnerText = "bnode:" + triple.ChildNodes[0].InnerText.Replace("_:", String.Empty);
}
}
}
//Subject is not valid: exception must be raised
else {
throw new RDFModelException("subject (" + triple.ChildNodes[0].Name + ") of \"<triple>\" element is neither \"<uri>\" or \"<id>\".");
}
#endregion
#region pred
//Predicate is not valid: exception must be raised
if (!triple.ChildNodes[1].Name.Equals("uri", StringComparison.Ordinal)) {
throw new RDFModelException("predicate (" + triple.ChildNodes[1].Name + ") of \"<triple>\" element must be \"<uri>\".");
}
#endregion
#region object
//Object is a resource ("<uri>") or a blank node ("<id>")
if (triple.ChildNodes[2].Name.Equals("uri", StringComparison.Ordinal) ||
triple.ChildNodes[2].Name.Equals("id", StringComparison.Ordinal)) {
//Sanitize eventual blank node value
if (triple.ChildNodes[2].Name.Equals("id", StringComparison.Ordinal)) {
if (!triple.ChildNodes[2].InnerText.StartsWith("bnode:")) {
triple.ChildNodes[2].InnerText = "bnode:" + triple.ChildNodes[2].InnerText.Replace("_:", String.Empty);
}
}
result.AddTriple(new RDFTriple(new RDFResource(triple.ChildNodes[0].InnerText),
new RDFResource(triple.ChildNodes[1].InnerText),
new RDFResource(triple.ChildNodes[2].InnerText)));
}
#endregion
#region literal
#region plain literal
else if(triple.ChildNodes[2].Name.Equals("plainLiteral")) {
if (triple.ChildNodes[2].Attributes != null && triple.ChildNodes[2].Attributes.Count > 0) {
XmlAttribute xmlLang = triple.ChildNodes[2].Attributes[RDFVocabulary.XML.PREFIX + ":lang"];
if (xmlLang != null) {
//Plain literal with language
result.AddTriple(new RDFTriple(new RDFResource(triple.ChildNodes[0].InnerText),
new RDFResource(triple.ChildNodes[1].InnerText),
new RDFPlainLiteral(RDFModelUtilities.ASCII_To_Unicode(HttpUtility.HtmlDecode(triple.ChildNodes[2].InnerText)), xmlLang.Value)));
}
else {
//Plain literal without language
result.AddTriple(new RDFTriple(new RDFResource(triple.ChildNodes[0].InnerText),
new RDFResource(triple.ChildNodes[1].InnerText),
new RDFPlainLiteral(RDFModelUtilities.ASCII_To_Unicode(HttpUtility.HtmlDecode(triple.ChildNodes[2].InnerText)))));
}
}
else {
//Plain literal without language
result.AddTriple(new RDFTriple(new RDFResource(triple.ChildNodes[0].InnerText),
new RDFResource(triple.ChildNodes[1].InnerText),
new RDFPlainLiteral(RDFModelUtilities.ASCII_To_Unicode(HttpUtility.HtmlDecode(triple.ChildNodes[2].InnerText)))));
}
}
#endregion
#region typed literal
else if(triple.ChildNodes[2].Name.Equals("typedLiteral", StringComparison.Ordinal)) {
if (triple.ChildNodes[2].Attributes != null && triple.ChildNodes[2].Attributes.Count > 0) {
XmlAttribute rdfDtype = triple.ChildNodes[2].Attributes["datatype"];
if (rdfDtype != null) {
result.AddTriple(new RDFTriple(new RDFResource(triple.ChildNodes[0].InnerText),
new RDFResource(triple.ChildNodes[1].InnerText),
new RDFTypedLiteral(RDFModelUtilities.ASCII_To_Unicode(HttpUtility.HtmlDecode(triple.ChildNodes[2].InnerText)), RDFModelUtilities.GetDatatypeFromString(rdfDtype.Value))));
}
else {
throw new Exception(" found typed literal without required \"datatype\" attribute.");
}
}
else {
throw new Exception(" found typed literal without required \"datatype\" attribute.");
}
}
#endregion
#endregion
#region exception
//Object is not valid: exception must be raised
else {
throw new RDFModelException("object (" + triple.ChildNodes[2].Name + ") of \"<triple>\" element is neither \"<uri>\" or \"<id>\" or \"<plainLiteral>\" or \"<typedLiteral>\".");
}
#endregion
}
#endregion
#region exception
else {
throw new RDFModelException("found a TriX element (" + triple.Name + ") which is neither \"<uri>\" or \"<triple>\", or is a \"<triple>\" without the required 3 childs.");
}
#endregion
}
#endregion
}
}
#endregion
}
}
return result;
#endregion
}
catch(Exception ex) {
throw new RDFModelException("Cannot deserialize TriX because: " + ex.Message, ex);
}
}
//source: http://dadev.cloudapp.net/Datos%20Abiertos/PDF/ReferenceGuide.pdf
static void Main(string[] args)
{
//create resource from string
RDFResource donaldduck = new RDFResource("http://www.waltdisney.com/donald_duck");
//create resource from uri
RDFResource goofygoof = new RDFResource(new Uri("http://www.waltdisney.com/goofy_goof").ToString());
//create plain literal
// "Donald Duck"
RDFPlainLiteral donaldduck_name = new RDFPlainLiteral("Donald Duck");
//create typed literal
// "85"^^xsd:integer
RDFTypedLiteral mickeymouse_age = new RDFTypedLiteral("85", RDFModelEnums.RDFDatatypes.XSD_INTEGER);
//create triples
// "Mickey Mouse is 85 years old"
RDFTriple mickeymouse_is85yr = new RDFTriple(new RDFResource("http://www.waltdisney.com/mickey_mouse"),
new RDFResource("http://xmlns.com/foaf/0.1/age"),
mickeymouse_age);
// "Donald Duck has English-US name "Donald Duck""
RDFTriple donaldduck_name_enus_triple = new RDFTriple(donaldduck,
new RDFResource("http://xmlns.com/foaf/0.1/name"),
donaldduck_name);
// "Goofy Goof is 82 years old"
RDFTriple goofygoof_is82yr = new RDFTriple(goofygoof,
RDFVocabulary.FOAF.AGE,
new RDFPlainLiteral("82"));
// "Donald Duck knows Goofy Goof"
RDFTriple donaldduck_knows_goofygoof = new RDFTriple(donaldduck,
RDFVocabulary.FOAF.KNOWS,
goofygoof);
//create graph from a list of triples
List <RDFTriple> triples = new List <RDFTriple>
{
mickeymouse_is85yr,
donaldduck_name_enus_triple,
goofygoof_is82yr,
donaldduck_knows_goofygoof
};
RDFGraph waltdisney = new RDFGraph(triples);
//set context of a graph
waltdisney.SetContext(new Uri("http://waltdisney.com/"));
//iterate triples of a graph
foreach (RDFTriple t in waltdisney)
{
Console.WriteLine($"Triple: {t}\n");
Console.WriteLine($"Subject: {t.Subject}");
Console.WriteLine($"Predicate: {t.Predicate}");
Console.WriteLine($"Object: {t.Object}");
}
//compose multiple selections
RDFGraph triples_by_subject_and_predicate =
waltdisney.SelectTriplesBySubject(donaldduck)
.SelectTriplesByPredicate(new RDFResource("http://xmlns.com/foaf/0.1/name"));
Console.WriteLine("Number of triples where the subject is Donald Duck and the predicate is foaf:name: " + triples_by_subject_and_predicate.TriplesCount);
Console.WriteLine();
//create namespace
RDFNamespace waltdisney_ns = new RDFNamespace("wd", "http://www.waltdisney.com/");
//set default namespace
RDFNamespaceRegister.SetDefaultNamespace(waltdisney_ns); //new graphs will default to this context
//iterate namespaces
foreach (RDFNamespace ns in RDFNamespaceRegister.Instance)
{
Console.WriteLine($"Prefix: {ns.NamespacePrefix}\n");
Console.WriteLine($"Namespace: {ns.NamespaceUri}\n");
}
Console.ReadKey();
}
/// <summary>
/// Gets a graph representation of the given ontology, eventually including inferences
/// </summary>
internal static RDFGraph ToRDFGraph(RDFOntology ontology, Boolean includeInferences) {
var result = new RDFGraph();
if (ontology != null) {
//Ontology
result.AddTriple(new RDFTriple((RDFResource)ontology.Value, RDFVocabulary.RDF.TYPE, RDFVocabulary.OWL.ONTOLOGY));
result = result.UnionWith(ontology.Annotations.VersionInfo.ToRDFGraph(includeInferences))
.UnionWith(ontology.Annotations.Comment.ToRDFGraph(includeInferences))
.UnionWith(ontology.Annotations.Label.ToRDFGraph(includeInferences))
.UnionWith(ontology.Annotations.SeeAlso.ToRDFGraph(includeInferences))
.UnionWith(ontology.Annotations.IsDefinedBy.ToRDFGraph(includeInferences))
.UnionWith(ontology.Annotations.BackwardCompatibleWith.ToRDFGraph(includeInferences))
.UnionWith(ontology.Annotations.IncompatibleWith.ToRDFGraph(includeInferences))
.UnionWith(ontology.Annotations.PriorVersion.ToRDFGraph(includeInferences))
.UnionWith(ontology.Annotations.Imports.ToRDFGraph(includeInferences))
.UnionWith(ontology.Annotations.CustomAnnotations.ToRDFGraph(includeInferences));
//Model
result = result.UnionWith(ontology.Model.ToRDFGraph(includeInferences));
//Data
result = result.UnionWith(ontology.Data.ToRDFGraph(includeInferences));
//Ontology Name
result.SetContext(((RDFResource)ontology.Value).URI);
}
return result;
}
