You could try use NewtonSoft.Json to parse xml to jsonString, then deserilize the jsonString object.

var doc = XDocument.Load("test.xml");
var jsonString = JsonConvert.SerializeXNode(doc);

//parse to jObject
var jObject = JsonConvert.DeserializeObject<JObject>(jsonString);
var value = jObject["layout"]["hierarchy"]["root"]["template_row_header"]["dy_title"]["@this"];

This approach is very cumbersome if you have dynamic XML. As class definitions have to be done at compile time, you don’t get much flexibility at runtime.

But there’s another class for handling XMLs – XDocument.

It does not require predefined class to deserialize into and allows more dynamic approach.

Here’s code snippet that traverses whole XML:

using System.Xml.Linq;

var rawJson = @"<?xml version=""1.0""?>
<layout
    version=""137""
    comment=""""
    precache_condition="""">
    <hierarchy>
        <root this=""2A19D461-6F9E-45F7-977F41D42D07FDB0"">
            <template_row_header this=""F3416CFD-8BC7-4276-86996FD67D7F6A75"">
                <dy_title this=""77E6B934-1E3B-40E5-BC14C7F643672167""/>
            </template_row_header>
        </root>
    </hierarchy>
    <components>
        <root
            this=""2A19D461-6F9E-45F7-977F41D42D07FDB0""
            id=""root"">
        </root>
        <template_row_header
            this=""F3416CFD-8BC7-4276-86996FD67D7F6A75""
            id=""template_row_header""
            offset=""0.00,4.00"">
        </template_row_header>
        <dy_title
            this=""77E6B934-1E3B-40E5-BC14C7F643672167""
            id=""dy_title""
            offset=""0.00,0.00"">
        </dy_title>
    </components>
</layout>";

var xDoc = XDocument.Parse(rawJson);

TraverseElement(xDoc.Root);

void TraverseElement(XElement node, string currentPath = "")
{
    if(!node.HasElements)
        Console.WriteLine($"Value for path {currentPath} is {node.Value}, first attribute value: {node.FirstAttribute?.Value}");

    foreach (var item in node.Descendants())
    {
        TraverseElement(item, currentPath + " -> " + item.Name);
    }
}

And the output is:

Value for path  -> hierarchy -> root -> template_row_header -> dy_title is , first attribute value: 77E6B934-1E3B-40E5-BC14C7F643672167
Value for path  -> hierarchy -> root -> dy_title is , first attribute value: 77E6B934-1E3B-40E5-BC14C7F643672167
Value for path  -> hierarchy -> template_row_header -> dy_title is , first attribute value: 77E6B934-1E3B-40E5-BC14C7F643672167
Value for path  -> hierarchy -> dy_title is , first attribute value: 77E6B934-1E3B-40E5-BC14C7F643672167
Value for path  -> root -> template_row_header -> dy_title is , first attribute value: 77E6B934-1E3B-40E5-BC14C7F643672167
Value for path  -> root -> dy_title is , first attribute value: 77E6B934-1E3B-40E5-BC14C7F643672167
Value for path  -> template_row_header -> dy_title is , first attribute value: 77E6B934-1E3B-40E5-BC14C7F643672167
Value for path  -> dy_title is , first attribute value: 77E6B934-1E3B-40E5-BC14C7F643672167
Value for path  -> components -> root is , first attribute value: 2A19D461-6F9E-45F7-977F41D42D07FDB0
Value for path  -> components -> template_row_header is , first attribute value: F3416CFD-8BC7-4276-86996FD67D7F6A75
Value for path  -> components -> dy_title is , first attribute value: 77E6B934-1E3B-40E5-BC14C7F643672167
Value for path  -> root is , first attribute value: 2A19D461-6F9E-45F7-977F41D42D07FDB0
Value for path  -> template_row_header is , first attribute value: F3416CFD-8BC7-4276-86996FD67D7F6A75
Value for path  -> dy_title is , first attribute value: 77E6B934-1E3B-40E5-BC14C7F643672167

UPDATE
Below is more examples how to get information out of XML using XDocument class. Comments in code:

var xDoc = XDocument.Parse(rawJson);

var componentChildren = xDoc.Descendants("components").Descendants();

foreach (var child in componentChildren)
{
    var tagName = child.Name;

    Console.WriteLine($"tagName={tagName} which has following attributes:");

    PrintAllAttributes(child);

    PrintSpecificAttribute(child, "this");
}

