C# 如何比较dotnetrdf中的简单文本和类型化文本？

我正在比较两个图，一个来自具有简单文本对象的Turtle文件，另一个来自具有显式数据类型IRIs的文件。这些图表在其他方面是相等的

图A：

<s> <p> "o"

---

---

dotnetrdf中是否有一种方法可以以与RDF 1.1一致的方式将简单文本与类型化文本进行比较，而无需像上面那样进行重大重写或解决方法？

dotnetrdf既不符合RDF 1.1，也不符合我们的要求。有一个分支被重写为兼容，但它尚未准备好远程生产

---

假设您控制了解析过程，那么您可以使用。然后，您可以根据需要重写

HandleTriple（Triple t）

方法，在隐式

xsd:string

输入到系统中时，将其剥离。

根据RobV的回答，使用Handlers API：

class StripStringHandler : BaseRdfHandler, IWrappingRdfHandler
{
    protected override bool HandleTripleInternal(Triple t)
    {
        if (t.Object is ILiteralNode)
        {
            var literal = t.Object as ILiteralNode;

            if (literal.DataType != null && (literal.DataType.AbsoluteUri == "http://www.w3.org/2001/XMLSchema#string" || literal.DataType.AbsoluteUri == "http://www.w3.org/2001/XMLSchema#langString"))
            {
                var simpleLiteral = this.CreateLiteralNode(literal.Value, literal.Language);

                t = new Triple(t.Subject, t.Predicate, simpleLiteral);
            }
        }

        return this.handler.HandleTriple(t);
    }

    private IRdfHandler handler;

    public StripStringHandler(IRdfHandler handler) : base(handler)
    {
        this.handler = handler;
    }

    public IEnumerable<IRdfHandler> InnerHandlers
    {
        get
        {
            return this.handler.AsEnumerable();
        }
    }

    protected override void StartRdfInternal()
    {
        this.handler.StartRdf();
    }

    protected override void EndRdfInternal(bool ok)
    {
        this.handler.EndRdf(ok);
    }

    protected override bool HandleBaseUriInternal(Uri baseUri)
    {
        return this.handler.HandleBaseUri(baseUri);
    }

    protected override bool HandleNamespaceInternal(string prefix, Uri namespaceUri)
    {
        return this.handler.HandleNamespace(prefix, namespaceUri);
    }

    public override bool AcceptsAll
    {
        get
        {
            return this.handler.AcceptsAll;
        }
    }
}

类StripStringHandler:BaseRdfHandler、IWrappingRdfHandler
{
受保护的超控bool HandleTripleInternal（三重t）
{
if（t.Object为ILiteralNode）
{
var literal=t.对象作为ILiteralNode；
如果（literal.DataType！=null&&（literal.DataType.AbsoluteUri==）http://www.w3.org/2001/XMLSchema#string“|| literal.DataType.AbsoluteUri=”http://www.w3.org/2001/XMLSchema#langString"))
{
var simpleLiteral=this.CreateLiteralNode（literal.Value，literal.Language）；
t=新的三元组（t.主语，t.谓语，单纯形）；
}
}
返回此.handler.HandleTriple（t）；
}
私人IRdfHandler处理程序；
public StripStringHandler（IRdfHandler处理程序）：基本（处理程序）
{
this.handler=handler；
}
公共IEnumerable内部处理器
{
得到
{
返回此.handler.AsEnumerable（）；
}
}
受保护的覆盖无效StartRDInternal（）
{
this.handler.StartRdf（）；
}
受保护的覆盖无效EndrFinternal（布尔正常）
{
this.handler.EndRdf（确定）；
}
受保护的覆盖布尔把手Baseurinal（Uri baseUri）
{
返回这个.handler.HandleBaseUri（baseUri）；
}
受保护的重写bool HandleNamespaceInternal（字符串前缀，Uri namespaceUri）
{
返回this.handler.HandleNamespace（前缀，namespaceUri）；
}
公共覆盖布尔接受
{
得到
{
返回this.handler.AcceptsAll；
}
}
}

用法：

class Program
{
    static void Main()
    {
        var graphA = Load("<http://example.com/subject> <http://example.com/predicate> \"object\".");
        var graphB = Load("<http://example.com/subject> <http://example.com/predicate> \"object\"^^<http://www.w3.org/2001/XMLSchema#string>.");

        var diff = graphA.Difference(graphB);

        Debug.Assert(diff.AreEqual);
    }

