APPENDIX A

Creating a Custom XmlReader and XmlWriter

In Chapter 3, you learned about the XmlReader and XmlWriter classes. The abstract classes XmlReader and XmlWriter can be used in three ways: • To call the Create() method of the respective classes that return an instance of the generic XmlReader or XmlWriter classes • To use the concrete classes XmlTextReader and XmlTextWriter provided by the .NET Framework • To create custom classes that inherit from the XmlReader and XmlWriter classes You are already familiar with the first two approaches. In the following sections, you are going to learn how to create custom readers and writers from the abstract base classes XmlReader and XmlWriter.

Creating a Custom XmlReader In this section, you will create a custom implementation of the XmlReader class. The SqlCommand class provides the ExecuteXmlReader() method that returns an instance of XmlReader to the caller. This works fine if your database is SQL Server, but what if your database is Microsoft Office Access or any other OLEDB- compliant database? Moreover, XML extensions such as the FOR XML clause may not be available for all databases. Does that mean that you cannot retrieve the data and read it by using an XmlReader? Of course not. There is no out-of-the-box solution for this problem, but you can build your own mechanism to overcome this limitation, by creating a custom class that inherits from the XmlReader abstract class. You can then override the required properties and methods as per your need. The requirements for the custom XmlReader class are summarized here: • It should accept the database connection string and table name to read. • The column values should be treated as attribute values. • It should allow iterating through the table to read each row. • The column values should be accessible by specifying a column index or name.

© Bipin Joshi 2017 421 B. Joshi, Beginning XML with C# 7, https://doi.org/10.1007/978-1-4842-3105-0 Appendix A ■ Creating a Custom XmlReader and XmlWriter

Inheriting from XmlReader The XmlReader class is an abstract class and provides several properties and methods that you need to override when you inherit from it. Listing A-1 shows signatures of these properties and methods.

Listing A-1. Properties and Methods of the XmlReader Class public abstract int AttributeCount; public abstract string BaseURI { get; } public abstract void Close(); public abstract int Depth { get; } public abstract bool EOF { get; } public abstract string GetAttribute(int i); public abstract string GetAttribute(string name, string namespaceURI); public abstract string GetAttribute(string name); public abstract bool HasValue { get; } public abstract bool IsEmptyElement { get; } public abstract string LocalName { get; } public abstract string LookupNamespace(string prefix); public abstract bool MoveToAttribute(string name, string ns); public abstract bool MoveToAttribute(string name); public abstract bool MoveToElement(); public abstract bool MoveToFirstAttribute(); public abstract bool MoveToNextAttribute(); public abstract XmlNameTable NameTable { get; } public abstract string NamespaceURI { get; }

422 Appendix A ■ Creating a Custom XmlReader and XmlWriter public abstract XmlNodeType NodeType { get; } public abstract string Prefix { get; } public abstract bool Read(); public abstract bool ReadAttributeValue(); public abstract ReadState ReadState { get; } public abstract void ResolveEntity(); public abstract string Value { get; }

You can override these properties and methods and write your own data-manipulation logic. If you do not want to override a particular property or method, you still need to have its empty implementation. A better way is to throw an exception in such properties and methods so that the caller knows that these properties and methods are not implemented by you. I will not discuss every property here because you are already familiar with many of them (see Chapter 3 for more information).

Creating the TableReader Class Now that you are familiar with the XmlReader abstract class, let’s create our own implementation. To do so, create a new project of type class library by using Visual Studio. Add a class named TableReader. Make sure that references to the System.Xml and System.Data assemblies are added to the project. Import the namespaces as shown in Listing A-2 at the top of the TableReader class and ensure that the TableReader class inherits from the XmlReader class.

