Boolean Conjunctions and Disjunctions

AND Both Child Nodes

You may have noticed that, in our XML document, some parent nodes include some child nodes that are not found in other parent nodes. For example, the first, the second, and the third videos of our XML document have a <format> child node but the fourth video does not. On the other hand, the second, the third, and the fourth videos have a <categories> child node while the first does not.

You can ask the XmlNodeList.SelectNodes() method (in fact the XML interpreter) to produce in its results only the parent nodes that have a combination of certain two nodes. To get such a result, add a first combination that includes one of the names of child nodes. Include a second pair of square brackets with the other name. Here is an example:

using System.Xml;

namespace VideoCollection1
{
    public partial class Exercise : Form
    {
        public Exercise()
        {
            InitializeComponent();
        }

        private void btnVideos_Click(object sender, EventArgs e)
        {
            XmlDocument xdVideos = new XmlDocument();

            xdVideos.Load("../../../Videos.xml");

            XmlElement xeVideo = xdVideos.DocumentElement!;
            XmlNodeList xnlVideos = xeVideo.SelectNodes("/videos/video[format][categories]")!;    

            foreach(XmlNode xnVideo in xnlVideos)
            {
                MessageBox.Show(xnVideo.OuterXml,
                                "Video Collection",
                                MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
    }
}

This would produce:

The "and" operator is used to check that two child nodes are found under a parent node. To use it, create the square brackets and in them, provide the names of two child nodes separated by the and operator. Here is an example:

using System.Xml;

namespace VideoCollection1
{
    public partial class Exercise : Form
    {
        public Exercise()
        {
            InitializeComponent();
        }

        private void btnVideos_Click(object sender, EventArgs e)
        {
            XmlDocument xdVideos = new XmlDocument();

            xdVideos.Load("../../../Videos.xml");

            XmlElement xeVideo = xdVideos.DocumentElement!;
            XmlNodeList xnlVideos = xeVideo.SelectNodes("//videos/video[format and rating]")!;    

            foreach(XmlNode xnVideo in xnlVideos)
            {
                MessageBox.Show(xnVideo.OuterXml,
                                "Video Collection",
                                MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
    }
}

This would produce:

In this case, only parent nodes that have both child nodes would be produced.

Practical Learning: Introducing Boolean Operations

1. Start Microsoft Visual Studio
2. Create a Windows Forms App named BooleanOperations

OR Either Child Node

To produce the parent nodes that include one or the other child node, use the or operator. Here is an example:

using System.Xml;

namespace VideoCollection1
{
    public partial class Exercise : Form
    {
        public Exercise()
        {
            InitializeComponent();
        }

        private void btnVideos_Click(object sender, EventArgs e)
        {
            XmlDocument xdVideos = new XmlDocument();

            xdVideos.Load("../../../Videos.xml");

            XmlElement xeVideo = xdVideos.DocumentElement!;
            XmlNodeList xnlVideos = xeVideo.SelectNodes("/videos/video[cast-members or categories]")!;    

            foreach(XmlNode xnVideo in xnlVideos)
            {
                MessageBox.Show(xnVideo.OuterXml,
                                "Video Collection",
                                MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
    }
}

In this case, only parent nodes that have both child nodes would be produced:

Once you have accessed the nodes, you can apply any concept we have reviewed so far to locate a specific node. Here is an example:

using System.Xml;

namespace VideoCollection1
{
    public partial class Exercise : Form
    {
        public Exercise()
        {
            InitializeComponent();
        }

        private void btnVideos_Click(object sender, EventArgs e)
        {
            XmlDocument xdVideos = new XmlDocument();

            xdVideos.Load("../../../Videos.xml");

            XmlElement xeVideo = xdVideos.DocumentElement!;
            XmlNodeList xnlVideos = xeVideo.SelectNodes("/videos/video/cast-members[actor or narrator][. = 'Danny DeVito']")!;    

            foreach(XmlNode xnVideo in xnlVideos)
            {
                MessageBox.Show(xnVideo.InnerText,
                                "Video Collection",
                                MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
    }
}

This would produce:

NOT This Child Node

To let you get only the nodes that do not have a certain child node, the XPath provides a Boolean function named not. To use it, pass the name of the node to it. Here is an example:

using System.Xml;

namespace VideoCollection1
{
    public partial class Exercise : Form
    {
        public Exercise()
        {
            InitializeComponent();
        }

        private void btnVideos_Click(object sender, EventArgs e)
        {
            XmlDocument xdVideos = new XmlDocument();

            xdVideos.Load("../../../Videos.xml");

            XmlElement xeVideo = xdVideos.DocumentElement!;
            XmlNodeList xnlVideos = xeVideo.SelectNodes("/videos/video[not(cast-members)]")!;

            foreach(XmlNode xnVideo in xnlVideos)
            {
                MessageBox.Show(xnVideo.OuterXml,
                                "Video Collection",
                                MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
    }
}

When the not() function returns, it produces only the nodes that don't have the child-node whose name was passed:

Other Logical Opertions

Sets Combinations

All the expressions we have seen so far produced only one result each. To let you combine two results into one, the XPath language provides the | operator. It must be applied between two expressions. Here is an example:

using System.Xml;

namespace VideoCollection1
{
    public partial class Exercise : Form
    {
        public Exercise()
        {
            InitializeComponent();
        }

        private void btnVideos_Click(object sender, EventArgs e)
        {
            XmlDocument xdVideos = new XmlDocument();

            xdVideos.Load("../../../Videos.xml");

            XmlElement xeVideo = xdVideos.DocumentElement!;
            XmlNodeList xnlVideos = xeVideo.SelectNodes("//cast-members[actor='Danny DeVito'] | //cast-members[actor='Eddie Murphy']")!;

            foreach(XmlNode xnVideo in xnlVideos)
            {
                MessageBox.Show(xnVideo.OuterXml,
                                "Video Collection",
                                MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
    }
}

This would produce:

Boolean Operations

The XPath language provides some operators that can be used to perform Boolean operations. The numeric comparisons are used to find the Boolean relationship between two values. Only some operators are allowed. If you use an operator that is not valid, the compiler would throw an exception. The valid Boolean operators and the rules are:

• = Both values are the same. This operator can be applied to strings (and characters or symbols) or numeric values. Here is an example:

  using System.Xml;
  
  namespace VideoCollection1
  {
      public partial class Exercise : Form
      {
          public Exercise()
          {
              InitializeComponent();
          }
  
          private void btnVideos_Click(object sender, EventArgs e)
          {
              XmlDocument xdVideos = new XmlDocument();
  
              xdVideos.Load("../../../Videos.xml");
  
              XmlElement xeVideo = xdVideos.DocumentElement!;
              XmlNodeList xnlVideos = xeVideo.SelectNodes("//videos/video/cast-members[actor = 'Sheryl Lee Ralph']")!;    
  
              foreach(XmlNode xnVideo in xnlVideos)
              {
                  MessageBox.Show(xnVideo.InnerXml,
                                  "Video Collection",
                                  MessageBoxButtons.OK, MessageBoxIcon.Information);
              }
          }
      }
  }

  This would produce:

  

• > or &gt; The left value is greater than the right value. This operator can be applied only to numeric values. If the operator is applied to a string, the XmlNodeList.SelectNodes() method would return nothing; no exception would be thrown. If you want to perform such comparisons as to find out if one string is alphabetically lower than another, call the Compare() method of the string class
• >= The left value is greater than, or equal to, the right value. This operator follows the numeric and string rules of the > operator
• < or &lt; The left value is lower than the right value
• <= The left value is lower than, or equal to, the right value
• != The values are different. This operator can be applied to strings and/or numeric values

Here is an example:

using System.Xml;

namespace VideoCollection1
{
    public partial class Exercise : Form
    {
        public Exercise()
        {
            InitializeComponent();
        }

        private void btnVideos_Click(object sender, EventArgs e)
        {
            XmlDocument xdVideos = new XmlDocument();

            xdVideos.Load("../../../Videos.xml");

            XmlElement xeVideo = xdVideos.DocumentElement!;
            XmlNodeList xnlVideos = xeVideo.SelectNodes("//videos/video[length >= 100]")!;    

            foreach(XmlNode xnVideo in xnlVideos)
            {
                MessageBox.Show(xnVideo.InnerXml,
                                "Video Collection",
                                MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
    }
}

This would produce:

Practical Learning: Ending the Lesson

• Close your programming environment

Previous	Copyright © 2014-2024, FunctionX	Friday 01 Mars 2024	Next