title: ASP.NET MVC Database not being created/uploaded System.ComponentModel.Win32Exception: The system cannot find the file specified
body: <p><strong>Background</strong><br>
  I have just created an MVC website (as an application) using <em>Visual Studio 2013 Express for Web</em> from the default MVC template using the "Individual user accounts" option. I have created views to fit and added two fields ("Username" and "Birthdate") to the accounts model (using the tutorials by Microsoft). <em>Note: Everything works fine when running on localhost from visual studio.</em></p>
  
  <p><strong>The Problem</strong><br>
  When I upload the site to <a href="http://www.spiderhouse.org" rel="nofollow noreferrer">my server</a>, I get a file not found error (I think it is the accounts database that is not being found). When I upload it (<em>I am doing this via the file system method</em>), there is nothing in the AppData folder but there isn't in VS either, it's in the server explorer. If I try to do anything with the accounts on the live server (eg. register a user), I get the following stack trace.</p>
  
  <p><strong>The Stack Trace</strong><br>
  <img src="https://i.stack.imgur.com/jNBRQ.jpg" alt="The Stack Trace"><br>
  Note: You can see this for yourself at <a href="http://www.spiderhouse.org" rel="nofollow noreferrer">spiderhouse.org</a> if you register a user; I have left the full error details available and in it's current state (at the time of writing) no info will be saved.</p>
  
  <p><strong>The Identity Models</strong></p>
  
  <pre><code>using System;
  using System.Security.Claims;
  using System.Threading.Tasks;
  using Microsoft.AspNet.Identity;
  using Microsoft.AspNet.Identity.EntityFramework;
  
  namespace Spiderhouse.Models
  {
      // You can add profile data for the user by adding more properties to your ApplicationUser class, please visit http://go.microsoft.com/fwlink/?LinkID=317594 to learn more.
      public class ApplicationUser : IdentityUser
      {
          public async Task&lt;ClaimsIdentity&gt; GenerateUserIdentityAsync(UserManager&lt;ApplicationUser&gt; manager)
          {
              // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
              var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);
              // Add custom user claims here
              return userIdentity;
          }
          public override string UserName { get; set; }
          public DateTime BirthDate { get; set; }
      }
  
      public class ApplicationDbContext : IdentityDbContext&lt;ApplicationUser&gt;
      {
          public ApplicationDbContext()
              : base("DefaultConnection", throwIfV1Schema: false)
          {
          }
  
          public static ApplicationDbContext Create()
          {
              return new ApplicationDbContext();
          }
      }
  }
  </code></pre>
  
  <p><strong>The Account Controller</strong>  </p>
  
  <pre><code>using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Security.Claims;
  using System.Threading.Tasks;
  using System.Web;
  using System.Web.Mvc;
  using Microsoft.AspNet.Identity;
  using Microsoft.AspNet.Identity.EntityFramework;
  using Microsoft.AspNet.Identity.Owin;
  using Microsoft.Owin.Security;
  using Owin;
  using Spiderhouse.Models;
  
      namespace Spiderhouse.Controllers
      {
      [Authorize]
      public class AccountController : Controller
      {
          private ApplicationUserManager _userManager;
  
          public AccountController()
          {
          }
  
          public AccountController(ApplicationUserManager userManager)
          {
              UserManager = userManager;
          }
  
          public ApplicationUserManager UserManager {
              get
              {
                  return _userManager ?? HttpContext.GetOwinContext().GetUserManager&lt;ApplicationUserManager&gt;();
              }
              private set
              {
                  _userManager = value;
              }
          }
  
          //
          // GET: /Account/Login
          [AllowAnonymous]
          public ActionResult Login(string returnUrl)
          {
              ViewBag.ReturnUrl = returnUrl;
              return View();
          }
  
          //
          // POST: /Account/Login
          [HttpPost]
          [AllowAnonymous]
          [ValidateAntiForgeryToken]
          public async Task&lt;ActionResult&gt; Login(LoginViewModel model, string returnUrl)
          {
              if (ModelState.IsValid)
              {
                  var user = await UserManager.FindAsync(model.UserName, model.Password);
                  if (user != null)
                  {
                      await SignInAsync(user, model.RememberMe);
                      return RedirectToLocal(returnUrl);
                  }
                  else
                  {
                      ModelState.AddModelError("", "Invalid username or password.");
                  }
              }
  
              // If we got this far, something failed, redisplay form
              return View(model);
          }
  
          //
          // GET: /Account/Register
          [AllowAnonymous]
          public ActionResult Register()
          {
              return View();
          }
  
          //
          // POST: /Account/Register
          [HttpPost]
          [AllowAnonymous]
          [ValidateAntiForgeryToken]
          public async Task&lt;ActionResult&gt; Register(RegisterViewModel model)
          {
              if (ModelState.IsValid)
              {
                  var user = new ApplicationUser() { UserName = model.UserName, Email = model.Email, BirthDate = model.BirthDate };
                  IdentityResult result = await UserManager.CreateAsync(user, model.Password);
                  if (result.Succeeded)
                  {
                      await SignInAsync(user, isPersistent: false);
  
                      // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
                      // Send an email with this link
                      // string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
                      // var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
                      // await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking &lt;a href=\"" + callbackUrl + "\"&gt;here&lt;/a&gt;");
  
                      return RedirectToAction("Index", "Home");
                  }
                  else
                  {
                      AddErrors(result);
                  }
              }
  
              // If we got this far, something failed, redisplay form
              return View(model);
          }
  
          //
          // GET: /Account/ConfirmEmail
          [AllowAnonymous]
          public async Task&lt;ActionResult&gt; ConfirmEmail(string userId, string code)
          {
              if (userId == null || code == null) 
              {
                  return View("Error");
              }
  
              IdentityResult result = await UserManager.ConfirmEmailAsync(userId, code);
              if (result.Succeeded)
              {
                  return View("ConfirmEmail");
              }
              else
              {
                  AddErrors(result);
                  return View();
              }
          }
  
          //
          // GET: /Account/ForgotPassword
          [AllowAnonymous]
          public ActionResult ForgotPassword()
          {
              return View();
          }
  
          //
          // POST: /Account/ForgotPassword
          [HttpPost]
          [AllowAnonymous]
          [ValidateAntiForgeryToken]
          public async Task&lt;ActionResult&gt; ForgotPassword(ForgotPasswordViewModel model)
          {
              if (ModelState.IsValid)
              {
                  var user = await UserManager.FindByNameAsync(model.Email);
                  if (user == null || !(await UserManager.IsEmailConfirmedAsync(user.Id)))
                  {
                      ModelState.AddModelError("", "The user either does not exist or is not confirmed.");
                      return View();
                  }
  
                  // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
                  // Send an email with this link
                  // string code = await UserManager.GeneratePasswordResetTokenAsync(user.Id);
                  // var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);       
                  // await UserManager.SendEmailAsync(user.Id, "Reset Password", "Please reset your password by clicking &lt;a href=\"" + callbackUrl + "\"&gt;here&lt;/a&gt;");
                  // return RedirectToAction("ForgotPasswordConfirmation", "Account");
              }
  
              // If we got this far, something failed, redisplay form
              return View(model);
          }
  
          //
          // GET: /Account/ForgotPasswordConfirmation
          [AllowAnonymous]
          public ActionResult ForgotPasswordConfirmation()
          {
              return View();
          }
  
          //
          // GET: /Account/ResetPassword
          [AllowAnonymous]
          public ActionResult ResetPassword(string code)
          {
              if (code == null) 
              {
                  return View("Error");
              }
              return View();
          }
  
          //
          // POST: /Account/ResetPassword
          [HttpPost]
          [AllowAnonymous]
          [ValidateAntiForgeryToken]
          public async Task&lt;ActionResult&gt; ResetPassword(ResetPasswordViewModel model)
          {
              if (ModelState.IsValid)
              {
                  var user = await UserManager.FindByNameAsync(model.Email);
                  if (user == null)
                  {
                      ModelState.AddModelError("", "No user found.");
                      return View();
                  }
                  IdentityResult result = await UserManager.ResetPasswordAsync(user.Id, model.Code, model.Password);
                  if (result.Succeeded)
                  {
                      return RedirectToAction("ResetPasswordConfirmation", "Account");
                  }
                  else
                  {
                      AddErrors(result);
                      return View();
                  }
              }
  
              // If we got this far, something failed, redisplay form
              return View(model);
          }
  
          //
          // GET: /Account/ResetPasswordConfirmation
          [AllowAnonymous]
          public ActionResult ResetPasswordConfirmation()
          {
              return View();
          }
  
          //
          // POST: /Account/Disassociate
          [HttpPost]
          [ValidateAntiForgeryToken]
          public async Task&lt;ActionResult&gt; Disassociate(string loginProvider, string providerKey)
          {
              ManageMessageId? message = null;
              IdentityResult result = await UserManager.RemoveLoginAsync(User.Identity.GetUserId(), new UserLoginInfo(loginProvider, providerKey));
              if (result.Succeeded)
              {
                  var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
                  await SignInAsync(user, isPersistent: false);
                  message = ManageMessageId.RemoveLoginSuccess;
              }
              else
              {
                  message = ManageMessageId.Error;
              }
              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."
                  : message == ManageMessageId.Error ? "An error has occurred."
                  : "";
              ViewBag.HasLocalPassword = HasPassword();
              ViewBag.ReturnUrl = Url.Action("Manage");
              return View();
          }
  
          //
          // POST: /Account/Manage
          [HttpPost]
          [ValidateAntiForgeryToken]
          public async Task&lt;ActionResult&gt; Manage(ManageUserViewModel model)
          {
              bool hasPassword = HasPassword();
              ViewBag.HasLocalPassword = hasPassword;
              ViewBag.ReturnUrl = Url.Action("Manage");
              if (hasPassword)
              {
                  if (ModelState.IsValid)
                  {
                      IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
                      if (result.Succeeded)
                      {
                          var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
                          await SignInAsync(user, isPersistent: false);
                          return RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess });
                      }
                      else
                      {
                          AddErrors(result);
                      }
                  }
              }
              else
              {
                  // User does not have a 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)
                  {
                      IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
                      if (result.Succeeded)
                      {
                          return RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess });
                      }
                      else
                      {
                          AddErrors(result);
                      }
                  }
              }
  
              // 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)
          {
              // Request a redirect to the external login provider
              return new ChallengeResult(provider, Url.Action("ExternalLoginCallback", "Account", new { ReturnUrl = returnUrl }));
          }
  
          //
          // GET: /Account/ExternalLoginCallback
          [AllowAnonymous]
          public async Task&lt;ActionResult&gt; ExternalLoginCallback(string returnUrl)
          {
              var loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync();
              if (loginInfo == null)
              {
                  return RedirectToAction("Login");
              }
  
              // Sign in the user with this external login provider if the user already has a login
              var user = await UserManager.FindAsync(loginInfo.Login);
              if (user != null)
              {
                  await SignInAsync(user, isPersistent: false);
                  return RedirectToLocal(returnUrl);
              }
              else
              {
                  // If the user does not have an account, then prompt the user to create an account
                  ViewBag.ReturnUrl = returnUrl;
                  ViewBag.LoginProvider = loginInfo.Login.LoginProvider;
                  return View("ExternalLoginConfirmation", new ExternalLoginConfirmationViewModel { Email = loginInfo.Email });
              }
          }
  
          //
          // POST: /Account/LinkLogin
          [HttpPost]
          [ValidateAntiForgeryToken]
          public ActionResult LinkLogin(string provider)
          {
              // Request a redirect to the external login provider to link a login for the current user
              return new ChallengeResult(provider, Url.Action("LinkLoginCallback", "Account"), User.Identity.GetUserId());
          }
  
          //
          // GET: /Account/LinkLoginCallback
          public async Task&lt;ActionResult&gt; LinkLoginCallback()
          {
              var loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync(XsrfKey, User.Identity.GetUserId());
              if (loginInfo == null)
              {
                  return RedirectToAction("Manage", new { Message = ManageMessageId.Error });
              }
              IdentityResult result = await UserManager.AddLoginAsync(User.Identity.GetUserId(), loginInfo.Login);
              if (result.Succeeded)
              {
                  return RedirectToAction("Manage");
              }
              return RedirectToAction("Manage", new { Message = ManageMessageId.Error });
          }
  
          //
          // POST: /Account/ExternalLoginConfirmation
          [HttpPost]
          [AllowAnonymous]
          [ValidateAntiForgeryToken]
          public async Task&lt;ActionResult&gt; ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
          {
              if (User.Identity.IsAuthenticated)
              {
                  return RedirectToAction("Manage");
              }
  
              if (ModelState.IsValid)
              {
                  // Get the information about the user from the external login provider
                  var info = await AuthenticationManager.GetExternalLoginInfoAsync();
                  if (info == null)
                  {
                      return View("ExternalLoginFailure");
                  }
                  var user = new ApplicationUser() { UserName = model.Email, Email = model.Email };
                  IdentityResult result = await UserManager.CreateAsync(user);
                  if (result.Succeeded)
                  {
                      result = await UserManager.AddLoginAsync(user.Id, info.Login);
                      if (result.Succeeded)
                      {
                          await SignInAsync(user, isPersistent: false);
  
                          // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
                          // Send an email with this link
                          // string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
                          // var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
                          // SendEmail(user.Email, callbackUrl, "Confirm your account", "Please confirm your account by clicking this link");
  
                          return RedirectToLocal(returnUrl);
                      }
                  }
                  AddErrors(result);
              }
  
              ViewBag.ReturnUrl = returnUrl;
              return View(model);
          }
  
          //
          // POST: /Account/LogOff
          [HttpPost]
          [ValidateAntiForgeryToken]
          public ActionResult LogOff()
          {
              AuthenticationManager.SignOut();
              return RedirectToAction("Index", "Home");
          }
  
          //
          // GET: /Account/ExternalLoginFailure
          [AllowAnonymous]
          public ActionResult ExternalLoginFailure()
          {
              return View();
          }
  
          [ChildActionOnly]
          public ActionResult RemoveAccountList()
          {
              var linkedAccounts = UserManager.GetLogins(User.Identity.GetUserId());
              ViewBag.ShowRemoveButton = HasPassword() || linkedAccounts.Count &gt; 1;
              return (ActionResult)PartialView("_RemoveAccountPartial", linkedAccounts);
          }
  
          protected override void Dispose(bool disposing)
          {
              if (disposing &amp;&amp; UserManager != null)
              {
                  UserManager.Dispose();
                  UserManager = null;
              }
              base.Dispose(disposing);
          }
  
          #region Helpers
          // Used for XSRF protection when adding external logins
          private const string XsrfKey = "XsrfId";
  
          private IAuthenticationManager AuthenticationManager
          {
              get
              {
                  return HttpContext.GetOwinContext().Authentication;
              }
          }
  
          private async Task SignInAsync(ApplicationUser user, bool isPersistent)
          {
              AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie);
              AuthenticationManager.SignIn(new AuthenticationProperties() { IsPersistent = isPersistent }, await user.GenerateUserIdentityAsync(UserManager));
          }
  
          private void AddErrors(IdentityResult result)
          {
              foreach (var error in result.Errors)
              {
                  ModelState.AddModelError("", error);
              }
          }
  
          private bool HasPassword()
          {
              var user = UserManager.FindById(User.Identity.GetUserId());
              if (user != null)
              {
                  return user.PasswordHash != null;
              }
              return false;
          }
  
          private void SendEmail(string email, string callbackUrl, string subject, string message)
          {
              // For information on sending mail, please visit http://go.microsoft.com/fwlink/?LinkID=320771
          }
  
          public enum ManageMessageId
          {
              ChangePasswordSuccess,
              SetPasswordSuccess,
              RemoveLoginSuccess,
              Error
          }
  
          private ActionResult RedirectToLocal(string returnUrl)
          {
              if (Url.IsLocalUrl(returnUrl))
              {
                  return Redirect(returnUrl);
              }
              else
              {
                  return RedirectToAction("Index", "Home");
              }
          }
  
          private class ChallengeResult : HttpUnauthorizedResult
          {
              public ChallengeResult(string provider, string redirectUri) : this(provider, redirectUri, null)
              {
              }
  
              public ChallengeResult(string provider, string redirectUri, string userId)
              {
                  LoginProvider = provider;
                  RedirectUri = redirectUri;
                  UserId = userId;
              }
  
              public string LoginProvider { get; set; }
              public string RedirectUri { get; set; }
              public string UserId { get; set; }
  
              public override void ExecuteResult(ControllerContext context)
              {
                  var properties = new AuthenticationProperties() { RedirectUri = RedirectUri };
                  if (UserId != null)
                  {
                      properties.Dictionary[XsrfKey] = UserId;
                  }
                  context.HttpContext.GetOwinContext().Authentication.Challenge(properties, LoginProvider);
              }
          }
          #endregion
      }
  }
  </code></pre>
  
  <p><strong>The Connection Strings</strong>  </p>
  
  <pre><code>&lt;connectionStrings&gt;
      &lt;add name="DefaultConnection" connectionString="Data Source=(LocalDb)\v11.0;AttachDbFilename=|DataDirectory|\aspnet-Spiderhouse-20141120093225.mdf;Initial Catalog=aspnet-Spiderhouse-20141120093225;Integrated Security=True" providerName="System.Data.SqlClient" /&gt;
  &lt;/connectionStrings&gt;
  </code></pre>