使用 LINQ 对 Xelement 进行排序时遇到问题

Question

I am trying to sort my XML below by the priority node, so the 1.0 is the highest and then they follow after. However everything I try wont return anything. Here is my code, the first chunk was a try I did that is just empty, the second chunk is my inline try that returns a null reference.

First:

 XNamespace ns = "http://www.sitemaps.org/schemas/sitemap/0.9";
            IEnumerable<XElement> list =
                from el in xelementList1.Elements(ns + "url")
                let priority = (int)el.Element(ns + "priority")
                orderby priority descending
                select el;

Second:

XDocument xdocument = this.BuildXmlDocument((IEnumerable<XElement>)xelementList1.OrderByDescending(x => x.Element("priority")?.Value));

Document:

<urlset xmlns:xhtml="http://www.w3.org/1999/xhtml" 
xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<url>
<loc>https:///</loc>
<lastmod>2021-03-15</lastmod>
<changefreq>daily</changefreq>
<priority>0.5</priority>
</url>
<url>
<loc>https:///404/</loc>
<lastmod>2021-04-22</lastmod>
<changefreq>daily</changefreq>
<priority>0.5</priority>
</url>
<url>
<loc>https:///500/</loc>
<lastmod>2021-04-22</lastmod>
<changefreq>daily</changefreq>
<priority>0.5</priority>
</url>
<url>
<loc>https:///avalon-brochures/</loc>
<lastmod>2021-04-27</lastmod>
<changefreq>daily</changefreq>
<priority>1.0</priority>
</url>
<url>
<loc>https:///contact-us/</loc>
<lastmod>2021-04-27</lastmod>
<changefreq>daily</changefreq>
<priority>0.8</priority>
</url>
<url>
<loc>https:///cors-test/</loc>
<lastmod>2021-03-15</lastmod>
<changefreq>daily</changefreq>
<priority>0.5</priority>
</url>

Answer 1

You should separate the process of persisting your data (storage) from the process of handling the data. This makes your code:

• easier to understand, because procedures are smaller
• easier to reuse, because you could use the same data handling if the data didn't come from XML, but for instance from JSON or a database -easier to change: if you want to persist the data in a different format, for instance JSON, or CSV, you won't have to change the LINQ parts
• Easier to unit test: you can test storing / retrieving your data without worrying about the LINQ parts: if in future you change the LINQ (for instance descending order, or order by different column), you won't have to change the unit tests about persistency.

(I'm not sure what's in your XML, In the rest of the answer I'll call this UrlModifications )

So you need two separate parts of code, maybe even separate classes:

• A part that reads the data from an XML file and converts it into a sequence of UrlModifications . Similar: store a sequence of UrlModifications in an XML file. Possible extensions: read/write from a Stream .
• A part that takes a sequence of UrlModifications and orders them by descending priority.

Whether it is worth to make separate classes for this, depends on whether you think someon might want to reuse this code, or change it, or whether you want to write unit tests for it, etc.

Read/Write UrlModifications to a file

First the class UrlModification. I think it will be something like this:

class UrlModification
{
    public string Location {get; set;}
    public DateTime LastModifiedDate {get; set; }
    public FrequencyDescription ChangeFrequency {get; set;}
    public decimal Priority {get; set;}
}

FrequencyDescription is an enum. You can change it to a string, which might give problems if someone types un unsupported value. If you don't want to be limited by values like daily / hourly / weekly /... , consider to use a TimeSpan. Daily will be replaced by 24 hours. You will need a conversion method anyway, because to do anything with this value, you'll need to convert the word Daily into TimeSpan 24 hours .

To Read and Write this to a file, I'll create a repository class (Repository in the sense of a warehouse: you store items in it, and later you can retrieve the same item from it, even if you have restarted the program.

To make the class a bit more reusable, I will not only save it to a file, but also to a Stream and a TextReader / TextWriter. This will also make the unit test easier

class UrlModificationRepository
{
    public IList<UrlModifiction> Load(string fileName)
    {
        using (var textReader = File.OpenText(fileName))
        {
            return Load(textReader);
        }
    }

    public IList<UrlModification> Load(System.IO.TextReader textReader)
    {
        return (UrlModification[]) serializer.Deserialize(textReader);
    }
}

The method for a Stream is similar.

The Save methods are also one-liners:

public void Save(string fileName, IEnumerable<UrlModification> urlModifications)
{
    using (var textWriter = File.CreateText(fileName))
    {
        this.Save(textWriter, urlModifications);
    }
}

public void Save(TextWriter textWriter, IEnumerable<UrlModification> urlModifications)
{
    serializer.Serialize(textWriter, urlModifications.ToArray());
}

This has hidden the format in which you load / save items. You can change it in JSON format, or even CSV. Users (=software, not operators) won't notice the difference.

If you unit test this, you will see that the XML format is not exactly the same format as yours. The easiest way to repair this is to add XML attributes to your class:

public class UrlModification
{
    [XmlElement("Loc")]
    public string Location { get; set; }

    [XmlElement("LastMod", DataType = "date")]
    public DateTime LastModifiedDate { get; set; }
    public FrequencyDescription ChangeFrequency { get; set; }
    public decimal Priority { get; set; }
}

You probably know XML better than I do, so I guess you'll get the gist.

Order the URL

I am trying to sort my XML below by the priority node, so the 1.0 is the highest and then they follow after.

Once you've created the repository, this will be very easy:

string fileName = ...
UrlModificationRepository repository = new UrlModidificationRepository();

var urlsOrderedByDescendingPriority = repository.Load(fileName)
    .OrderByDescending(urlModification => urlModification.Priority);

Conclusion

By separating how the data is stored from the data processing, you made the code easier to understand and unit test. The code is highly reusable and changeable.