EF Core 使用 FromSql 调用存储过程抛出 InvalidOperationException

问题描述 投票：0回答：1

我正在使用 EF Core 7 并尝试使用以下代码调用存储过程，但 EF Core 查询生成器抛出异常。 我正在使用MS Docs中的语法，并且我已经检查了这些其他示例，但我只是不明白为什么我的代码失败了

我的代码：

SqlParameter casinoState = new SqlParameter("CasinoState", casinoStateFilter);
SqlParameter isActive = new SqlParameter("IsActive", isActiveFilter);
SqlParameter prohibitedCountry = new SqlParameter("ProhibitedCountry", prohibitedCountryFilter);
SqlParameter softwareProviderId = new SqlParameter("SoftwareProviderId", softwareProviderFilter);
SqlParameter casinoName = new SqlParameter("CasinoName", casinoNameFilter);

FormattableString sql = $"exec CasinoIdSerach @CasinoState={casinoStateFilter}, @IsActive={isActive}, @ProhibitedCountry={prohibitedCountryFilter}, @SoftwareProviderId={softwareProviderFilter}, @CasinoName={casinoNameFilter}"; 
var casinos = _context.Casinos.FromSql<Domain.Casino>(sql).ToList();

我也尝试了

_context.Casinos.FromSql(sql).ToList();
，结果相同

例外情况

System.InvalidOperationException：调用了“FromSql”或“SqlQuery” 使用不可组合的 SQL 和在其上组合的查询。考虑 在执行组合的方法之后调用“AsEnumerable” 客户端。'

这是来自 MS 的示例代码，我不明白为什么这会起作用，但我的却不起作用

var user = new SqlParameter("user", "johndoe");

var blogs = context.Blogs
    .FromSql($"EXECUTE dbo.GetMostPopularBlogsForUser @filterByUser={user}")
    .ToList();

我尝试了 SQL 字符串的一些变体，例如

  • FormattableString sql = $"exec CasinoSearch @CasinoName='%test%'";
  • FormattableString sql = $"select * from Casino";

现在，第二个执行没有异常，但显然查询不是我想要的

我已成功将以下内容与存储过程一起使用，但此示例不需要返回数据集

int result = _context.Database.ExecuteSqlRaw(query, parameters.ToArray());

更新 根据要求，这是我在 

Casino
事件
中的
OnModelCreating

配置 
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
   modelBuilder.ApplyConfiguration(new Configurations.CasinoConfiguration());
...
}

