varsayılan MVC4 uygulamaya yeni kullanıcılar Bir bilete başvurumun giriş yaptığını kullanıcıyı atamak çalışıyorum benim denetleyicileri birinde

Question

kaydedilemiyor Bu hatayı olsun MVC uygulamasını varsayılan

gerekli providerName özelliğini içermez uygulamanın yapılandırma dosyasında

bağlantı dizesi 'DefaultConnection'."

Oldukça eminim çünkü "UserContext" (Kullanıcı ismlerim ve şifrelerimin DB'si ile bağlantı) arasında bağlantı kurmadım. Veritabanları \ Bağlam \ Tablolar altında "SQL SerVer Nesne Gezgini" bölümünde daha önce görmüştüm ama şu an kayıp. InitializeSimpleMemberShipAttribute.cs

using System; 
using System.Data.Entity; 
using System.Data.Entity.Infrastructure; 
using System.Threading; 
using System.Web.Mvc; 
using WebMatrix.WebData; 
using RecreationalServicesTicketingSystem.Models; 

namespace RecreationalServicesTicketingSystem.Filters 
{ 
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false, Inherited = true)] 
    public sealed class InitializeSimpleMembershipAttribute : ActionFilterAttribute 
    { 
     private static SimpleMembershipInitializer _initializer; 
     private static object _initializerLock = new object(); 
     private static bool _isInitialized; 

     public override void OnActionExecuting(ActionExecutingContext filterContext) 
     { 
      // Ensure ASP.NET Simple Membership is initialized only once per app start 
      LazyInitializer.EnsureInitialized(ref _initializer, ref _isInitialized, ref _initializerLock); 
     } 

     private class SimpleMembershipInitializer 
     { 
      public SimpleMembershipInitializer() 
      { 
       Database.SetInitializer<UsersContext>(null); 

       try 
       { 
        using (var context = new UsersContext()) 
        { 
         if (!context.Database.Exists()) 
         { 
          // Create the SimpleMembership database without Entity Framework migration schema 
          ((IObjectContextAdapter)context).ObjectContext.CreateDatabase(); 
         } 
        } 

        WebSecurity.InitializeDatabaseConnection("DefaultConnection", "UserProfile", "UserId", "UserName", autoCreateTables: true); 
       } 
       catch (Exception ex) 
       { 
        throw new InvalidOperationException("The ASP.NET Simple Membership database could not be initialized. For more information, please see http://go.microsoft.com/fwlink/?LinkId=256588", ex); 
       } 
      } 
     } 
    } 
} 

Web.config \

