Finding all Images in a FlowDocument

Since I am pretty new to WPF FlowDocuments I would like to ask if the code below is correct. It is supposed to return all Images contained in a FlowDocument as List:

List<Image> FindAllImagesInParagraph(Paragraph paragraph)
{
    List<Image> result = null;

    foreach (var inline in paragraph.Inlines)
    {
        var inlineUIContainer = inline as InlineUIContainer;
        if (inlineUIContainer != null)
        {
            var image = inlineUIContainer.Child as Image;

            if (image != null)
            {
                if (result == null)
                    result = new List<Image>();

                result.Add(image);
            }
        }
    }

    return result;
}

private List<Image> FindAllImagesInDocument(FlowDocument Document)
{
    List<Image> result = new List<Image>();

    foreach (var block in Document.Blocks)
    {
        if (block is Table)
        {
            var table = block as Table;

            foreach (TableRowGroup rowGroup in table.RowGroups)
            {
                foreach (TableRow row in rowGroup.Rows)
                {
                    foreach (TableCell cell in row.Cells)
                    {
                        foreach (var block2 in cell.Blocks)
                        {
                            if (block2 is Paragraph)
                            {
                                var paragraph = block2 as Paragraph;
                                var images = FindAllImagesInParagraph(paragraph);
                                if (images != null)
                                    result.AddRange(images);
                            }

                            else if (block2 is BlockUIContainer)
                            {
                                var container = block as BlockUIContainer;
                                if (container.Child is Image)
                                {
                                    var image = container.Child as Image;
                                    result.Add(image);
                                }
                            }
                        }
                    }
                }
            }
        }

        else if (block is Paragraph)
        {
            var paragraph = block as Paragraph;
            var images = FindAllImagesInPar开发者_StackOverflow社区agraph(paragraph);
            if (images != null)
                result.AddRange(images);
        }

        else if (block is BlockUIContainer)
        {
            var container = block as BlockUIContainer;
            if(container.Child is Image)
            {
                var image = container.Child as Image;
                result.Add(image);
            }
        }
    }

    return result.Count > 0 ? result : null;
}

LINQ is just freaking magical:

public IEnumerable<Image> FindImages(FlowDocument document)
{
    return document.Blocks.SelectMany(FindImages);
}

public IEnumerable<Image> FindImages(Block block)
{
    if (block is Table)
    {
        return ((Table)block).RowGroups
            .SelectMany(x => x.Rows)
            .SelectMany(x => x.Cells)
            .SelectMany(x => x.Blocks)
            .SelectMany(FindImages);
    }
    if (block is Paragraph)
    {
        return ((Paragraph) block).Inlines
            .OfType<InlineUIContainer>()
            .Where(x => x.Child is Image)
            .Select(x => x.Child as Image);
    }
    if (block is BlockUIContainer)
    {
        Image i = ((BlockUIContainer) block).Child as Image;
        return i == null
                    ? new List<Image>()
                    : new List<Image>(new[] {i});
    }
    throw new InvalidOperationException("Unknown block type: " + block.GetType());
}

Little change in Code to add coverage for List

    public static IEnumerable<Image> FindImages(FlowDocument document)
    {
        return document.Blocks.SelectMany(block => FindImages(block));
    }

    public static IEnumerable<Image> FindImages(Block block)
    {
        if (block is Table)
        {
            return ((Table)block).RowGroups
                .SelectMany(x => x.Rows)
                .SelectMany(x => x.Cells)
                .SelectMany(x => x.Blocks)
                .SelectMany(innerBlock => FindImages(innerBlock));
        }
        if (block is Paragraph)
        {
            return ((Paragraph)block).Inlines
                .OfType<InlineUIContainer>()
                .Where(x => x.Child is Image)
                .Select(x => x.Child as Image);
        }
        if (block is BlockUIContainer)
        {
            Image i = ((BlockUIContainer)block).Child as Image;
            return i == null
                        ? new List<Image>()
                        : new List<Image>(new[] { i });
        }
        if (block is List)
        {
            return ((List)block).ListItems.SelectMany(listItem => listItem
                                                                  .Blocks
                                                                  .SelectMany(innerBlock => FindImages(innerBlock)));
        }
        throw new InvalidOperationException("Unknown block type: " + block.GetType());
    }

static IEnumerable<T> GetElementsOfType<T>(DependencyObject parent) where T : class
{
   var childElements = LogicalTreeHelper.GetChildren(parent).OfType().ToList();
   return childElements.SelectMany(GetElementsOfType<T>).Union(childElements.OfType<T>());
}
....
var images = GetElementsOfType<Image>(document)

Little change in Code to add coverage for Figure and Floater

public static IEnumerable<Image> FindImages(FlowDocument document)
    {
        return document.Blocks.SelectMany(block => FindImages(block));
    }        

    public static IEnumerable<Image> FindImages(Block block)
    {
        if (block is Paragraph)
        {
            List<Image> toReturn = new List<Image>();
            var check = ((Paragraph)block).Inlines;
            foreach (var i in check)
            {
                if (i is InlineUIContainer)
                {
                    var inlineUiContainer = i as InlineUIContainer;
                    Image image = ((InlineUIContainer)inlineUiContainer).Child as Image;
                    if(image != null)
                    {
                        toReturn.Add(image);
                    }
                }
                else if (i is Figure)
                {
                    var figure = i as Figure;
                    var images = figure.Blocks.SelectMany(blocks => FindImages(blocks));
                    toReturn.AddRange(images);
                }
                else if (i is Floater)
                {
                    var floater = i as Floater;
                    var images = floater.Blocks.SelectMany(blocks => FindImages(blocks));
                    toReturn.AddRange(images);
                }
            }
            return toReturn;               
        }
        if (block is Table)
        {
            return ((Table)block).RowGroups
                .SelectMany(x => x.Rows)
                .SelectMany(x => x.Cells)
                .SelectMany(x => x.Blocks)
                .SelectMany(innerBlock => FindImages(innerBlock));
        }            
        if (block is BlockUIContainer)
        {
            Image i = ((BlockUIContainer)block).Child as Image;
            return i == null
                        ? new List<Image>()
                        : new List<Image>(new[] { i });
        }
        if (block is List)
        {
            return ((List)block).ListItems.SelectMany(listItem => listItem
                                                                  .Blocks
                                                                  .SelectMany(innerBlock => FindImages(innerBlock)));
        }
        throw new InvalidOperationException("Unknown block type: " + block.GetType());
    }