Formsroleauth: как это реализовать если я использую Entity Framework 4.0

private void btnLogin_Click(Object sender, EventArgs e)
{
    // Initialize FormsAuthentication, for what it's worth
    FormsAuthentication.Initialize();
 
    // Create our connection and command objects
    SqlConnection conn =
     new SqlConnection("Data Source=localhost;Initial Catalog=web;");
    SqlCommand cmd = conn.CreateCommand();
    cmd.CommandText = "SELECT roles FROM web WHERE username=@username " +
     "AND password=@password";
 
    // Fill our parameters
    cmd.Parameters.Add("@username", SqlDbType.NVarChar, 64).Value =
Username.Value;
    cmd.Parameters.Add("@password", SqlDbType.NVarChar, 128).Value =
     FormsAuthentication.HashPasswordForStoringInConfigFile(
        Password.Value, "md5"); // Or "sha1"
 
    // Execute the command
    conn.Open();
    SqlDataReader reader = cmd.ExecuteReader();
    if (reader.Read())
    {
     // Create a new ticket used for authentication
     FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(
        1, // Ticket version
        Username.Value, // Username associated with ticket
        DateTime.Now, // Date/time issued
        DateTime.Now.AddMinutes(30), // Date/time to expire
        true, // "true" for a persistent user cookie
        reader.GetString(0), // User-data, in this case the roles
        FormsAuthentication.FormsCookiePath);// Path cookie valid for
 
     // Encrypt the cookie using the machine key for secure transport
     string hash = FormsAuthentication.Encrypt(ticket);
     HttpCookie cookie = new HttpCookie(
        FormsAuthentication.FormsCookieName, // Name of auth cookie
        hash); // Hashed ticket
 
     // Set the cookie's expiration time to the tickets expiration time
     if (ticket.IsPersistent) cookie.Expires = ticket.Expiration;
 
     // Add the cookie to the list for outgoing response
     Response.Cookies.Add(cookie);
 
     // Redirect to requested URL, or homepage if no previous page
     // requested
     string returnUrl = Request.QueryString["ReturnUrl"];
     if (returnUrl == null) returnUrl = "/";
 
     // Don't call FormsAuthentication.RedirectFromLoginPage since it
     // could
     // replace the authentication ticket (cookie) we just added
     Response.Redirect(returnUrl);
    }
    else
    {
     // Never tell the user if just the username is password is incorrect.
     // That just gives them a place to start, once they've found one or
     // the other is correct!
     ErrorLabel = "Username / password incorrect. Please try again.";
     ErrorLabel.Visible = true;
    }
 
    reader.Close();
    conn.Close();
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using BusinessLogic;
using Components;
 
namespace Web.Account
{
    public partial class Login : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
 
        }
 
        protected void btnLogin_Click(object sender, EventArgs e)
        {
            var accountService = new AccountService();
            accountService.Login(tbxLoginUsername.Text, tbxLoginPassword.Text);
            
        }
    }
}

using System;
using System.Collections.Generic;
using BusinessLogic.Interfaces;
using Common;
using Components;
using DataAccessLayer;
using DataAccessLayer.Repositories;
 
namespace BusinessLogic
{
    public class AccountService:IAccountService
 
    {
        private AccountRepository accountRepository=new AccountRepository();
        private UserSessionComponent userSession=new UserSessionComponent();
        private RedirectorComponent redirector=new RedirectorComponent();
        private EmailComponent _email=new EmailComponent();
        private LoggerComponent log=new LoggerComponent();
 
        //CHAPTER 5
        public List<Account> SearchAccounts(string searchText)
        {
            return accountRepository.SearchAccounts(searchText);
        }
        public bool UsernameInUse(string username)
        {
            try
            {
                var account = accountRepository.GetAccountByUsername(username);
                return account != null;
            }
            catch (Exception e)
            {
                log.Error(e, e.Message);
                return false;
            }
        }
 
