Почему здесь допустимо размещение лямбда-выражения внутри вызова функции?

Да modelBuilder.Entity<Customer> это функция с такой подписью Entity<TEntity>(Action<EntityTypeBuilder<TEntity>>) поэтому в основном она принимает другую "функцию" (здесь это действие делегата)

Из документации:

Эта перегрузка позволяет настроить тип объекта в строка в вызове метода, а не цепочка после вызова Entity<TEntity>(). Это позволяет дополнительную настройку модели уровень для привязки после настройки типа сущности.

Таким образом, это в основном настраивает сущность, которую вы передали.

entity это имя параметра EntityTypeBuilder<TEntity> это не free переменная. Этот параметр будет передан внутри лямбды, указанной вами во время выполнения EF.

Здесь с помощью e => e.Name вы выбираете, какое свойство вы хотите изменить.

entity.Property(e => e.Name).IsRequired();

modelBuilder.Entity<Customer> Это вызов функции

Это просто перегруженный метод/конфигурация типа объекта, который принимает действие или функцию в качестве делегата.

В более ранней версии EF мы делаем это с помощью цепочки:

modelBuilder.Entity<Customer>().ToTable("Customer").Property(e => e.Name).IsRequired();

То же самое и с

modelBuilder.Entity<Customer>(entity =>
{
    entity.ToTable("Customer");
    entity.Property(e => e.Name).IsRequired(); // Column is not nullable
});

Но, как говорится в документации, это позволяет нам добавить дополнительную конфигурацию на уровне модели, которая будет связана после конфигурации для типа сущности.

Но, как правило, он делает то же самое, он настраивает модель, которая была обнаружена из типов сущностей, представленных в свойствах DBSet: ваша сущность Customer находится в таблице Customer из вашей базы данных, и требуется свойство Name.

Чтобы лучше понять и ответить на ваши вопросы № 1 и № 2, подумайте об этом:

Action<EntityTypeBuilder<Customer>> expression = (entity =>
{
    entity.ToTable("Customer");
    entity.Property(e => e.Name).IsRequired(); // Column is not nullable
});

modelBuilder.Entity<Customer>(expression);

Метод Entity ожидает делегата, лямбда-выражение просто используется для создания делегата Action.

Я не самый продвинутый парень в дотнете, но с точки зрения нуба я отвечу на то, что вы хотите, простой фразой: Scaffolding это пример мой друг

1. строительные леса

Когда мы используем скаффолдинг с командной строкой, EntityFramework генерирует в вашем файле контекста этот фрагмент кода.

2. После генерации кода командой

Здесь modelBuilder.Entity — это набор DBSet, который я объявил AOC в своем файле контекста.

Теперь объект представляет собой таблицу, которую я создал в своем локальном SQL, и хочу, чтобы она была создана здесь, в коде (сначала ревер-инжиниринг базы данных, а затем код)

Свойство (e => e.Opt)
Свойство означает доступ к свойствам, которые у вас есть в вашей таблице
e => e.Opt : выражение ссылки означает, что этот объект AOC (таблица) modelBuilder.Entity<Customer> конфигурация данной сущности/таблицы Customer

 modelBuilder.Entity<AOC>(entity =>
            {
                entity.ToTable("AOC");

                entity.Property(e => e.Opt)
                    .HasMaxLength(2)
                    .IsUnicode(false);

            });

Подпись метода (modelBuilder.Entity<Customer>) следующая (Источник: MSDN):

public virtual Microsoft.EntityFrameworkCore.ModelBuilder Entity<TEntity> (Action<Microsoft.EntityFrameworkCore.Metadata.Builders.EntityTypeBuilder<TEntity>> buildAction) where TEntity : class;

Для нас актуален аргумент buildAction. Это тип Action<EntityTypeBuilder<TEntity>>.

Action<T>определяется какpublic delegate void Action<in T>(T obj);

Это означает, что Action — это просто функция, которая принимает аргумент типа T и ничего не возвращает.

С лямбда-выражениями мы можем создавать анонимные функции, поэтому с entity => { ... } мы просто создаем анонимную функцию, которая принимает аргумент, который мы решили назвать entity, и его областью действия будет тело нашего выражения (итак, что внутри {...}) .

Тип аргумента entity выводится компилятором, поскольку он знает, что, как указано выше, аргумент modelBuilder.Entity<Customer> — это Action<EntityTypeBuilder<TEntity>>. Итак, entity будет экземпляром EntityTypeBuilder<TEntity>, поэтому мы можем использовать такие методы, как ToTable

С Property(e => e.Name) все немного сложнее... Сигнатура метода следующая (Источник: MSDN):

public virtual Microsoft.EntityFrameworkCore.Metadata.Builders.PropertyBuilder<TProperty> Property<TProperty> (System.Linq.Expressions.Expression<Func<TEntity,TProperty>> propertyExpression);

Опять же, для нас важен аргумент propertyExpression. Это тип Expression<Func<TEntity,TProperty>>.

Это означает, что это Выражение , описывающее функцию (очень похожую на Действие, описанное выше, но вместо того, чтобы ничего не возвращать, оно возвращает значение), которая принимает аргумент (который в нашем случае мы произвольно называем e ) типа TEntity и возвращает значение типа TProperty.

И TEntity, и TProperty выводятся компилятором: мы сказали выше, что entity является экземпляром EntityTypeBuilder<TEntity>, поэтому вывод, сделанный выше компилятором для определения TEntity, все еще действителен, потому что мы вызываем метод экземпляра entity.

TProperty выводится из лямбда-выражения e => e.Name. Это выражение эквивалентно e => { return e.Name; }.

По сути, это лямбда-выражение представляет собой функцию, которая принимает экземпляр Customer и возвращает его свойство Name. В определении класса Customer мы объявили Name как строку, поэтому компилятор знает, что TProperty — это string.

Но помните, что параметр, который мы передаем методу Property(Property(e => e.Name)), — это просто Expression, а не функция. По сути, код e.Name никогда не будет запущен, потому что это не скомпилированная функция. Компилятор выдаст дерево выражений, описывающее то, что мы на самом деле написали (см. раздел «Примечания» класса Expression ).

Затем Entity Framework проанализирует выражение, чтобы определить свойство вашего класса, которое необходимо отобразить в модели.