Как правильно разбить код на разделы в функциональной библиотеке C#?

Примечание: если вы хотите более короткий, более-к-пункту ответ, см. Мой другой ответ. Я знаю, что этот здесь может кажется, бродить и идти дальше навсегда и говорить мимо вашей проблемы, но, возможно, это даст вам несколько идей.

трудно ответить на ваш вопрос, не зная точного отношения между Animal и Skeleton. Я сделаю рекомендацию об этих отношениях во второй половине моего ответа, но прежде чем я это сделаю, я просто соглашусь с тем, что вижу на вашем посту.

сначала я попытаюсь вывести несколько вещей из вашего кода:

static class AnimalTopology
{
    // Note: I made this function `static`... or did you omit the keyword on purpose?
    static IEnumerable<Animal> ListVertebrated(Func<Skeleton, bool> selector)
    {
        …
    }
}

1. если вы разработали эту функцию в соответствии с функциональными принципами, она не должна иметь побочных эффектов. То есть его вывод зависит только от его аргументов. (И в полу-объектно-ориентированное задание, возможно, на другие статические члены AnimalTopology; но так как вы ничего не показали, давайте проигнорируем это возможность.)

2. если функция действительно свободна от побочных эффектов (и не имеет доступа к статическим членам AnimalTopology), то сигнатура типа функции предполагает, что можно получить Animal С Skeleton, потому что он принимает то, что действует на Skeletons и возвращает Animals.

3. если это также верно, то позвольте мне предположить следующее ради возможности дать ответ:

   class Skeleton
   {
       …
       public Animal Animal { get { … } } // Skeletons have animals!? We'll get to that.
   }
   

теперь очевидно, что функцию невозможно реализовать, так как это может вывести AnimalС Skeletons, но он не получает никаких Skeleton вообще; он получает только функцию предиката, которая действует на Skeleton. (Вы можете исправить это, добавив второй параметр типа Func<IEnumerable<Skeleton>> getSkeletons, но...)

на мой взгляд, что-то вроде следующего бы больше смысла:

static IEnumerable<Animal> GetVertebrates(this IEnumerable<Skeleton> skeletons,
                                          Func<Skeleton, bool> isVertebrate)
{
    return skeletons
           .Where(isVertebrate)
           .Select(s => s.Animal);
}

теперь можно задаться вопросом почему вы угадываете животных из их скелетов; и это не bool свойство "является ли позвоночное" неотъемлемым свойством животного (или скелета)? Есть ли действительно несколько способов решить это?

я бы предложил следующее:

class Animal
{
     Skeleton Skeleton { get; } // not only vertebrates have skeletons! 
}

class Vertebrate : Animal { … } // vertebrates are a kind of animal 

static class AnimalsExtensions
{
    static IEnumerable<Vertebrate> ThatAreVertebrates(this IEnumerable<Animal> animals)
    {
        return animals.OfType<Vertebrate>();
    }
}

обратите внимание на использование методов расширения выше. Вот пример, как его использовать:

List<Animal> animals = …;
IEnumerable<Vertebrate> vertebrates = animals.ThatAreVertebrates();

теперь предположим, что ваш метод расширения делали более сложную работу. В таком случае, было бы неплохо поставить он внутри своего собственного обозначенного "типа алгоритма":

interface IVertebrateSelectionAlgorithm
{
    IEnumerable<Vertebrate> GetVertebrates(IEnumerable<Animal> animals);
}

это имеет то преимущество ,что его можно настроить / параметризовать, например, с помощью конструктора класса; и вы можете разделить алгоритм на несколько методов, которые все находятся в одном классе (но все private за исключением GetVertebrates.)

конечно, вы можете сделать такую же параметризацию с функциональными замыканиями, но, по моему опыту, это быстро становится грязным в настройке c#. Здесь занятия-хорошее средство сгруппировать набор функций как одну логическую сущность.