C# INode.Equals方法代码示例

 /// <summary>
 /// Checks for circular references and throws an error if there is one
 /// </summary>
 /// <param name="a">Object you are attempting to load</param>
 /// <param name="b">Object being referenced</param>
 /// <param name="property">QName for the property that makes the reference</param>
 /// <remarks>
 /// <para>
 /// If the Object you are trying to load and the Object you need to load are equal then this is a circular reference and an error is thrown
 /// </para>
 /// <para>
 /// The <see cref="ConfigurationLoader">ConfigurationLoader</see> is not currently capable of detecting more subtle circular references
 /// </para>
 /// </remarks>
 public static bool CheckCircularReference(INode a, INode b, String property)
 {
     if (a.Equals(b))
     {
         throw new DotNetRdfConfigurationException("Unable to load the Object identified by the Node '" + a.ToString() + "' as one of the values for the " + property + " property is a circular reference to the Object we are attempting to load");
     }
     else
     {
         return false;
     }
 }

 private static bool NodeMatch(INode expectedNode, INode actualNode, Dictionary<string, string> bnodeMap)
 {
     if (expectedNode is IBlankNode && actualNode is IUriNode)
     {
         var actualUriNode = actualNode as IUriNode;
         var expectedBNode = expectedNode as IBlankNode;
         if (bnodeMap.ContainsKey(actualUriNode.Uri.ToString()))
         {
             return expectedBNode.InternalID.Equals(bnodeMap[actualUriNode.Uri.ToString()]);
         }
         return true;
     }
     if (expectedNode is IBlankNode && actualNode is IBlankNode)
     {
         var ebNode = expectedNode as IBlankNode;
         var abNode = actualNode as IBlankNode;
         if (bnodeMap.ContainsKey(abNode.InternalID))
         {
             return ebNode.InternalID.Equals(bnodeMap[abNode.InternalID]);
         }
         return true; // ebNode.InternalID.Equals(abNode.InternalID);
     }
     if (!expectedNode.NodeType.Equals(actualNode.NodeType)) return false;
     return expectedNode.Equals(actualNode);
 }

 /// <inheritdoc />
 public IVNode OtherEnd(INode node)
 {
     if (!node.Equals(To) && !node.Equals(From))
         throw new Exception("Cannot return other end. Parameter 'node' must be connected to link.");
     return From.Equals(node) ? To : From;
 }

        /// <summary>
        /// Implements Node Inequality with SPARQL Semantics
        /// </summary>
        /// <param name="x">Node</param>
        /// <param name="y">Node</param>
        /// <returns></returns>
        public static bool Inequality(INode x, INode y)
        {
            if (x == null || y == null)
            {
                //Nulls can't be equal to each other
                throw new RdfQueryException("Cannot evaluate inequality when one/both arguments are null");
            }
            else if (x.NodeType != y.NodeType)
            {
                //Different Type Nodes are never equal to each other
                return true;
            }
            else if (x.NodeType == NodeType.Literal)
            {
                //Do they have supported Data Types?
                String xtype, ytype;
                try
                {
                    xtype = XmlSpecsHelper.GetSupportedDataType(x);
                    ytype = XmlSpecsHelper.GetSupportedDataType(y);
                }
                catch (RdfException)
                {
                    //Can't determine a Data Type for one/both of the Nodes so use RDF Term equality instead
                    return !x.Equals(y);
                }

                if (xtype.Equals(String.Empty) || ytype.Equals(String.Empty))
                {
                    //One/both has an unknown type
                    if (x.Equals(y))
                    {
                        //If RDF Term equality returns true then we return false
                        return false;
                    }
                    else
                    {
                        //If RDF Term equality returns false then we error
                        throw new RdfQueryException("Unable to determine inequality since one/both arguments has an Unknown Type");
                    }
                }
                else
                {
                    //Both have known types
                    SparqlNumericType xnumtype = GetNumericTypeFromDataTypeUri(xtype);
                    SparqlNumericType ynumtype = GetNumericTypeFromDataTypeUri(ytype);
                    SparqlNumericType numtype = (SparqlNumericType)Math.Max((int)xnumtype, (int)ynumtype);
                    if (numtype != SparqlNumericType.NaN)
                    {
                        if (xnumtype == SparqlNumericType.NaN || ynumtype == SparqlNumericType.NaN)
                        {
                            //If one is non-numeric then we can't assume non-equality
                            return false;
                        }

                        //Both are Numeric so use Numeric equality
                        try
                        {
                            return !NumericEquality(x, y, numtype);
                        }
                        catch (FormatException)
                        {
                            if (x.Equals(y)) return false;
                            return false;
                        }
                        catch (RdfQueryException)
                        {
                            //If this errors try RDF Term equality since 
                            return !x.Equals(y);
                        }
                    }
                    else if (xtype.Equals(ytype))
                    {
                        switch (xtype)
                        {
                            case XmlSpecsHelper.XmlSchemaDataTypeDate:
                                return !DateEquality(x, y);
                            case XmlSpecsHelper.XmlSchemaDataTypeDateTime:
                                return !DateTimeEquality(x, y);
                            case XmlSpecsHelper.XmlSchemaDataTypeDuration:
                                return !TimeSpanEquality(x, y);
                            case XmlSpecsHelper.XmlSchemaDataTypeString:
                                //Both Strings so use Lexical string equality
                                return !((ILiteralNode)x).Value.Equals(((ILiteralNode)y).Value);
                            default:
                                //Use value equality
                                return (x.CompareTo(y) != 0);
                        }
                    }
                    else
                    {
                        String commontype = XmlSpecsHelper.GetCompatibleSupportedDataType(xtype, ytype);
                        if (commontype.Equals(String.Empty))
                        {
//.........这里部分代码省略.........

        private void OnNodeUpdated(INode node)
        {
            if (!node.Equals(Source)){
                throw new ArgumentException("Received updated callback for wrong node");
            }

            Source.Updated -= OnNodeUpdated;

            foreach (var child in ((IFolder)node).Children) {
                ITransfer t = Transfers.CreateTransfer(child, Path.Combine(Destination, child.Name), 0);
                SubTransfers.Add(t);
            }

            if (startCalled) {
                Download();
            } else {
                Status = Status.Pending;
                listingDone = true;
            }
        }