        public bool EmailInUse(string email)
        {
            try
            {
                var account = accountRepository.GetAccountByEmail(email);
                return account != null;
            }
            catch (Exception e)
            {
                log.Error(this, e.Message);
                return false;
            }
        }
 
        public void Logout()
        {
            try
            {
                userSession.LoggedIn = false;
                userSession.CurrentUser = null;
                userSession.Username = string.Empty;
                redirector.GoToAccountLoginPage();
            }
            catch (Exception e)
            {
                log.Error(this, e.Message);
            }
        }
 
        public string Login(string username, string password)
        {
            try
            {
                password = password.Encrypt(username);
                var account = accountRepository.GetAccountByUsername(username);
 
                if (account != null)
                {
                    //password matches
                    if (account.Password == password)
                    {
                        userSession.LoggedIn = true;
                        userSession.Username = username;
                        userSession.CurrentUser = account;
                        redirector.GoToProfilesDefault();
                        
                    }
                }
                return "Check your Username and try again!";
            }
            catch (Exception e)
            {
                log.Error(e, e.Message);
                return e.Message;
            }
        }
 
        public void SaveAccount(Account account)
        {
            accountRepository.SaveAccount(account);
        }
 
        public Account GetAccountByEmail(string email)
        {
            return accountRepository.GetAccountByEmail(email);
        }
 
        public void AddRole(Account account, Role role)
        {
            accountRepository.AddRole(account, role);
        }
 
        //Chapter 4
        public Account GetAccountById(int accountId)
        {
            return accountRepository.GetAccountById(accountId);
        }
 
