Inspect and Navigate SVG in C#

Before code changes colors, replaces shapes, extracts data, or converts an SVG document, it often needs to find the exact element to work with. Aspose.SVG for .NET gives C# code DOM access to SVG content, so you can inspect markup, move through the document tree, select elements with CSS selectors, evaluate XPath queries, and iterate through nodes with custom filters.

In this article, you will learn how to:

• view SVG markup as a string;
• access the root <svg> element and traverse child elements;
• find elements by tag name, CSS selector, or XPath query;
• filter nodes with NodeIterator and NodeFilter;
• use navigation results as the starting point for editing or conversion workflows.

Quick Start: Find an SVG Element in C#

The following example loads an SVG file, finds the first <rect> element with a CSS selector, and prints the element markup:

using System;
using System.IO;
using Aspose.Svg;
using Aspose.Svg.Dom;

string inputPath = Path.Combine(DataDir, "shapes.svg");

using (SVGDocument document = new SVGDocument(inputPath))
{
    // Find the first rectangle in the SVG document
    Element rectangle = document.QuerySelector("rect");

    if (rectangle == null)
    {
        Console.WriteLine("No <rect> element was found.");
        return;
    }

    // Print the selected element as SVG markup
    Console.WriteLine(rectangle.OuterHTML);
}

Use this pattern when you already know which element you need to inspect or modify. The null check keeps the example clear when the input SVG does not contain the expected element. If the SVG structure is unknown, start with DOM traversal or OuterHTML to understand the document first.

View SVG Markup as a String

The OuterHTML property returns the markup of an element together with its children. The InnerHTML property returns only the element content. These properties are useful for quick diagnostics, logging, and checking which part of the SVG document has been selected.

This example prints the markup of the root <svg> element:

using Aspose.Svg;
using System;

// View SVG document content as OuterHTML in C#

// Load an SVG document
using (SVGDocument document = new SVGDocument(Path.Combine(DataDir, "bezier-curves.svg")))
{
    // Use the OuterHTML property
    string html = document.DocumentElement.OuterHTML;

    Console.WriteLine(html);
}
// View the document content

Navigate the SVG DOM

An SVG document is an XML-based tree of nodes. The root <svg> element can be accessed in two common ways:

• DocumentElement returns the document element as a general DOM Element.
• RootElement returns the same root element as SVGSVGElement.

using Aspose.Svg;
using Aspose.Svg.Dom;

Element documentElement = document.DocumentElement;
SVGSVGElement rootElement = document.RootElement;

For simple traversal inside the SVG element tree, use element-level properties such as FirstElementChild, LastElementChild, NextElementSibling, and Children. Here, Children means the child elements of an Element, for example the children of <svg> or <g>, not the Document.Children collection. The following example walks from the document element to nested child elements and prints their tag names:

using Aspose.Svg;
using System;
using System.IO;

// Traverse SVG document elements using the DOM in C#

// Load an SVG document
using (SVGDocument document = new SVGDocument(Path.Combine(DataDir, "shapes_svg.svg")))
{
    // Get direct access to the <svg> element of the document
    Element element = document.DocumentElement;
    Console.WriteLine(element.TagName); // svg

    // Use the LastElementChild property
    element = element.LastElementChild;
    Console.WriteLine(element.TagName); // g

    // Use the FirstElementChild property
    element = element.FirstElementChild;
    Console.WriteLine(element.TagName); // rect
}

Find Elements by Tag Name

Use GetElementsByTagName() when you need all descendants with the same SVG tag name, such as all <circle> or <rect> elements. The method returns a NodeList, which can be inspected or filtered in code.

The following example finds the first <g> element, reads its first child element, and prints the width and height of that <rect> element:

using Aspose.Svg;
using System;
using System.IO;
using System.Linq;

// Extract information about a specific SVG element in C#

string documentPath = Path.Combine(DataDir, "shapes_svg.svg");

// Load a document from a file
using (SVGDocument document = new SVGDocument(documentPath))
{
    // Get the root <svg> element of the document
    Element svg = document.DocumentElement;

    // Find the first child element with a given tag name
    SVGGElement g = svg.GetElementsByTagName("g").First() as SVGGElement;
    SVGRectElement rect = g.FirstElementChild as SVGRectElement;

    Console.WriteLine("Height: {0}", rect.Height); // 100
    Console.WriteLine("Width: {0}", rect.Width); // 100
}

Find SVG Elements with CSS Selectors

CSS selectors are often the most concise way to find elements by tag name, id, class, attributes, or position in the SVG tree. QuerySelector() returns the first matching element. QuerySelectorAll() returns all matching elements as a NodeList.

The following example uses an attribute selector to find only the rectangles whose inline style contains FireBrick, then prints their id values. This is a more targeted search than selecting every <rect> element in the file.