public class CasinoConfiguration : IEntityTypeConfiguration<Casino>
{
    public void Configure(EntityTypeBuilder<Casino> modelBuilder)
    {
        modelBuilder.ToTable("Casino");
        modelBuilder.ToTable(tb => tb.HasTrigger("TR_upd_Casino"));
    
        modelBuilder.Ignore(c => c.EWalletWithdrawalTurnaround);
        modelBuilder.Ignore(c => c.CreditAndDebitCardWithdrawalTurnaround);
        modelBuilder.Ignore(c => c.BankTransferWithdrawalTurnaround);
        modelBuilder.Ignore(c => c.CheckWithdrawalTurnaround);
    
        modelBuilder.HasMany(c => c.Bonuses)
            .WithOne(b => b.Casino)
            .OnDelete(DeleteBehavior.Cascade);
    
        modelBuilder.HasMany(c => c.WebsiteCasinoReviewBonuses)
            .WithOne(w => w.Casino)
            .OnDelete(DeleteBehavior.Cascade);
    
        modelBuilder.HasMany(c => c.Promotions);
        modelBuilder.HasMany(c => c.CasinoGameTypes);
    
        modelBuilder.HasMany(c => c.AvailableCurrencies)
                .WithOne(cc => cc.Casino)
                .HasConstraintName("FK_CasinoCurrency_Casino");
    
        modelBuilder.HasMany(c => c.CompatibleOperatingSystems)
            .WithOne(cc => cc.Casino)
            .HasConstraintName("FK_CasinoOperatingSystem_Casino");
    
        modelBuilder.HasMany(c => c.CasinoSoftwareProviders)
            .WithOne(b => b.Casino)
            .HasConstraintName("FK_CasinoSoftwareProvider_Casino");
                
        modelBuilder.OwnsMany(c => c.Alerts)
            .ToTable("CasinoAlert");
    
        modelBuilder
            .HasMany(a => a.Languages)
            .WithOne(l => l.Casino)
            .HasConstraintName("FK_CasinoLanguage_Casino")
            .OnDelete(DeleteBehavior.Cascade);
    
        modelBuilder
            .HasMany(c => c.TrackerLinks)
            .WithOne(t => t.Casino)
            .HasConstraintName("FK_CasinoTrackerLink_Casino")
            .OnDelete(DeleteBehavior.Cascade);
    
        #region Intersect tables
    
        modelBuilder
            .HasMany(a => a.BankingProviders)
            .WithMany(b => b.Casinos)
            .UsingEntity<Dictionary<string, object>>(
                "Casino_BankingProvider",
                j => j
                    .HasOne<BankingProvider>()
                    .WithMany()
                    .HasForeignKey("BankingProviderId"),
                j => j
                    .HasOne<Casino>()
                    .WithMany()
                    .HasForeignKey("CasinoId")
            );
    
        modelBuilder
            .HasMany(a => a.BettingMarkets)
            .WithMany(b => b.Casinos)
            .UsingEntity<Dictionary<string, object>>(
                "Sportsbook_BettingMarket",
                j => j
                    .HasOne<BettingMarket>()
                    .WithMany()
                    .HasForeignKey("BettingMarketId"),
                j => j
                    .HasOne<Casino>()
                    .WithMany()
                    .HasForeignKey("CasinoId")
            );
    
    
        modelBuilder
            .HasMany(a => a.BettingSports)
            .WithMany(b => b.Casinos)
            .UsingEntity<Dictionary<string, object>>(
                "Sportsbook_BettingSport",
                j => j
                    .HasOne<BettingSport>()
                    .WithMany()
                    .HasForeignKey("BettingSportId"),
                j => j
                    .HasOne<Casino>()
                    .WithMany()
                    .HasForeignKey("CasinoId")
            );
    
        modelBuilder
            .HasMany(a => a.BettingTournamentLeagues)
            .WithMany(b => b.Casinos)
            .UsingEntity<Dictionary<string, object>>(
                "Sportsbook_BettingTournamentLeague",
                j => j
                    .HasOne<BettingTournamentLeague>()
                    .WithMany()
                    .HasForeignKey("BettingTournamentLeagueId"),
                j => j
                    .HasOne<Casino>()
                    .WithMany()
                    .HasForeignKey("CasinoId")
            );
    
        modelBuilder
            .HasMany(a => a.Jurisdictions)
            .WithMany(b => b.Casinos)
            .UsingEntity<Dictionary<string, object>>(
                "Casino_Jurisdiction",
                j => j
                    .HasOne<Jurisdiction>()
                    .WithMany()
                    .HasForeignKey("JurisdictionId"),
                j => j
                    .HasOne<Casino>()
                    .WithMany()
                    .HasForeignKey("CasinoId")
            );
    
        modelBuilder
            .HasMany(a => a.AllowedCountries)
            .WithMany(b => b.AllowedCasinos)
            .UsingEntity<Dictionary<string, object>>(
                "Casino_Allowed_Country",
                j => j
                    .HasOne<Country>()
                    .WithMany()
                    .HasForeignKey("CountryId"),
                j => j
                    .HasOne<Casino>()
                    .WithMany()
                    .HasForeignKey("CasinoId")
            );
    
        modelBuilder
            .HasMany(a => a.ProhibitedCountries)
            .WithMany(b => b.ProhibitedCasinos)
            .UsingEntity<Dictionary<string, object>>(
                "Casino_Prohibited_Country",
                j => j
                    .HasOne<Country>()
                    .WithMany()
                    .HasForeignKey("CountryId"),
                j => j
                    .HasOne<Casino>()
                    .WithMany()
                    .HasForeignKey("CasinoId")
            );
    
        modelBuilder
            .HasMany(a => a.SportsbookProhibitedCountries)
            .WithMany(b => b.ProhibitedSportsbooks)
            .UsingEntity<Dictionary<string, object>>(
                "Sportsbook_Prohibited_Country",
                j => j
                    .HasOne<Country>()
                    .WithMany()
                    .HasForeignKey("CountryId"),
                    j => j
                        .HasOne<Casino>()
                        .WithMany()
                        .HasForeignKey("CasinoId")
            );
    
        modelBuilder
            .HasMany(a => a.CasinoAllowedUSStates)
            .WithMany(b => b.AllowedCasinos)
            .UsingEntity<Dictionary<string, object>>(
                "Casino_Allowed_USState",
                j => j
                    .HasOne<USState>()
                    .WithMany()
                    .HasForeignKey("USStateId"),
                j => j
                    .HasOne<Casino>()
                    .WithMany()
                    .HasForeignKey("CasinoId")
            );
    
        modelBuilder
            .HasMany(a => a.SportsbookAllowedUSStates)
            .WithMany(b => b.AllowedSportsbooks)
            .UsingEntity<Dictionary<string, object>>(
                "Sportsbook_Allowed_USState",
                j => j
                    .HasOne<USState>()
                    .WithMany()
                    .HasForeignKey("USStateId"),
                j => j
                    .HasOne<Casino>()
                    .WithMany()
                    .HasForeignKey("CasinoId")
            );
    
        #endregion
    
    }
}
c# sql-server entity-framework
1个回答
0
投票

在你的模型中，你有

modelBuilder.OwnsMany(c => c.Alerts)
            .ToTable("CasinoAlert");

这是一个拥有的实体类型。这是始终包含在内的子类型。因此，就好像您所做的每个查询（包括 

FromSql
）总是隐含地具有：

.Include(c => c.Alerts)

您无法在 

EXEC
上进行创作，因此隐式 
Include
不起作用。

将您的模型更改为：

modelBuilder.HasMany(c => c.Alerts);
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.