    private static IGraph Load(string source)
    {
        var result = new Graph();
        var graphHandler = new GraphHandler(result);
        var strippingHandler = new StripStringHandler(graphHandler);
        var parser = new TurtleParser();

        using (var reader = new StringReader(source))
        {
            parser.Load(strippingHandler, reader);
        }

        return result;
    }
}

类程序
{
静态void Main（）
{
var graphA=加载（“对象”）；
var graphB=Load（“\”对象\“^^”）；
var diff=图形差异（graphB）；
断言（diff.AreEqual）；
}
专用静态IGraph加载（字符串源）
{
var结果=新图形（）；
var graphHandler=新的graphHandler（结果）；
var strippingHandler=新的StripStringHandler（graphHandler）；
var parser=新TurtleParser（）；
使用（变量读取器=新的StringReader（源））
{
Load（strippingHandler、reader）；
}
返回结果；
}
}

我已将此实现贡献给dotNetRDF：

private static void RemoveDefaultDatatype(IGraph g)
{
    var triplesWithDefaultDatatype =
        from triple in g.Triples
        where triple.Object is ILiteralNode
        let literal = triple.Object as ILiteralNode
        where literal.DataType != null
        where literal.DataType.AbsoluteUri == "http://www.w3.org/2001/XMLSchema#string" || literal.DataType.AbsoluteUri == "http://www.w3.org/2001/XMLSchema#langString"
        select triple;

    var triplesWithNoDatatype =
        from triple in triplesWithDefaultDatatype
        let literal = triple.Object as ILiteralNode
        select new Triple(
            triple.Subject,
            triple.Predicate,
            g.CreateLiteralNode(
                literal.Value,
                literal.Language));

    g.Assert(triplesWithNoDatatype.ToArray());
    g.Retract(triplesWithDefaultDatatype);
}

class StripStringHandler : BaseRdfHandler, IWrappingRdfHandler
{
    protected override bool HandleTripleInternal(Triple t)
    {
        if (t.Object is ILiteralNode)
        {
            var literal = t.Object as ILiteralNode;

            if (literal.DataType != null && (literal.DataType.AbsoluteUri == "http://www.w3.org/2001/XMLSchema#string" || literal.DataType.AbsoluteUri == "http://www.w3.org/2001/XMLSchema#langString"))
            {
                var simpleLiteral = this.CreateLiteralNode(literal.Value, literal.Language);

                t = new Triple(t.Subject, t.Predicate, simpleLiteral);
            }
        }

        return this.handler.HandleTriple(t);
    }

    private IRdfHandler handler;

    public StripStringHandler(IRdfHandler handler) : base(handler)
    {
        this.handler = handler;
    }

    public IEnumerable<IRdfHandler> InnerHandlers
    {
        get
        {
            return this.handler.AsEnumerable();
        }
    }

    protected override void StartRdfInternal()
    {
        this.handler.StartRdf();
    }

    protected override void EndRdfInternal(bool ok)
    {
        this.handler.EndRdf(ok);
    }

    protected override bool HandleBaseUriInternal(Uri baseUri)
    {
        return this.handler.HandleBaseUri(baseUri);
    }

    protected override bool HandleNamespaceInternal(string prefix, Uri namespaceUri)
    {
        return this.handler.HandleNamespace(prefix, namespaceUri);
    }

    public override bool AcceptsAll
    {
        get
        {
            return this.handler.AcceptsAll;
        }
    }
}

class Program
{
    static void Main()
    {
        var graphA = Load("<http://example.com/subject> <http://example.com/predicate> \"object\".");
        var graphB = Load("<http://example.com/subject> <http://example.com/predicate> \"object\"^^<http://www.w3.org/2001/XMLSchema#string>.");

        var diff = graphA.Difference(graphB);

        Debug.Assert(diff.AreEqual);
    }

    private static IGraph Load(string source)
    {
        var result = new Graph();
        var graphHandler = new GraphHandler(result);
        var strippingHandler = new StripStringHandler(graphHandler);
        var parser = new TurtleParser();

        using (var reader = new StringReader(source))
        {
            parser.Load(strippingHandler, reader);
        }

        return result;
    }
}