C# SparqlResultsFormat类代码示例

        public string GetString(SparqlResultsFormat format, IRdfWriter graphWriter = null)
        {
            switch (ResultType)
            {
                case BrightstarSparqlResultsType.VariableBindings:
                case BrightstarSparqlResultsType.Boolean:
                    var stringWriter = new System.IO.StringWriter();
                    var sparqlXmlWriter = GetSparqlWriter(format); 
                    sparqlXmlWriter.Save(_resultSet, stringWriter);
                    return stringWriter.GetStringBuilder().ToString();
                case BrightstarSparqlResultsType.Graph:
                    if (graphWriter == null)
                    {
#if WINDOWS_PHONE
                        // Cannot use DTD because the mobile version of XmlWriter doesn't support writing a DOCTYPE.
                        graphWriter = new RdfXmlWriter(WriterCompressionLevel.High, false);
#else
                        graphWriter = new RdfXmlWriter();
#endif
                    }
                    return StringWriter.Write(_graph, graphWriter);
                default:
                    throw new BrightstarInternalException(
                        String.Format("Unrecognized result type when serializing results string: {0}",
                                      ResultType));
            }
        }

 public SparqlResultModel(string storeName, IBrightstarService service, SparqlRequestObject sparqlRequest, SparqlResultsFormat resultsFormat)
 {
     _storeName = storeName;
     _sparqlRequest = sparqlRequest;
     _service = service;
     ResultsFormat = resultsFormat;
 }

 public static string ExecuteSparqlQuery(this IStore store, string sparqlExpression,
                                         SparqlResultsFormat resultsFormat)
 {
     var query = ParseSparql(sparqlExpression);
     var resultsStream = new MemoryStream();
     store.ExecuteSparqlQuery(query, resultsFormat.WithEncoding(new UTF8Encoding(false)), resultsStream);
     var ret = Encoding.UTF8.GetString(resultsStream.ToArray());
     return ret;
 }

 public static string Query(this StoreWorker storeWorker, string sparqlExpression,
                            SparqlResultsFormat resultsFormat, string[] defaultGraphUris)
 {
     var query = ParseSparql(sparqlExpression);
     using (var resultsStream = new MemoryStream())
     {
         storeWorker.Query(query, resultsFormat.WithEncoding(new UTF8Encoding(false)), resultsStream, defaultGraphUris);
         return Encoding.UTF8.GetString(resultsStream.ToArray());
     }
 }

 public SparqlResultModel(string storeName, ulong commitId, IBrightstarService service,
                          SparqlRequestObject sparqlRequest, SparqlResultsFormat resultsFormat, RdfFormat graphFormat)
 {
     _storeName = storeName;
     _commitId = commitId;
     _sparqlRequest = sparqlRequest;
     _service = service;
     ResultsFormat = resultsFormat;
     GraphFormat = graphFormat;
 }

 public Stream GetResultsStream(SparqlResultsFormat format, RdfFormat graphFormat, DateTime? ifNotModifiedSince, out ISerializationFormat streamFormat)
 {
     if (_commitId > 0)
     {
         var commitPointInfo = _service.GetCommitPoint(_storeName, _commitId);
         if (commitPointInfo == null) throw new InvalidCommitPointException();
         return _service.ExecuteQuery(commitPointInfo, _sparqlRequest.Query, _sparqlRequest.DefaultGraphUri, format, graphFormat, out streamFormat);
     }
     return _service.ExecuteQuery(_storeName, _sparqlRequest.Query, _sparqlRequest.DefaultGraphUri, ifNotModifiedSince, format, graphFormat, out streamFormat);
 }

 private ISparqlResultsWriter GetSparqlWriter(SparqlResultsFormat format)
 {
     var ext = format.DefaultExtension;
     if (ext.Equals(SparqlResultsFormat.Xml.DefaultExtension))
             return new SparqlXmlWriter();
     if (ext.Equals(SparqlResultsFormat.Json.DefaultExtension))
             return new SparqlJsonWriter();
     if (ext.Equals(SparqlResultsFormat.Tsv.DefaultExtension))
             return new SparqlTsvWriter();
     if (ext.Equals(SparqlResultsFormat.Csv.DefaultExtension))
         return new SparqlCsvWriter();
     throw new BrightstarInternalException("Unsupported SPARQL results format");
 }

 private static ISparqlResultsWriter GetWriter(SparqlResultsFormat format)
 {
     if (format == SparqlResultsFormat.Csv)
     {
         return new SparqlCsvWriter();
     }
     if (format == SparqlResultsFormat.Tsv)
     {
         return new SparqlTsvWriter();
     }
     if (format == SparqlResultsFormat.Json)
     {
         return new SparqlJsonWriter();
     }
     return new SparqlXmlWriter();
 }

 public SparqlQueryHandler(ISerializationFormat targetFormat,
                           IEnumerable<string> defaultGraphUris)
 {
     if (targetFormat is SparqlResultsFormat)
     {
         _sparqlResultsFormat = targetFormat as SparqlResultsFormat;
     }
     if (targetFormat is RdfFormat)
     {
         _rdfFormat = targetFormat as RdfFormat;
     }
     if (defaultGraphUris != null)
     {
         _defaultGraphUris = defaultGraphUris.Select(g => new Uri(g)).ToList();
     }
 }

 public string AsString(SparqlResultsFormat format)
 {
     var g = new VDS.RDF.Graph();
     var results = new List<SparqlResult>();
     foreach (var graphUri in Graphs)
     {
         var s = new Set();
         s.Add(SparqlResultVariableName, g.CreateUriNode(new Uri(graphUri)));
         results.Add(new SparqlResult(s));
     }
     var rs = new SparqlResultSet(results);
     var writer = GetWriter(format);
     var sw = new StringWriter();
     writer.Save(rs, sw);
     sw.Flush();
     return sw.ToString();
 }

 public SparqlQueryResponse(SparqlQueryProcessingModel model, DateTime? ifNotModifiedSince, SparqlResultsFormat format)
 {
     try
     {
         var resultStream = model.GetResultsStream(format, ifNotModifiedSince);
         Contents = resultStream.CopyTo;
         ContentType = format.MediaTypes[0];
         StatusCode = HttpStatusCode.OK;
     }
     catch (InvalidCommitPointException)
     {
         StatusCode = HttpStatusCode.NotFound;
     }
     catch (BrightstarStoreNotModifiedException)
     {
         StatusCode = HttpStatusCode.NotModified;
     }
 }

 public SparqlQueryResponse(SparqlQueryProcessingModel model, DateTime? ifNotModifiedSince, SparqlResultsFormat format, RdfFormat graphFormat)
 {
     try
     {
         ISerializationFormat streamFormat;
         var resultStream = model.GetResultsStream(format, graphFormat, ifNotModifiedSince, out streamFormat);
         Contents = resultStream.CopyTo;
         ContentType = streamFormat.ToString();
         StatusCode = HttpStatusCode.OK;
     }
     catch (InvalidCommitPointException)
     {
         StatusCode = HttpStatusCode.NotFound;
     }
     catch (BrightstarStoreNotModifiedException)
     {
         StatusCode = HttpStatusCode.NotModified;
     }
 }

 private static string MakeQueryCacheKey(string storeName, long commitTime, string query, IEnumerable<string> defaultGraphUris, SparqlResultsFormat format)
 {
     var graphHashCode = defaultGraphUris == null ? 0 : String.Join(",", defaultGraphUris).GetHashCode();
     return storeName + "_" + commitTime + "_" + query.GetHashCode() + "_" + graphHashCode + "." +
            format.DefaultExtension;
 }

 public string Query(string storeName, string queryExpression, IEnumerable<string> defaultGraphUris, SparqlResultsFormat resultsFormat)
 {
     var g = defaultGraphUris == null ? null : defaultGraphUris.ToArray();
     Logging.LogDebug("Query {0} {1}", storeName, queryExpression);
     var currentCommitPoint = _storeManager.GetMasterFile(Path.Combine(_baseLocation, storeName)).GetLatestCommitPoint();
     var cacheKey = MakeQueryCacheKey(storeName, currentCommitPoint.CommitTime.Ticks,
                                      queryExpression, g, resultsFormat);
     var cachedResult = GetCachedResult(cacheKey);
     if (cachedResult != null)
     {
         Logging.LogDebug("Returning cached result for query Query {0} {1}", storeName, queryExpression);
         return cachedResult;
     }
     var storeWorker = GetStoreWorker(storeName);
     var result =  storeWorker.Query(queryExpression, resultsFormat, g);
     //add to cache
     CacheResult(cacheKey, result);
     return result;
 }

 private static void WriteResults(SparqlResultsFormat resultsFormat, Stream responseStream, string results)
 {
     StreamWriter streamWriter;
     if (resultsFormat.DefaultExtension.Equals(SparqlResultsFormat.Xml.DefaultExtension) &&
         !resultsFormat.Encoding.Equals(Encoding.Unicode))
     {
         // We need to rewrite the XML, otherwise the encoding setting is wrong
         XDocument resultsDoc = XDocument.Parse(results);
         streamWriter = new StreamWriter(responseStream, resultsFormat.Encoding);
         resultsDoc.Save(streamWriter);
         streamWriter.Flush();
     }
     else
     {
         streamWriter = new StreamWriter(responseStream, resultsFormat.Encoding);
         streamWriter.Write(results);
         streamWriter.Flush();
     }
 }