Un autre LINQ to XML (conversion de C# à VB.NET)

Question

Quelle est la syntaxe VB.NET pour cela ? Toute aide à la conversion serait grandement appréciée.

        var defaultStyleName = (string)doc
            .MainDocumentPart
            .StyleDefinitionsPart
            .GetXDocument()
            .Root
            .Elements(w + "style")
            .Where(style =>
                (string)style.Attribute(w + "type") == "paragraph" &&
                (string)style.Attribute(w + "default") == "1")
            .First()
            .Attribute(w + "styleId");

        var q1 = doc
            .MainDocumentPart
            .GetXDocument()
            .Root
            .Element(w + "body")
            .Elements()
            .Select((p, i) =>
            {
                var styleNode = p
                    .Elements(w + "pPr")
                    .Elements(w + "pStyle")
                    .FirstOrDefault();
                var styleName = styleNode != null ?
                    (string)styleNode.Attribute(w + "val") :
                    defaultStyleName;
                return new
                {
                    Element = p,
                    Index = i,
                    StyleName = styleName
                };
            }
            );

        var q2 = q1
            .Select(i =>
            {
                string text = null;
                if (i.Element.Name == w + "p")
                    text = i.Element.Elements()
                        .Where(z => z.Name == r || z.Name == ins)
                        .Descendants(w + "t")
                        .StringConcatenate(element => (string)element);
                else
                    text = i.Element
                        .Descendants(w + "p")
                        .StringConcatenate(p => p
                            .Elements()
                            .Where(z => z.Name == r || z.Name == ins)
                            .Descendants(w + "t")
                            .StringConcatenate(element => (string)element),
                            Environment.NewLine
                        );

                return new
                {
                    Element = i.Element,
                    StyleName = i.StyleName,
                    Index = i.Index,
                    Text = text
                };
            }
            );

        var q3 = q2
            .Select(i =>
                new Commands.MatchInfo
                {
                    ElementNumber = i.Index + 1,
                    Content = i.Text,
                    Style = ContainsAnyStyles(GetAllStyleIdsAndNames(doc, i.StyleName).Distinct(), styleSearchString),
                    Pattern = ContainsAnyContent(i.Text, contentSearchString, regularExpressions, isRegularExpression, caseInsensitive),
                    IgnoreCase = caseInsensitive
                }
            )
            .Where(i => (styleSearchString == null || i.Style != null) && (contentSearchString == null || i.Pattern != null));
        return q3.ToArray();

Answer 1

Dans ce cas, il est préférable d'utiliser un outil et de réparer ensuite ce que l'outil a manqué. Dans ce cas, j'ai utilisé convertisseur de code .net pour obtenir ce résultat :

Dim defaultStyleName = DirectCast(doc.MainDocumentPart.StyleDefinitionsPart.GetXDocument().Root.Elements(w & "style").Where(Function(style) DirectCast(style.Attribute(w & "type"), String) = "paragraph" AndAlso DirectCast(style.Attribute(w & "default"), String) = "1").First().Attribute(w & "styleId"), String)

Dim q1 = doc.MainDocumentPart.GetXDocument().Root.Element(w & "body").Elements().[Select](Function(p, i) Do
    Dim styleNode = p.Elements(w & "pPr").Elements(w & "pStyle").FirstOrDefault()
    Dim styleName = If(styleNode IsNot Nothing, DirectCast(styleNode.Attribute(w & "val"), String), defaultStyleName)
    Return New ()
End Function)

Dim q2 = q1.[Select](Function(i) Do
    Dim text As String = Nothing
    If i.Element.Name = w & "p" Then
        text = i.Element.Elements().Where(Function(z) z.Name = r OrElse z.Name = ins).Descendants(w & "t").StringConcatenate(Function(element) DirectCast(element, String))
    Else
        text = i.Element.Descendants(w & "p").StringConcatenate(Function(p) p.Elements().Where(Function(z) z.Name = r OrElse z.Name = ins).Descendants(w & "t").StringConcatenate(Function(element) DirectCast(element, String)), Environment.NewLine)
    End If
    
    Return New ()
End Function)

Dim q3 = q2.[Select](Function(i) New Commands.MatchInfo()).Where(Function(i) (styleSearchString Is Nothing OrElse i.Style IsNot Nothing) AndAlso (contentSearchString Is Nothing OrElse i.Pattern IsNot Nothing))
Return q3.ToArray()

Encore une fois, le code n'est probablement pas parfait, mais il devrait vous permettre d'atteindre 95 % de vos objectifs. Le compilateur devrait vous aider pour le reste.

Answer 2

Pour la première, voici une façon de la réécrire en VB :

Dim defaultStyleName = (from style in _
    doc.MainDocumentPart.StyleDefinitionsPart.GetXDocument().Root.Elements(w & "style") _
    where style.Attribute(w & "type").Value = "paragraph" AndAlso _
          style.Attribute(w & "default").Value = "1" _
    select style).First().Attribute(w & "styleId").Value

Mais ce n'est pas si différent de ce que vous feriez en C#.

En VB.NET, vous pouvez également utiliser le @ pour les attributs, comme dans l'exemple suivant style.@AttributeName qui vous donne la valeur de la chaîne de l'attribut, mais je ne suis pas sûr de savoir comment cela fonctionnerait avec vos noms d'attributs concaténés.

Il est également possible d'accéder aux éléments via .<elementName> mais là encore, vos noms concaténés pourraient ne pas fonctionner avec cette syntaxe.

En général, les DirectCast qui sont produits par les outils de conversion en ligne peuvent être éliminés en VB.

Pour une excellente introduction à la façon dont VB.NET utilise LINQ to XML, consultez la page suivante Série vidéo "How Do I" par Beth Massi .