        public Account GetAccountByUsername(string username)
        {
            return accountRepository.GetAccountByUsername(username);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using DataAccessLayer.Interfaces;
 
namespace DataAccessLayer.Repositories
{
    public class AccountRepository:IAccountRepository 
    {
        private Connection conn;
        public AccountRepository(){conn=new Connection();}
        public Account GetAccountById(int accountId)
        {
            Account account;
            using (SNDataContext dc = conn.GetContext())
            {
                account = (dc.Account.Where(a => a.AccountID == accountId)).FirstOrDefault();
            }
            return account;
        }
        public Account GetAccountByEmail(string email)
        {
            Account account;
            using (SNDataContext dc = conn.GetContext())
            {
                account = (from a in dc.Account
                           where a.Email == email
                           select a).FirstOrDefault();
            }
            return account;
        }
        public Account GetAccountByUsername(string username)
        {
            Account account;
            using (SNDataContext dc=conn.GetContext())
            {
                account = (from a in dc.Account
                           where a.Username == username
                           select a).FirstOrDefault();
            }
            return account;
        }
        public void AddRole(Account account, Role role)
        {
            using (SNDataContext dc=conn.GetContext())
            {
                var ar = new AccountRole {AccountID = account.AccountID, RoleID = role.RoleID};
                dc.AccountRole.AddObject(ar);
                dc.SaveChanges();
            }
        }
        public void SaveAccount(Account account)
        {
            using (SNDataContext dc = conn.GetContext())
            {
                if (account.AccountID > 0)
                {
                    dc.Account.Attach(new Account { AccountID = account.AccountID });
                    dc.Account.ApplyCurrentValues(account);
                }
                else
                {
                    dc.Account.AddObject(account);
                }
                dc.SaveChanges();
            }
            {
                
            }
        }
        public void DeleteAccount(Account account)
        {
            using (SNDataContext dc = conn.GetContext())
            {
                dc.Account.DeleteObject(account);
                dc.SaveChanges();
            }
        }
        public List<Account> GetAllAccounts(int pageNumber)
        {
            IEnumerable<Account> accounts;
            using (SNDataContext dc = conn.GetContext())
            {
                accounts = (from a in dc.Account
                            orderby a.Username
                            select a).Skip((pageNumber - 1)*10).Take(10);
            }
            return accounts.ToList();
        }
        //CHAPTER 5
        public List<Account> SearchAccounts(string searchText)
        {
            var result = new List<Account>();
            using (var dc = conn.GetContext())
            {
                IEnumerable<Account> accounts = from a in dc.Account
                                                where (a.FirstName + " " + a.LastName).Contains(searchText) ||
                                                    a.Email.Contains(searchText) ||
                                                    a.Username.Contains(searchText)
                                                select a;
                result = accounts.ToList();
            }
            return result;
        }
         
    }
}

using DataAccessLayer;
using Interfaces;
 
namespace Components
{
    
    public class UserSessionComponent:IUserSessionComponent
    {
        
        private WebContextComponent _webContextComponent=new WebContextComponent(); 
 
        public bool LoggedIn
        {
            get
            {
                return _webContextComponent.LoggedIn;
            }
            set
            {
                _webContextComponent.LoggedIn = value;
            }
        }
 
        public Account CurrentUser
        {
            get
            {
                return _webContextComponent.CurrentUser;
            }
            set
            {
                _webContextComponent.CurrentUser = value;
            }
        }
 
        public string Username
        {
            get
            {
                return _webContextComponent.Username;
            }
 
            set
            {
                _webContextComponent.Username = value;
            }
        }
    }
}

using System;
using System.Web;
using DataAccessLayer;
using Interfaces;
 
namespace Components
{
    public class WebContextComponent : IWebContextComponent 
    {
        //CHAPTER 5
        public int AccoundIdToInvite
        {
            get
            {
                int result = !string.IsNullOrEmpty(GetQueryStringValue("AccountIdToInvite")) ? Convert.ToInt32(GetQueryStringValue("AccountIdToInvite")) : 0;
                return result;
            }
        }
 
        //CHAPTER 5
        public string SearchText
        {
            get
            {
                string result = !string.IsNullOrEmpty(GetQueryStringValue("s")) ? GetQueryStringValue("s") : "";
                return result;
            }
        }
        public int AccountId
        {
            get
            {
                if (!string.IsNullOrEmpty(GetQueryStringValue("AccountID")))
                {
                    return Convert.ToInt32(GetQueryStringValue("AccountID"));
                }
                return 0;
            }
        }
        //CHAPTER 3
        public Account CurrentUser
        {
            get
            {
                if (ContainsInSession("CurrentUser"))
                {
                    return GetFromSession("CurrentUser") as Account;
                }
 
                return null;
            }
            set
            {
                SetInSession("CurrentUser", value);
            }
        }
 
        //CHAPTER 3
        public string Username
        {
            get
            {
                if (ContainsInSession("Username"))
                {
                    return GetFromSession("Username").ToString();
                }
 
                return "";
            }
 
            set
            {
                SetInSession("Username", value);
            }
        }
 
        //CHAPTER 3
        public bool LoggedIn
        {
            get
            {
                if (ContainsInSession("LoggedIn"))
                {
                    if ((bool)GetFromSession("LoggedIn"))
                        return true;
                    return false;
                }
                return false;
            }
            set
            {
                SetInSession("LoggedIn", value);
            }
        }
 
        //CHAPTER 3
        public string UsernameToVerify
        {
            get
            {
                return GetQueryStringValue("a");
            }
        }
 
        public void ClearSession()
        {
            HttpContext.Current.Session.Clear();
        }
 
        public bool ContainsInSession(string key)
        {
            return HttpContext.Current.Session[key] != null;
        }
 
        public void RemoveFromSession(string key)
        {
            HttpContext.Current.Session.Remove(key);
        }
 
        private string GetQueryStringValue(string key)
        {
            return HttpContext.Current.Request.QueryString.Get(key);
        }
 
        private void SetInSession(string key, object value)
        {
            if (HttpContext.Current == null || HttpContext.Current.Session == null)
            {
                return;
            }
            HttpContext.Current.Session[key] = value;
        }
 
        private object GetFromSession(string key)
        {
            if (HttpContext.Current == null || HttpContext.Current.Session == null)
            {
                return null;
            }
            return HttpContext.Current.Session[key];
        }
 
        private void UpdateInSession(string key, object value)
        {
            HttpContext.Current.Session[key] = value;
        }
    }
}