Listing A-2. Importing Namespaces and Setting Inheritance using System.Xml; using System.Data; using System.Data.OleDb; class TableReader:XmlReader { ...

You need to add an implementation of each property and method mentioned. Visual Studio provides a shortcut for adding empty implementations of these members. Go to the class declaration line and look for the Quick Actions icon in the left margin. Open the Quick Actions list and choose the Implement Abstract Class option (see Figure A-1).

423 Appendix A ■ Creating a Custom XmlReader and XmlWriter

Figure A-1. Adding empty implementations of properties and methods

This will add dummy signatures of all the properties and methods that need to be overridden. Notice how the dummy implementation throws an exception by using the throw keyword. This way, if somebody tries to use unimplemented members, an exception will be thrown indicating that “the method or operation is not implemented.” Code the TableReader class as shown in Listing A-3.

Listing A-3. The TableReader Class public class TableReader:XmlReader { private OleDbConnection cnn; private OleDbCommand cmd; private OleDbDataReader reader; private int intColumnIndex = -1; private string strValue;

public TableReader(string connectionString,string tableName) { cnn = new OleDbConnection(connectionString); cmd = new OleDbCommand(); cmd.Connection = cnn; cmd.CommandText = tableName; cmd.CommandType = CommandType.TableDirect; cnn.Open(); reader = cmd.ExecuteReader(); }

public override int AttributeCount { get { return reader.FieldCount; } }

public override void Close() { reader.Close(); cnn.Close(); }

424 Appendix A ■ Creating a Custom XmlReader and XmlWriter

public override int Depth { get { return reader.Depth; } }

public override string GetAttribute(int i) { return reader.GetValue(i).ToString(); }

public override string GetAttribute(string name) { return reader.GetValue(reader.GetOrdinal(name)).ToString(); }

public override bool MoveToAttribute(string name) { intColumnIndex = reader.GetOrdinal(name); return true; }

public override bool MoveToElement() { intColumnIndex = -1; return true; }

public override bool MoveToFirstAttribute() { intColumnIndex = 0; return true; }

public override bool MoveToNextAttribute() { intColumnIndex++; if (intColumnIndex > reader.FieldCount - 1) { return false; } else { return true; } }

425 Appendix A ■ Creating a Custom XmlReader and XmlWriter

public override bool Read() { intColumnIndex = -1; strValue = ""; return reader.Read(); }

public override bool HasValue { get { return reader.IsDBNull(intColumnIndex); } }

public override bool ReadAttributeValue() { if (intColumnIndex < reader.FieldCount) { strValue = reader.GetValue(intColumnIndex).ToString(); return true; } else { return false; } }

public string Name { get { if (intColumnIndex == -1) { return cmd.CommandText; } else { return reader.GetName(intColumnIndex); } } }

public override string Value { get { return strValue; } } ... }

In the following text, we dissect the code step by step. 426 Appendix A ■ Creating a Custom XmlReader and XmlWriter

Declaring Class-Level Variables private OleDbConnection cnn; private OleDbCommand cmd; private OleDbDataReader reader; private int intColumnIndex = -1; private string strValue;

The TableReader class declares private variables of type OleDbConnection, OleDbCommand, and OleDbDataReader at the class level: • The OleDbConnection class is used to establish a connection with any OLEDB- compliant databases. • The OleDbCommand class is used to execute any query, SQL query, or stored procedures against a database. • The OleDbDataReader class allows you to iterate through a result set in a cursor- oriented manner. The intColumnIndex integer variable keeps track of the current column index whose value is to be read. Similarly, the strValue string variable stores the value from the column indicated by intColumnIndex.

Initializing the Variables public TableReader(string connectionString,string tableName) { cnn = new OleDbConnection(connectionString); cmd = new OleDbCommand(); cmd.Connection = cnn; cmd.CommandText = tableName; cmd.CommandType = CommandType.TableDirect; cnn.Open(); reader = cmd.ExecuteReader(); }

The constructor of the TableReader class accepts two parameters: the database connection string and the name of the table whose data is to be read. Using the connection string, the OleDbConnection is instantiated. The Connection property of the OleDbCommand class is set to the OleDbConnection class we just instantiated. The CommandText property of the OleDbCommand class is set to the name of the table whose data is to be read. Have a look at the CommandType property. It is set to TableDirect, which returns all the rows from the table indicated by the CommandText property. In effect, it works as if we have specified SELECT * FROM as the query. The database connection is then opened. The ExecuteReader() method of OleDbCommand is called and an OleDbDataReader is retrieved.

427 Appendix A ■ Creating a Custom XmlReader and XmlWriter

Retrieving the Total Number of Attributes public override int AttributeCount { get { return reader.FieldCount; } }

The TableReader class is going to return column values as attributes in the resultant XML data. Hence, the AttributeCount read-only property returns the total number of columns in the underlying table. The total number of columns in the table is obtained by using the FieldCount property of the OleDbDataReader class.

Closing the Reader public override void Close() { reader.Close(); cnn.Close(); } public override int Depth { get { return reader.Depth; } }

The Close() method closes the OleDbDataReader as well as the OleDbConnection. The Depth property returns the Depth of the OleDbDataReader.

Reading Attributes public override string GetAttribute(int i) { return reader.GetValue(i).ToString(); }

public override string GetAttribute(string name) { return reader.GetValue(reader.GetOrdinal(name)).ToString(); }

The column values can be retrieved by using two overloads of the GetAttribute() method. The first overload accepts the attribute index. In our case, the attribute index is the same as the column index. The GetValue() method of the OleDbDataReader class accepts the column index and returns the column value as an object. The ToString() method returns a string representation of the object to the caller. The second overload accepts an attribute name. The GetOrdinal() method of OleDbDataReader accepts the column name and returns its index. The returned index is then passed to the GetValue() method as before. 428 Appendix A ■ Creating a Custom XmlReader and XmlWriter

Navigating Between the Attributes public override bool MoveToAttribute(string name) { intColumnIndex = reader.GetOrdinal(name); return true; } public override bool MoveToElement() { intColumnIndex = -1; return true; } public override bool MoveToFirstAttribute() { intColumnIndex = 0; return true; } public override bool MoveToNextAttribute() { intColumnIndex++; if (intColumnIndex > reader.FieldCount - 1) { return false; } else { return true; } }

The MoveToAttribute(), MoveToFirstAttribute(), MoveToNextAtribute(), and MoveToElement() methods allow you to navigate within the available attributes: • The MoveToAttribute() method accepts the name of the column (which is the same as the attribute name) and sets the column index variable to the index of that column. • The MoveToFirstAttribute() method sets the current column index to 0, whereas MoveToNextAttribute() increments it so that the next column value can be read. • The MoveToElement() method simply sets the current column index to -1, indicating that no column value can be read. The MoveToElement() method is intended to move the reader to the element node from any of its attributes. By setting the column index to -1, we reset the column index counter and mimic this behavior.

429 Appendix A ■ Creating a Custom XmlReader and XmlWriter

Advancing the Reader public override bool Read() { intColumnIndex = -1; strValue = ""; return reader.Read(); }

The Read() method allows you to iterate through the table. It calls the Read() method of the OleDbDataReader class and returns a Boolean value indicating whether the read operation was successful. As the record pointer is moving on to a new record, the current column index and value are reset.

Checking Whether the Value Is Empty public override bool HasValue { get { return reader.IsDBNull(intColumnIndex); } }

The HasValue property indicates whether the TableReader contains any value. If the column contains a NULL value, HasValue should return false. The IsDbNull() method of the OleDbDataReader class accepts a column index and returns true if the column contains a NULL value.

Reading Values public override bool ReadAttributeValue() { if (intColumnIndex < reader.FieldCount) { strValue = reader.GetValue(intColumnIndex).ToString(); return true; } else { return false; } }

The ReadAttributeValue() method returns the value of the current column. It does so by using the GetValue() method of the OleDbDataReader class as before.

430 Appendix A ■ Creating a Custom XmlReader and XmlWriter

Returning the Table or Column Name public string Name { get { if (intColumnIndex == -1) { return cmd.CommandText; } else { return reader.GetName(intColumnIndex); } } }

The Name property returns either the underlying table name or column name. This is useful to see which column is being read. The table name is obtained from the CommandText property of the OleDbCommand class, whereas the column name is obtained from the GetName() method of the OleDbDataReader class.

Returning Values public override string Value { get { return strValue; } }

Finally, the Value property simply returns the value stored in the strValue variable. Note that strValue gets assigned in the ReadAttributeValue() method. The remaining properties and methods are not implemented by the TableReader class. Compile the class library and you should get an assembly, TableReader.dll. This assembly can be used in client applications to work with OLEDB databases and XML.

Using the TableReader Class To consume the TableReader class, you need to create a Windows Forms application like the one shown in Figure A-2.

431 Appendix A ■ Creating a Custom XmlReader and XmlWriter

Figure A-2. Application that consumes the TableReader class

The application consists of text boxes for entering the database connection string and table name, respectively. After you click the Read button, the TableReader class is instantiated. It reads the table data and writes it to an XML file. The XML file thus created is displayed in a Web Browser control. The Click event handler of the Read button contains the code shown in Listing A-4.

Listing A-4. Using the TableReader Class private void button1_Click(object sender, EventArgs e) { TableReader tr = new TableReader(textBox1.Text, textBox2.Text); XmlTextWriter writer = new XmlTextWriter($"{Application.StartupPath}\\temp.xml", null); writer.WriteStartDocument(); writer.WriteStartElement("root"); int count = tr.AttributeCount; while (tr.Read()) { writer.WriteStartElement(tr.Name); for (int i = 0; i < count; i++) { tr.MoveToAttribute(i); tr.ReadAttributeValue(); writer.WriteAttributeString(tr.Name, tr.Value); } writer.WriteEndElement(); }

432 Appendix A ■ Creating a Custom XmlReader and XmlWriter

writer.WriteEndElement(); tr.Close(); writer.Close(); webBrowser1.Navigate($"{Application.StartupPath}\\temp.xml"); }

Before you write the preceding code, add a reference to TableReader.dll in the Windows application and import the namespace at the top. The code creates an instance of the TableReader class by passing the database connection string and table name to its constructor. Then an XmlTextWriter is created that writes data to a temporary XML file called temp.xml. The TableReader class will return only the fragmented XML data; hence the root element is added by using the WriteStartElement() method of the XmlTextWriter class. The total number of columns in the supplied table is retrieved by using the AttributeCount property and is stored in a variable for later use. A while loop calls the Read() method of the TableReader class. With each iteration, an element is added to the file with the same name as the table name. Recollect that the Name property of the TableReader class returns either the table name or column name depending on the current column index. Because we have just called the Read() method, the column index is going to be -1 and hence the table name will be returned. Next, a for loop iterates through all the attributes—that is, columns. With each iteration of the for loop, the value of the attribute is read by using the ReadAttributeValue() method. An attribute is then written to the file along with its value by using the WriteAttributeString() method of the XmlTextWriter class. The WriteEndElement() method of the XmlTextWriter class writes end tags for the nearest open element. The TableReader and XmlTextReader are then closed by using their respective Close() methods. Finally, the Navigate() method of the web browser control shows the user the XML file.

Creating a Custom XmlWriter Now that you have created a custom implementation of XmlReader, let’s move further and see how to create a custom XmlWriter. As an example, we will create an RSS writer that emits RSS feeds. Really Simple Syndication (RSS) is a standard way to share your web site content with others. It is nothing but standardized XML markup that describes the content you want to share. Because RSS is a widely accepted format, your content immediately becomes ready to be consumed by others. Listing A-5 illustrates an RSS document.

Listing A-5. Sample RSS Markup http://localhost/mywebsite Latest Articles from My Web Site Copyright (C) My Web Site. All rights reserved. My RSS Generator http://localhost/mywebsite/displayarticle.aspx?id=239 Description goes here Sun, 25 Jan 2004 12:00:00 AM GMT

433 Appendix A ■ Creating a Custom XmlReader and XmlWriter

Let’s look at each markup tag closely: • forms the root tag and has a version attribute. The version attribute specifies the RSS specification version used by the markup, 2.0 in this case. • contains tags such as