using System;
using System.IO;
using Aspose.Svg;
using Aspose.Svg.Collections;
using Aspose.Svg.Dom;

string inputPath = Path.Combine(DataDir, "shapes.svg");

using (SVGDocument document = new SVGDocument(inputPath))
{
    // Select only rectangles whose style attribute contains "FireBrick"
    NodeList fireBrickRectangles = document.QuerySelectorAll("rect[style*='FireBrick']");

    if (fireBrickRectangles.Length == 0)
    {
        Console.WriteLine("No rectangles with FireBrick in the style attribute were found.");
        return;
    }

    foreach (Element rectangle in fireBrickRectangles)
    {
        Console.WriteLine(rectangle.GetAttribute("id"));
    }
}

If the input SVG contains rectangles with FireBrick in the style attribute, the example prints their id values. The explicit empty-result check keeps the example useful when the SVG does not contain matching elements.

CSS selectors are also useful before editing. For larger examples that select owl illustration elements and modify them, see Edit SVG Using CSS Selectors.

Navigate SVG with XPath

XPath is useful when the selection condition is easier to express as a document query, for example by matching an attribute value or a hierarchy of elements. Aspose.SVG supports XPath evaluation through Evaluate().

The following example finds a <rect> element whose x attribute equals 120 and prints the selected node:

using System;
using System.IO;
using Aspose.Svg;
using Aspose.Svg.Dom;
using Aspose.Svg.Dom.XPath;

string inputPath = Path.Combine(DataDir, "shapes.svg");

using (SVGDocument document = new SVGDocument(inputPath))
{
    // Evaluate the XPath expression against the SVG document
    IXPathResult result = document.Evaluate(
        "//rect[@x='120']",
        document,
        null,
        Dom.XPath.XPathResultType.Any,
        null);

    // Read the first matching node
    Element selectedElement = result.IterateNext() as Element;

    if (selectedElement == null)
    {
        Console.WriteLine("No rectangle with x=\"120\" was found.");
        return;
    }

    Console.WriteLine(selectedElement.OuterHTML);
}

In the sample shapes.svg file, this XPath expression selects the rectangle with id="second-rect". XPath is especially helpful when the condition is attribute-based or when the target element is easier to describe by its position in the XML tree.

Filter Nodes with NodeIterator

Use CreateNodeIterator() when traversal should move through the document while a custom filter decides which nodes are accepted. A filter derived from NodeFilter returns FILTER_ACCEPT for nodes that should be visible to the iterator and FILTER_REJECT for nodes that should be skipped.

The following example creates an iterator that accepts only <rect> elements:

using Aspose.Svg;
using Aspose.Svg.Dom;
using Aspose.Svg.Dom.Traversal.Filters;
using System;
using System.IO;

// Iterate SVG rectangle nodes with a custom NodeFilter in C#

using (SVGDocument document = new SVGDocument(Path.Combine(DataDir, "shapes.svg")))
{
    // Create a node iterator
    using (INodeIterator iterator = document.CreateNodeIterator(document, NodeFilter.SHOW_ALL, new RectFilter()))
    {
        Node node;
        while ((node = iterator.NextNode()) != null)
        {
        }
    }
}

The RectFilter class accepts nodes whose NodeName is rect:

public class RectFilter : NodeFilter
{
    public override short AcceptNode(Node node)
    {
        return string.Equals("rect", node.NodeName)
            ? FILTER_ACCEPT
            : FILTER_REJECT;
    }
}

NextNode() returns the next accepted node and advances the iterator position. This is useful when you need a repeatable traversal rule rather than a one-time selector.

FAQ

1. Should I use CSS selectors or XPath to find SVG elements?
Use CSS selectors for common SVG selection tasks such as finding elements by tag name, id, class, attributes, or parent-child relationships. Use XPath when the query is easier to express as a document path or when you need more XML-style selection logic.

2. What is the difference between DocumentElement and RootElement?
DocumentElement comes from the general DOM Document API and returns the document element as an Element. RootElement is specific to SVGDocument and returns the root <svg> element as SVGSVGElement, which exposes SVG-specific members.

3. Can I inspect SVG before editing or converting it?
Yes. A common workflow is to load an SVG file, inspect its structure with OuterHTML, DOM traversal, CSS selectors, or XPath, and only then modify selected elements or pass the document to conversion code.

4. Can I inspect the generated or edited SVG without saving it first?
Yes. After creating or editing an SVGDocument, read DocumentElement.OuterHTML or inspect selected elements directly in memory. Saving is only needed when you want to write the document to a file, stream, or another storage target.

Next Steps

• Edit SVG Files in C# – add, update, and save SVG elements.
• Edit SVG Using CSS Selectors – see larger selector-based editing examples.
• Save SVG Documents – save inspected or modified SVG content.
• How to Run the Examples – download and run the complete examples from GitHub.