// This is the way to access all attributes of element.
void PrintAllAttributes(XElement child)
{
    var attributes = child.Attributes();

    foreach (var attribute in attributes)
        Console.WriteLine(attribute);
}
// And here's how you can access specific attribute and get its value.
void PrintSpecificAttribute(XElement child, string attributeName)
{
    var attribute = child.Attribute(attributeName);
    Console.WriteLine(attribute.Value);
}

In a situation where you have a sequence of child elements that have different element names but similar schemas, you can use XmlSerializer’s support for polymorphism to map the elements to a collection of C# polymorphic types. This corresponds to a sequence of <xsd:choice> elements in an XSD schema. The basic idea is to:

1. Define some base type TBaseType with the properties common to all elements. (It could be object if there are no common properties.)

2. Add derived types TDerivedType corresponding to each specific element name derivedElementName, and apply [XmlType("derivedElementName")] to each.

3. In each containing type that has a sequence of TBaseType elements, add a List<TBaseType> property. Then inform the serializer of all possible derived types by applying [XmlElement(typeof(TDerivedType))] for all derived types.

Thus, for your specific XML, first define the following data model:

// The root model <layout>
[XmlType("layout"), XmlRoot("layout")]
public class LayoutModel 
{
    [XmlAttribute("version")]
    public uint Version { get; set; }

    [XmlAttribute("comment")]
    public string Comment { get; set; } = "";

    [XmlAttribute("precache_condition")]
    public string PrecacheCondition { get; set; } = "";

    [XmlElement("hierarchy")]
    public LayoutContainerModel? Hierarchy { get; set; }

    [XmlElement("components")]
    public LayoutContainerModel? Components { get; set; }
}

// THe container model for <hierarchy> and <components>.
public class LayoutContainerModel
{
    [XmlElement("root")]
    public LayoutItemRoot? Root { get; set; }

    // The same list of polymorphic children must appear in LayoutItemBase.Children
    [XmlElement(typeof(DyTitle)),
     XmlElement(typeof(TemplateRowHeader))
     // Add others as required
    ]
    public List<LayoutItemBase> Children { get; set; } = new();
}

// The type hierarchy for the polymorphic sequence of child elements
public abstract class LayoutItemBase
{
    [XmlAttribute("this")]
    public string? This { get; set; }
    
    [XmlAttribute("id")]
    public string? Id { get; set; }
    
    // The same list of polymorphic children must appear in LayoutModelContainer.Children
    [XmlElement(typeof(DyTitle)),
     XmlElement(typeof(TemplateRowHeader))
     // Add others as required
    ]
    public List<LayoutItemBase> Children { get; set; } = new();
}

[XmlType("root")]
public class LayoutItemRoot : LayoutItemBase;

[XmlType("dy_title")]
public class DyTitle : LayoutItemBase
{
    [XmlAttribute("offset")]
    public string? Offset { get; set; }
}

[XmlType("template_row_header")]
public class TemplateRowHeader : LayoutItemBase
{
    [XmlAttribute("offset")]
    public string? Offset { get; set; }
}

Then given some static extension method like:

public static T? LoadFromFile<T>(string path, XmlSerializer? serial = null)
{
    using var stream = File.OpenRead(path);
    return (T?)(serial ?? new XmlSerializer(typeof(T))).Deserialize(stream);
}

You will be able to load your LayoutModel from a file path as follows:

var model = XmlExtensions.LoadFromFile<LayoutModel>(path);

Notes:

• If the polymorphic element names differ from collection to collection, you can apply [XmlElement(string? derivedElementName, Type? type)] to the collection property, instead of [XmlEoot(derivedElementName)] to the derived type, to specify both the polymorphic names and types on a per-collection basis.

• I chose to use the same C# type for identical elements. Thus your HierarchyNodeModel and ComponentNodeModel were replaced with a single LayoutContainerModel.

• If you were provided an XSD for your XML file, then xsd.exe will construct a polymorphic type hierarchy for you as long as the XSD contains <xsd:choice> elements. xsd.exe will not, however, infer a polymorphic type hierarchy from some sample XML file (and will sometimes infer an incorrect type hierarchy when presented with polymorphic XML.)

• For more on XmlSerializer polymorphism, see

  • Using XmlSerializer to serialize derived classes
  • Keep sort when deserialize and serialize XML using XmlSerializer

Demo fiddle here.