Line 32:      using (var context = new UsersContext()) 
Line 33:      { 
Line 34:       if (!context.Database.Exists()) <--- ERROR HERE 
Line 35:       { 
Line 36:        // Create the SimpleMembership database without Entity Framework migration schema 

Filtreler

<?xml version="1.0" encoding="utf-8"?> 
<!-- 
    For more information on how to configure your ASP.NET application, please visit 
    http://go.microsoft.com/fwlink/?LinkId=169433 
    --> 
<configuration> 
    <configSections> 
    <section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" /> 
    <!-- For more information on Entity Framework configuration, visit http://go.microsoft.com/fwlink/?LinkID=237468 --> 
    </configSections> 
    <connectionStrings> 
    <add name="DefaultConnection" connectionString="Data Source=.\SQLEXPRESS;Integrated Security=True;Connect Timeout=15;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False" /> 
    </connectionStrings> 
    <appSettings> 
    <add key="webpages:Version" value="2.0.0.0" /> 
    <add key="webpages:Enabled" value="false" /> 
    <add key="PreserveLoginUrl" value="true" /> 
    <add key="ClientValidationEnabled" value="true" /> 
    <add key="UnobtrusiveJavaScriptEnabled" value="true" /> 
    </appSettings> 
    <system.web> 
    <compilation debug="true" targetFramework="4.0" /> 
    <httpRuntime targetFramework="4.5" /> 
    <authentication mode="Forms"> 
     <forms loginUrl="~/Account/Login" timeout="2880" /> 
    </authentication> 
    <pages> 
     <namespaces> 
     <add namespace="System.Web.Helpers" /> 
     <add namespace="System.Web.Mvc" /> 
     <add namespace="System.Web.Mvc.Ajax" /> 
     <add namespace="System.Web.Mvc.Html" /> 
     <add namespace="System.Web.Optimization" /> 
     <add namespace="System.Web.Routing" /> 
     <add namespace="System.Web.WebPages" /> 
     </namespaces> 
    </pages> 
    </system.web> 
    <system.webServer> 
    <validation validateIntegratedModeConfiguration="false" /> 
    <handlers> 
     <remove name="ExtensionlessUrlHandler-ISAPI-4.0_32bit" /> 
     <remove name="ExtensionlessUrlHandler-ISAPI-4.0_64bit" /> 
     <remove name="ExtensionlessUrlHandler-Integrated-4.0" /> 
     <add name="ExtensionlessUrlHandler-ISAPI-4.0_32bit" path="*." verb="GET,HEAD,POST,DEBUG,PUT,DELETE,PATCH,OPTIONS" modules="IsapiModule" scriptProcessor="%windir%\Microsoft.NET\Framework\v4.0.30319\aspnet_isapi.dll" preCondition="classicMode,runtimeVersionv4.0,bitness32" responseBufferLimit="0" /> 
     <add name="ExtensionlessUrlHandler-ISAPI-4.0_64bit" path="*." verb="GET,HEAD,POST,DEBUG,PUT,DELETE,PATCH,OPTIONS" modules="IsapiModule" scriptProcessor="%windir%\Microsoft.NET\Framework64\v4.0.30319\aspnet_isapi.dll" preCondition="classicMode,runtimeVersionv4.0,bitness64" responseBufferLimit="0" /> 
     <add name="ExtensionlessUrlHandler-Integrated-4.0" path="*." verb="GET,HEAD,POST,DEBUG,PUT,DELETE,PATCH,OPTIONS" type="System.Web.Handlers.TransferRequestHandler" preCondition="integratedMode,runtimeVersionv4.0" /> 
    </handlers> 
    </system.webServer> 
    <runtime> 
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1"> 
     <dependentAssembly> 
     <assemblyIdentity name="DotNetOpenAuth.Core" publicKeyToken="2780ccd10d57b246" /> 
     <bindingRedirect oldVersion="0.0.0.0-4.1.0.0" newVersion="4.1.0.0" /> 
     </dependentAssembly> 
     <dependentAssembly> 
     <assemblyIdentity name="DotNetOpenAuth.AspNet" publicKeyToken="2780ccd10d57b246" /> 
     <bindingRedirect oldVersion="0.0.0.0-4.1.0.0" newVersion="4.1.0.0" /> 
     </dependentAssembly> 
     <dependentAssembly> 
     <assemblyIdentity name="System.Web.Helpers" publicKeyToken="31bf3856ad364e35" /> 
     <bindingRedirect oldVersion="1.0.0.0-2.0.0.0" newVersion="2.0.0.0" /> 
     </dependentAssembly> 
     <dependentAssembly> 
     <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" /> 
     <bindingRedirect oldVersion="0.0.0.0-4.0.0.0" newVersion="4.0.0.0" /> 
     </dependentAssembly> 
     <dependentAssembly> 
     <assemblyIdentity name="System.Web.WebPages" publicKeyToken="31bf3856ad364e35" /> 
     <bindingRedirect oldVersion="1.0.0.0-2.0.0.0" newVersion="2.0.0.0" /> 
     </dependentAssembly> 
     <dependentAssembly> 
     <assemblyIdentity name="WebGrease" publicKeyToken="31bf3856ad364e35" /> 
     <bindingRedirect oldVersion="0.0.0.0-1.3.0.0" newVersion="1.3.0.0" /> 
     </dependentAssembly> 
     <dependentAssembly> 
     <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" /> 
     <bindingRedirect oldVersion="0.0.0.0-8.0.0.0" newVersion="8.0.0.0" /> 
     </dependentAssembly> 
    </assemblyBinding> 
    </runtime> 
    <entityFramework> 
    <defaultConnectionFactory type="System.Data.Entity.Infrastructure.SqlConnectionFactory, EntityFramework" /> 
    <providers> 
     <provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" /> 
    </providers> 
    </entityFramework> 
</configuration> 

AccountModels (UserContext)

namespace RecreationalServicesTicketingSystem.Models 
{ 
    public class UsersContext : DbContext 
    { 
     public UsersContext() 
      : base("DefaultConnection") 
     { 
     } 

     public DbSet<UserProfile> UserProfiles { get; set; } 
    } 

    [Table("UserProfile")] 
    public class UserProfile 
    { 
     [Key] 
     [DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity)] 
     public int UserId { get; set; } 
     public string UserName { get; set; } 
    } 

    public class RegisterExternalLoginModel 
    { 
     [Required] 
     [Display(Name = "User name")] 
     public string UserName { get; set; } 

     public string ExternalLoginData { get; set; } 
    } 

    public class LocalPasswordModel 
    { 
     [Required] 
     [DataType(DataType.Password)] 
     [Display(Name = "Current password")] 
     public string OldPassword { get; set; } 

     [Required] 
     [StringLength(100, ErrorMessage = "The {0} must be at least {2} characters long.", MinimumLength = 6)] 
     [DataType(DataType.Password)] 
     [Display(Name = "New password")] 
     public string NewPassword { get; set; } 

     [DataType(DataType.Password)] 
     [Display(Name = "Confirm new password")] 
     [Compare("NewPassword", ErrorMessage = "The new password and confirmation password do not match.")] 
     public string ConfirmPassword { get; set; } 
    } 

    public class LoginModel 
    { 
     [Required] 
     [Display(Name = "User name")] 
     public string UserName { get; set; } 

     [Required] 
     [DataType(DataType.Password)] 
     [Display(Name = "Password")] 
     public string Password { get; set; } 

     [Display(Name = "Remember me?")] 
     public bool RememberMe { get; set; } 
    } 

    public class RegisterModel 
    { 
     [Required] 
     [Display(Name = "User name")] 
     public string UserName { get; set; } 

     [Required] 
     [StringLength(100, ErrorMessage = "The {0} must be at least {2} characters long.", MinimumLength = 6)] 
     [DataType(DataType.Password)] 
     [Display(Name = "Password")] 
     public string Password { get; set; } 

     [DataType(DataType.Password)] 
     [Display(Name = "Confirm password")] 
     [Compare("Password", ErrorMessage = "The password and confirmation password do not match.")] 
     public string ConfirmPassword { get; set; } 
    } 

    public class ExternalLogin 
    { 
     public string Provider { get; set; } 
     public string ProviderDisplayName { get; set; } 
     public string ProviderUserId { get; set; } 
    } 
} 

AccountController.cs

namespace RecreationalServicesTicketingSystem.Controllers 
{ 
    [Authorize] 
    [InitializeSimpleMembership] 
    public class AccountController : Controller 
    { 
     // 
     // GET: /Account/Login 

     [AllowAnonymous] 
     public ActionResult Login(string returnUrl) 
     { 
      ViewBag.ReturnUrl = returnUrl; 
      return View(); 
     } 

     // 
     // POST: /Account/Login 

     [HttpPost] 
     [AllowAnonymous] 
     [ValidateAntiForgeryToken] 
     public ActionResult Login(LoginModel model, string returnUrl) 
     { 
      if (ModelState.IsValid && WebSecurity.Login(model.UserName, model.Password, persistCookie: model.RememberMe)) 
      { 
       return RedirectToLocal(returnUrl); 
      } 

      // If we got this far, something failed, redisplay form 
      ModelState.AddModelError("", "The user name or password provided is incorrect."); 
      return View(model); 
     } 

     // 
     // POST: /Account/LogOff 

     [HttpPost] 
     [ValidateAntiForgeryToken] 
     public ActionResult LogOff() 
     { 
      WebSecurity.Logout(); 

      return RedirectToAction("Index", "Home"); 
     } 

     // 
     // GET: /Account/Register 

     [AllowAnonymous] 
     public ActionResult Register() 
     { 
      return View(); 
     } 

     // 
     // POST: /Account/Register 

     [HttpPost] 
     [AllowAnonymous] 
     [ValidateAntiForgeryToken] 
     public ActionResult Register(RegisterModel model) 
     { 
      if (ModelState.IsValid) 
      { 
       // Attempt to register the user 
       try 
       { 
        WebSecurity.CreateUserAndAccount(model.UserName, model.Password); 
        WebSecurity.Login(model.UserName, model.Password); 
        return RedirectToAction("Index", "Home"); 
       } 
       catch (MembershipCreateUserException e) 
       { 
        ModelState.AddModelError("", ErrorCodeToString(e.StatusCode)); 
       } 
      } 

      // If we got this far, something failed, redisplay form 
      return View(model); 
     } 

     // 
     // POST: /Account/Disassociate 

     [HttpPost] 
     [ValidateAntiForgeryToken] 
     public ActionResult Disassociate(string provider, string providerUserId) 
     { 
      string ownerAccount = OAuthWebSecurity.GetUserName(provider, providerUserId); 
      ManageMessageId? message = null; 

      // Only disassociate the account if the currently logged in user is the owner 
      if (ownerAccount == User.Identity.Name) 
      { 
       // Use a transaction to prevent the user from deleting their last login credential 
       using (var scope = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions { IsolationLevel = IsolationLevel.Serializable })) 
       { 
        bool hasLocalAccount = OAuthWebSecurity.HasLocalAccount(WebSecurity.GetUserId(User.Identity.Name)); 
        if (hasLocalAccount || OAuthWebSecurity.GetAccountsFromUserName(User.Identity.Name).Count > 1) 
        { 
         OAuthWebSecurity.DeleteAccount(provider, providerUserId); 
         scope.Complete(); 
         message = ManageMessageId.RemoveLoginSuccess; 
        } 
       } 
      } 

      return RedirectToAction("Manage", new { Message = message }); 
     } 

     // 
     // GET: /Account/Manage 

     public ActionResult Manage(ManageMessageId? message) 
     { 
      ViewBag.StatusMessage = 
       message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed." 
       : message == ManageMessageId.SetPasswordSuccess ? "Your password has been set." 
       : message == ManageMessageId.RemoveLoginSuccess ? "The external login was removed." 
       : ""; 
      ViewBag.HasLocalPassword = OAuthWebSecurity.HasLocalAccount(WebSecurity.GetUserId(User.Identity.Name)); 
      ViewBag.ReturnUrl = Url.Action("Manage"); 
      return View(); 
     } 

     // 
     // POST: /Account/Manage 

     [HttpPost] 
     [ValidateAntiForgeryToken] 
     public ActionResult Manage(LocalPasswordModel model) 
     { 
      bool hasLocalAccount = OAuthWebSecurity.HasLocalAccount(WebSecurity.GetUserId(User.Identity.Name)); 
      ViewBag.HasLocalPassword = hasLocalAccount; 
      ViewBag.ReturnUrl = Url.Action("Manage"); 
      if (hasLocalAccount) 
      { 
       if (ModelState.IsValid) 
       { 
        // ChangePassword will throw an exception rather than return false in certain failure scenarios. 
        bool changePasswordSucceeded; 
        try 
        { 
         changePasswordSucceeded = WebSecurity.ChangePassword(User.Identity.Name, model.OldPassword, model.NewPassword); 
        } 
        catch (Exception) 
        { 
         changePasswordSucceeded = false; 
        } 

        if (changePasswordSucceeded) 
        { 
         return RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess }); 
        } 
        else 
        { 
         ModelState.AddModelError("", "The current password is incorrect or the new password is invalid."); 
        } 
       } 
      } 
      else 
      { 
       // User does not have a local password so remove any validation errors caused by a missing 
       // OldPassword field 
       ModelState state = ModelState["OldPassword"]; 
       if (state != null) 
       { 
        state.Errors.Clear(); 
       } 

       if (ModelState.IsValid) 
       { 
        try 
        { 
         WebSecurity.CreateAccount(User.Identity.Name, model.NewPassword); 
         return RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess }); 
        } 
        catch (Exception) 
        { 
         ModelState.AddModelError("", String.Format("Unable to create local account. An account with the name \"{0}\" may already exist.", User.Identity.Name)); 
        } 
       } 
      } 

      // If we got this far, something failed, redisplay form 
      return View(model); 
     } 

     // 
     // POST: /Account/ExternalLogin 

     [HttpPost] 
     [AllowAnonymous] 
     [ValidateAntiForgeryToken] 
     public ActionResult ExternalLogin(string provider, string returnUrl) 
     { 
      return new ExternalLoginResult(provider, Url.Action("ExternalLoginCallback", new { ReturnUrl = returnUrl })); 
     } 

     // 
     // GET: /Account/ExternalLoginCallback 

     [AllowAnonymous] 
     public ActionResult ExternalLoginCallback(string returnUrl) 
     { 
      AuthenticationResult result = OAuthWebSecurity.VerifyAuthentication(Url.Action("ExternalLoginCallback", new { ReturnUrl = returnUrl })); 
      if (!result.IsSuccessful) 
      { 
       return RedirectToAction("ExternalLoginFailure"); 
      } 

      if (OAuthWebSecurity.Login(result.Provider, result.ProviderUserId, createPersistentCookie: false)) 
      { 
       return RedirectToLocal(returnUrl); 
      } 

      if (User.Identity.IsAuthenticated) 
      { 
       // If the current user is logged in add the new account 
       OAuthWebSecurity.CreateOrUpdateAccount(result.Provider, result.ProviderUserId, User.Identity.Name); 
       return RedirectToLocal(returnUrl); 
      } 
      else 
      { 
       // User is new, ask for their desired membership name 
       string loginData = OAuthWebSecurity.SerializeProviderUserId(result.Provider, result.ProviderUserId); 
       ViewBag.ProviderDisplayName = OAuthWebSecurity.GetOAuthClientData(result.Provider).DisplayName; 
       ViewBag.ReturnUrl = returnUrl; 
       return View("ExternalLoginConfirmation", new RegisterExternalLoginModel { UserName = result.UserName, ExternalLoginData = loginData }); 
      } 
     } 

     // 
     // POST: /Account/ExternalLoginConfirmation 

     [HttpPost] 
     [AllowAnonymous] 
     [ValidateAntiForgeryToken] 
     public ActionResult ExternalLoginConfirmation(RegisterExternalLoginModel model, string returnUrl) 
     { 
      string provider = null; 
      string providerUserId = null; 

      if (User.Identity.IsAuthenticated || !OAuthWebSecurity.TryDeserializeProviderUserId(model.ExternalLoginData, out provider, out providerUserId)) 
      { 
       return RedirectToAction("Manage"); 
      } 

      if (ModelState.IsValid) 
      { 
       // Insert a new user into the database 
       using (UsersContext db = new UsersContext()) 
       { 
        UserProfile user = db.UserProfiles.FirstOrDefault(u => u.UserName.ToLower() == model.UserName.ToLower()); 
        // Check if user already exists 
        if (user == null) 
        { 
         // Insert name into the profile table 
         db.UserProfiles.Add(new UserProfile { UserName = model.UserName }); 
         db.SaveChanges(); 

         OAuthWebSecurity.CreateOrUpdateAccount(provider, providerUserId, model.UserName); 
         OAuthWebSecurity.Login(provider, providerUserId, createPersistentCookie: false); 

         return RedirectToLocal(returnUrl); 
        } 
        else 
        { 
         ModelState.AddModelError("UserName", "User name already exists. Please enter a different user name."); 
        } 
       } 
      } 

      ViewBag.ProviderDisplayName = OAuthWebSecurity.GetOAuthClientData(provider).DisplayName; 
      ViewBag.ReturnUrl = returnUrl; 
      return View(model); 
     } 

     // 
     // GET: /Account/ExternalLoginFailure 

     [AllowAnonymous] 
     public ActionResult ExternalLoginFailure() 
     { 
      return View(); 
     } 

     [AllowAnonymous] 
     [ChildActionOnly] 
     public ActionResult ExternalLoginsList(string returnUrl) 
     { 
      ViewBag.ReturnUrl = returnUrl; 
      return PartialView("_ExternalLoginsListPartial", OAuthWebSecurity.RegisteredClientData); 
     } 

     [ChildActionOnly] 
     public ActionResult RemoveExternalLogins() 
     { 
      ICollection<OAuthAccount> accounts = OAuthWebSecurity.GetAccountsFromUserName(User.Identity.Name); 
      List<ExternalLogin> externalLogins = new List<ExternalLogin>(); 
      foreach (OAuthAccount account in accounts) 
      { 
       AuthenticationClientData clientData = OAuthWebSecurity.GetOAuthClientData(account.Provider); 

       externalLogins.Add(new ExternalLogin 
       { 
        Provider = account.Provider, 
        ProviderDisplayName = clientData.DisplayName, 
        ProviderUserId = account.ProviderUserId, 
       }); 
      } 

      ViewBag.ShowRemoveButton = externalLogins.Count > 1 || OAuthWebSecurity.HasLocalAccount(WebSecurity.GetUserId(User.Identity.Name)); 
      return PartialView("_RemoveExternalLoginsPartial", externalLogins); 
     } 

     #region Helpers 
     private ActionResult RedirectToLocal(string returnUrl) 
     { 
      if (Url.IsLocalUrl(returnUrl)) 
      { 
       return Redirect(returnUrl); 
      } 
      else 
      { 
       return RedirectToAction("Index", "Home"); 
      } 
     } 

     public enum ManageMessageId 
     { 
      ChangePasswordSuccess, 
      SetPasswordSuccess, 
      RemoveLoginSuccess, 
     } 

     internal class ExternalLoginResult : ActionResult 
     { 
      public ExternalLoginResult(string provider, string returnUrl) 
      { 
       Provider = provider; 
       ReturnUrl = returnUrl; 
      } 

      public string Provider { get; private set; } 
      public string ReturnUrl { get; private set; } 

      public override void ExecuteResult(ControllerContext context) 
      { 
       OAuthWebSecurity.RequestAuthentication(Provider, ReturnUrl); 
      } 
     } 

     private static string ErrorCodeToString(MembershipCreateStatus createStatus) 
     { 
      // See http://go.microsoft.com/fwlink/?LinkID=177550 for 
      // a full list of status codes. 
      switch (createStatus) 
      { 
       case MembershipCreateStatus.DuplicateUserName: 
        return "User name already exists. Please enter a different user name."; 

       case MembershipCreateStatus.DuplicateEmail: 
        return "A user name for that e-mail address already exists. Please enter a different e-mail address."; 

       case MembershipCreateStatus.InvalidPassword: 
        return "The password provided is invalid. Please enter a valid password value."; 

       case MembershipCreateStatus.InvalidEmail: 
        return "The e-mail address provided is invalid. Please check the value and try again."; 

       case MembershipCreateStatus.InvalidAnswer: 
        return "The password retrieval answer provided is invalid. Please check the value and try again."; 

       case MembershipCreateStatus.InvalidQuestion: 
        return "The password retrieval question provided is invalid. Please check the value and try again."; 

       case MembershipCreateStatus.InvalidUserName: 
        return "The user name provided is invalid. Please check the value and try again."; 

       case MembershipCreateStatus.ProviderError: 
        return "The authentication provider returned an error. Please verify your entry and try again. If the problem persists, please contact your system administrator."; 

       case MembershipCreateStatus.UserRejected: 
        return "The user creation request has been canceled. Please verify your entry and try again. If the problem persists, please contact your system administrator."; 

       default: 
        return "An unknown error occurred. Please verify your entry and try again. If the problem persists, please contact your system administrator."; 
      } 
     } 
     #endregion 
    } 
} 

Answer 1

Sizin connectionString sağlayıcı ada sahip görünmüyor:

<add name="DefaultConnection" connectionString="Data Source=.\SQLEXPRESS;Integrated Security=True;Connect Timeout=15;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False" /> 

Uygulamanız, bağlı olduğu veri sağlayıcıdan ne tür bilmesi gerekir. Bu

<add name="DefaultConnection" connectionString="Data Source=.\SQLEXPRESS;Integrated Security=True;Connect Timeout=15;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False" 
    providerName="System.Data.SqlClient" /> 

gibi

providerName="System.Data.SqlClient" 

Ve Tamam yapmalıdır: SQL Server için providerNameSystem.Data.SqlClient olarak ekleyin.