[C#] Berekening op stukje uit XML-bestand en overschrijven.

[Anoniem: 122357]

Ik heb een stuk XML, dit komt uit een applicatie dus ik kan niets doen aan de opmaak. Ik wil de attributen uitlezen, een berekening toepassen en daarna de uitkomt, de huidige waarden laten overschrijven.

De waarden in elke LineTo-rij vormen de coordinaten van de hoekpunten van een rechthoek, ik moet een bekerening toepassen op de gehele rechthoek, de nieuwe coordinaten terugschrijven naar de XML.
Voor de berekening heb ik dus de waarden nodig van meerdere attributen tegelijk. Dus een waarde van bijvoorbeeld de eerste X + 5 en weer opslaan gaat niet.

Het aantal MoveTo met de bijbehorende 4 LineTo nodes kan varrieren. In dit voorbeeld staan de coordinaten van 2 rechthoeken, dus kunnen er bijvoorbeeld ook 1 of 3 zijn.

In het laatste CODE-blok zien jullie dat ik de XML uitlees en via de switch de type regels kan onderscheiden in MoveTo en LineTo. Zodra ik 1 x een MoveTo heb, kan ik wel nog 4 x door de loop gaan en de LineTo waarden (als double) ophalen. De berekening op alles toepassen, een nieuwe stuk text maken in de vorm van een string die er dat uitziet als het huidige stuk XML maar dan met de nieuwe coordinaten.

Hiermee sla ik natuurlijk helemaal de plank mis, wanneer ik dit in een string doe. Hoe kan ik dit het beste aanpakken? En hoe vervang ik dan de oude Outline Node in mijn bestand met de nieuwe?

(De berekening zelf is verder geen probleem.)

XML:

<Outline>
    <MoveTo X="1344.64" Y="2576.58"/>
    <LineTo X="1344.64" Y="1299.01"/>
    <LineTo X="11.43" Y="1299.01"/>
    <LineTo X="11.43" Y="2576.58"/>
    <LineTo X="1344.64" Y="2576.58"/>
    <MoveTo X="1344.64" Y="1289.01"/>
    <LineTo X="1344.64" Y="11.43"/>
    <LineTo X="11.43" Y="11.43"/>
    <LineTo X="11.43" Y="1289.01"/>
    <LineTo X="1344.64" Y="1289.01"/>
    <Method Type="Thru-cut"/>
</Outline>

Dit haal ik netjes op via:

C#:

            string fileName = @"..\..\..\..\test.zcc";

            xmlDoc.Load(fileName);

            XmlNodeList outlineNodes = xmlDoc.SelectNodes("/ZCC_cmd/Job/Geometry/Outline/*");

            foreach (XmlNode outlineNode in outlineNodes)
            {
                nodeName = outlineNode.Name;
                
                if (outlineNode.Name != "Method")
                {
                    x = Convert.ToDouble(outlineNode.Attributes["X"].Value);
                    y = Convert.ToDouble(outlineNode.Attributes["Y"].Value);
                    Console.WriteLine("nodeName.Name: " + nodeName + " X: " + x + " Y: " + y);
                }

                switch (nodeName)
                {
                    case "MoveTo":

                        // Doe iets
                        break;
                    case "LineTo":

                        // Doe iets
                        break;
                    default:
                        break;
                }

            }
}

[jip_86]

Hiermee sla ik natuurlijk helemaal de plank mis, wanneer ik dit in een string doe.

Hoezo sla je de plank mis? Inlezen, bewerken en weer wegschrijven naar het bestand zal toch de richting moeten zijn die je zal moeten volgen.

[Damic]

Je moet maar 3 lijnen inlezen na de MoveTo, als het recht hoeken zijn

[ Voor 26% gewijzigd door Damic op 25-01-2015 18:08 . Reden: *disclamier er bij gezet ]

[Anoniem: 122357]

jip_86 schreef op zondag 25 januari 2015 @ 15:52:
[...]

Hoezo sla je de plank mis? Inlezen, bewerken en weer wegschrijven naar het bestand zal toch de richting moeten zijn die je zal moeten volgen.

Nou, ik dacht dat het misschien beter zou zijn om met XML-objecten te werken dan met een string. Ik weet alleen niet welke. Ook omdat de opmaak, volgens mij, van het deel XML waar het hier om gaat ook niet echt netjes is opgemaakt. In de node <Outline> staan nu verschillende outline achter elkaar. Volgens mij was het netter geweest als het was als volgd:

XML:

<Outlines>
    <Outline>
        <MoveTo X="1344.64" Y="2576.58"/>
        <LineTo X="1344.64" Y="1299.01"/>
        <LineTo X="11.43" Y="1299.01"/>
        <LineTo X="11.43" Y="2576.58"/>
        <LineTo X="1344.64" Y="2576.58"/>
    </Outline>
    <Outline>
        ...
    </Outline>
    <Method Type="Thru-cut"/>
</Outlines>

Maar dat terzijde... Zou dit dus niet mooier kunnen met XML-objecten?

[Anoniem: 122357]

Damic schreef op zondag 25 januari 2015 @ 17:33:
Je moet maar 3 lijnen inlezen na de MoveTo, als het recht hoeken zijn

Dan zou ik in theorie maar 2 regels uit hoeven lezen, de hoekpunten van 1 diagonaal. Maar dat is verder niet relevant voor mijn vraag.

[jark86]

Je kunt zonder problemen het XmlDocument veranderen, en opslaan met de xml api.

De outlineNode.Attributes["Y"].Value heeft namelijk ook een setter, dus ken gewoon de nieuwe waarde weer aan de value toe, nadat je alle aanpassingen hebt gedaan kun je het naar schijf schrijven met xmlDoc.Save methode.