Entity Framework Custom Membership Provider

Here's an example of a custom MembershipProvider that uses Entity Framework 4.2 for data access.

First you will need to create an aspnetdb database on your SQL Server. On the SQL Server open a command prompt and run the following command:

C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\aspnet_regsql.exe

In the code below I have created a custom MembershipUser object in which I've included the following columns that I added to the aspnetdb aspnet_Users table:

Id (int, not null) Identity Column
FirstName (nvarchar(256), null)
LastName (nvarchar(256), null)


Add a connection string to your web config to connect to the aspnetdb:

<connectionStrings>
    <add name="ApplicationServices" connectionString="data source=server;Initial Catalog=aspnetdb;User Id=sa;Password=password;MultipleActiveResultSets=true" providerName="System.Data.SqlClient" />
</connectionStrings>

The name of the connection string is important as it is used when declaring the EF data context.

The keys that are used to encrypt passwords and password questions need to be generated and added to the web.config. This is important if your application runs in a server farm.

<system.web>
    <machineKey validationKey="EF3DFB100FD7C5FCC8915EEC705968659FB2982C466B9D67694471F6543C60CE244E5FF8CF049C759784F73CFC2D4E05B1D75D92134C27C1DA644A5D32D82D50"
                decryptionKey="A71798F098622A67A6DFA5472AA46C8E83AF7462DA19BF8B2E23C1B113608F7F"
                validation="SHA1"
                decryption="AES"/>
</system.web>

Here is a snippet of code from a Console application that can be used to generate the 128bit and 64bit keys:

static void GenerateMachineKey(string[] argv)
        {
            int len = 128;
            if (argv.Length > 0)
                len = int.Parse(argv[0]);
            byte[] buff = new byte[len / 2];
            RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
            rng.GetBytes(buff);
            StringBuilder sb = new StringBuilder(len);
            for (int i = 0; i < buff.Length; i++)
                sb.Append(string.Format("{0:X2}", buff[i]));
            Console.WriteLine(sb);
        }

Here's the Membership section from the web.config

<membership userIsOnlineTimeWindow="20" defaultProvider="EfMembershipProvider">
      <providers>
        <clear />
        <add name="EfMembershipProvider"
             type="Company.Namespace.EfMembershipProvider,Assembly" 
             connectionStringName="ApplicationServices"
             enablePasswordRetrieval="false" 
             enablePasswordReset="true" 
             requiresQuestionAndAnswer="false" 
             requiresUniqueEmail="false" 
             maxInvalidPasswordAttempts="5" 
             minRequiredPasswordLength="6" 
             minRequiredNonalphanumericCharacters="0" 
             passwordAttemptWindow="10" 
             applicationName="/facade" 
             description="Entity Framework Membership Provider" />
      </providers>
</membership>

It's important to always give an applicationName, by default this will be the web root of your application which can lead to confusion and problems when you deploy your solution to a live server environment.

You can customise the Profile and RoleManager Providers too, but I've left these as using the standard System.Web.Profile.SqlProfileProvider and System.Web.Security.SqlRoleProvider types.

Here's my data context class that defines the data sets (tables) from the aspnetdb and my custom membership provider class. The "ApplicationServices" in the constructor is the name of the connection string to the aspnetdb database from the web.config

        public class MembershipContext : DbContext
        {
            public MembershipContext()
                : base("ApplicationServices")
            { }

            public DbSet<User> UserData { get; set; }
            public DbSet<Member> MembershipData { get; set; }
            public DbSet<Application> ApplicationData { get; set; }
            public DbSet<UserRoles> UserRoleData { get; set; }
            public DbSet<Profile> ProfileData { get; set; }
        }

Here's the class file (Assembly) that defines the classes used in the data context, overrides the MembershipProvider properties and methods and implements a custom MembershipUser object to include the extra columns I added to the database.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Data.Entity;
using System.ComponentModel.DataAnnotations;
using System.Web.Configuration;
using System.Collections.Specialized;
using System.Configuration.Provider;
using System.Configuration;
using System.Data;
using System.Security.Cryptography;
using System.Text;
using System.Data.SqlTypes;

namespace Company.Namespace
{    
    [Table("aspnet_Users")]
    public class User
    {
        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public int Id { get; set; }
        public Guid ApplicationId { get; set; }
        [Key]
        public Guid UserId { get; set; }
        public string UserName { get; set; }
        public string LoweredUserName { get; set; }
        public string MobileAlias { get; set; }
        public bool IsAnonymous { get; set; }
        public DateTime LastActivityDate { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
    }

    [Table("aspnet_Membership")]
    public class Member
    {
        [ForeignKey("Application")]
        public Guid ApplicationId { get; set; }       
        public virtual Application Application { get; set; }
        [Key]
        [ForeignKey("User")]        
        public Guid UserId { get; set; }   
        public virtual User User { get; set; }
        public string Password { get; set; }
        public int PasswordFormat { get; set; }
        public string PasswordSalt { get; set; }
        public string MobilePIN { get; set; }
        public string Email { get; set; }
        public string LoweredEmail { get; set; }
        public string PasswordQuestion { get; set; }
        public string PasswordAnswer { get; set; }
        public bool IsApproved { get; set; }
        public bool IsLockedOut { get; set; }
        public DateTime CreateDate { get; set; }
        public DateTime LastLoginDate { get; set; }
        public DateTime LastPasswordChangedDate { get; set; }
        public DateTime LastLockoutDate { get; set; }
        public int FailedPasswordAttemptCount { get; set; }
        public DateTime FailedPasswordAttemptWindowStart { get; set; }
        public int FailedPasswordAnswerAttemptCount { get; set; }
        public DateTime FailedPasswordAnswerAttemptWindowStart { get; set; }
        public string Comment { get; set; }
    }

    [Table("aspnet_Applications")]
    public class Application
    {
        public string ApplicationName { get; set; }
        public string LoweredApplicationName { get; set; }
        [Key]
        public Guid ApplicationId { get; set; }
        public string Description { get; set; }
    }

    [Table("aspnet_UsersInRoles")]
    public class UserRoles
    {
        [Key]
        [Column(Order=1)]
        public Guid UserId { get; set; }
        [Key]
        [Column(Order = 2)]
        public Guid RoleId { get; set; }
    }

    [Table("aspnet_Profile")]
    public class Profile
    {
        [Key]
        public Guid UserId { get; set; }
        public string PropertyNames { get; set; }
        public string PropertyValuesString { get; set; }
        public byte[] PropertyValuesBinary { get; set; }
        public DateTime LastUpdatedDate { get; set; }
    }

    public class EfMembershipProvider : MembershipProvider
    {
        //
        // Global connection string, generated password length, generic exception message, event log info.
        //

        private int newPasswordLength = 8;
        private string exceptionMessage = "An exception occurred. Please check the Log.";

        //
        // Used when determining encryption key values.
        //

        private MachineKeySection machineKey;

        //
        // If false, exceptions are thrown to the caller. If true,
        // exceptions are written to the event log.
        //

        private bool pWriteExceptionsToEventLog;

        public bool WriteExceptionsToEventLog
        {
            get { return pWriteExceptionsToEventLog; }
            set { pWriteExceptionsToEventLog = value; }
        }

        //
        // System.Configuration.Provider.ProviderBase.Initialize Method
        //        

        public override void Initialize(string name, NameValueCollection config)
        {
            //
            // Initialize values from web.config.
            //

            if (config == null)
                throw new ArgumentNullException("config");

            if (name == null || name.Length == 0)
                name = "EfMembershipProvider";

            if (String.IsNullOrEmpty(config["description"]))
            {
                config.Remove("description");
                config.Add("description", "Entity Framework Membership Provider");
            }

            // Initialize the abstract base class.
            base.Initialize(name, config);

            pApplicationName = GetConfigValue(config["applicationName"], System.Web.Hosting.HostingEnvironment.ApplicationVirtualPath);
            pMaxInvalidPasswordAttempts = Convert.ToInt32(GetConfigValue(config["maxInvalidPasswordAttempts"], "5"));
            pPasswordAttemptWindow = Convert.ToInt32(GetConfigValue(config["passwordAttemptWindow"], "10"));
            pMinRequiredNonAlphanumericCharacters = Convert.ToInt32(GetConfigValue(config["minRequiredNonAlphanumericCharacters"], "1"));
            pMinRequiredPasswordLength = Convert.ToInt32(GetConfigValue(config["minRequiredPasswordLength"], "7"));
            pPasswordStrengthRegularExpression = Convert.ToString(GetConfigValue(config["passwordStrengthRegularExpression"], ""));
            pEnablePasswordReset = Convert.ToBoolean(GetConfigValue(config["enablePasswordReset"], "true"));
            pEnablePasswordRetrieval = Convert.ToBoolean(GetConfigValue(config["enablePasswordRetrieval"], "true"));
            pRequiresQuestionAndAnswer = Convert.ToBoolean(GetConfigValue(config["requiresQuestionAndAnswer"], "false"));
            pRequiresUniqueEmail = Convert.ToBoolean(GetConfigValue(config["requiresUniqueEmail"], "true"));
            pWriteExceptionsToEventLog = Convert.ToBoolean(GetConfigValue(config["writeExceptionsToEventLog"], "true"));

            string temp_format = config["passwordFormat"];
            if (temp_format == null)
            {
                temp_format = "Hashed";
            }

            switch (temp_format)
            {
                case "Hashed":
                    pPasswordFormat = MembershipPasswordFormat.Hashed;
                    break;
                case "Encrypted":
                    pPasswordFormat = MembershipPasswordFormat.Encrypted;
                    break;
                case "Clear":
                    pPasswordFormat = MembershipPasswordFormat.Clear;
                    break;
                default:
                    throw new ProviderException("Password format not supported.");
            }            

            // Get encryption and decryption key information from the configuration.
            //Configuration cfg = WebConfigurationManager.OpenWebConfiguration(System.Web.Hosting.HostingEnvironment.ApplicationVirtualPath);
            //machineKey = (MachineKeySection)cfg.GetSection("system.web/machineKey");
            machineKey = (MachineKeySection)WebConfigurationManager.GetSection("system.web/machineKey");

            if (machineKey.ValidationKey.Contains("AutoGenerate"))
                if (PasswordFormat != MembershipPasswordFormat.Clear)
                    throw new ProviderException("Hashed or Encrypted passwords are not supported with auto-generated keys.");
        }

        //
        // A helper function to retrieve config values from the configuration file.
        //

        private string GetConfigValue(string configValue, string defaultValue)
        {
            if (String.IsNullOrEmpty(configValue))
                return defaultValue;

            return configValue;
        }

        //
        // System.Web.Security.MembershipProvider properties.
        //

        private string pApplicationName;
        private bool pEnablePasswordReset;
        private bool pEnablePasswordRetrieval;
        private bool pRequiresQuestionAndAnswer;
        private bool pRequiresUniqueEmail;
        private int pMaxInvalidPasswordAttempts;
        private int pPasswordAttemptWindow;
        private MembershipPasswordFormat pPasswordFormat;

        public override string ApplicationName
        {
            get { return pApplicationName; }
            set { pApplicationName = value; }
        }

        public override bool EnablePasswordReset
        {
            get { return pEnablePasswordReset; }
        }


        public override bool EnablePasswordRetrieval
        {
            get { return pEnablePasswordRetrieval; }
        }


        public override bool RequiresQuestionAndAnswer
        {
            get { return pRequiresQuestionAndAnswer; }
        }


        public override bool RequiresUniqueEmail
        {
            get { return pRequiresUniqueEmail; }
        }


        public override int MaxInvalidPasswordAttempts
        {
            get { return pMaxInvalidPasswordAttempts; }
        }


        public override int PasswordAttemptWindow
        {
            get { return pPasswordAttemptWindow; }
        }


        public override MembershipPasswordFormat PasswordFormat
        {
            get { return pPasswordFormat; }
        }

        private int pMinRequiredNonAlphanumericCharacters;

        public override int MinRequiredNonAlphanumericCharacters
        {
            get { return pMinRequiredNonAlphanumericCharacters; }
        }

        private int pMinRequiredPasswordLength;

        public override int MinRequiredPasswordLength
        {
            get { return pMinRequiredPasswordLength; }
        }

        private string pPasswordStrengthRegularExpression;

        public override string PasswordStrengthRegularExpression
        {
            get { return pPasswordStrengthRegularExpression; }
        }

        //
        // System.Web.Security.MembershipProvider methods.
        //

        //
        // MembershipProvider.ChangePassword
        //

        public override bool ChangePassword(string username, string oldPwd, string newPwd)
        {
            if (!ValidateUser(username, oldPwd))
                return false;

            ValidatePasswordEventArgs args =
              new ValidatePasswordEventArgs(username, newPwd, true);

            OnValidatingPassword(args);

            if (args.Cancel)
                if (args.FailureInformation != null)
                    throw args.FailureInformation;
                else
                    throw new MembershipPasswordException("Change password canceled due to new password validation failure.");

            try
            {
                using (Data.MembershipContext context = new Data.MembershipContext())
                {
                    Member member = context.MembershipData
                        .Where(m => m.User.UserName.Equals(username)
                          && m.Application.ApplicationName.Equals(pApplicationName))
                        .FirstOrDefault();
                    if (member != null)
                    {
                        member.Password = EncodePassword(newPwd);
                        member.LastPasswordChangedDate = DateTime.Now;
                        context.Entry(member).State = EntityState.Modified;
                        context.SaveChanges();
                        return true;
                    }
                }
            }
            catch (Exception e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "ChangePassword");

                    throw new ProviderException(exceptionMessage);
                }
                else
                {
                    throw e;
                }
            }
            return false;
        }

        //
        // MembershipProvider.ChangePasswordQuestionAndAnswer
        //

        public override bool ChangePasswordQuestionAndAnswer(string username,
                      string password,
                      string newPwdQuestion,
                      string newPwdAnswer)
        {
            if (!ValidateUser(username, password))
                return false;

            try
            {
                using (Data.MembershipContext context = new Data.MembershipContext())
                {
                    Member member = context.MembershipData
                        .Where(m => m.User.UserName.Equals(username)
                          && m.Application.ApplicationName.Equals(pApplicationName))
                        .FirstOrDefault();
                    if (member != null)
                    {
                        member.PasswordQuestion = newPwdQuestion;
                        member.PasswordAnswer = newPwdAnswer;
                        context.Entry(member).State = EntityState.Modified;
                        context.SaveChanges();
                        return true;
                    }
                }
            }
            catch (Exception e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "ChangePasswordQuestionAndAnswer");

                    throw new ProviderException(exceptionMessage);
                }
                else
                {
                    throw e;
                }
            }

            return false;
        }

        //
        // MembershipProvider.CreateUser
        //

        public override MembershipUser CreateUser(string username,
                 string password,
                 string email,
                 string passwordQuestion,
                 string passwordAnswer,
                 bool isApproved,
                 object providerUserKey,
                 out MembershipCreateStatus status)
        {
            ValidatePasswordEventArgs args =
              new ValidatePasswordEventArgs(username, password, true);

            OnValidatingPassword(args);

            if (args.Cancel)
            {
                status = MembershipCreateStatus.InvalidPassword;
                return null;
            }

            if (RequiresUniqueEmail && GetUserNameByEmail(email) != "")
            {
                status = MembershipCreateStatus.DuplicateEmail;
                return null;
            }

            MembershipUser u = GetUser(username, false);

            if (u == null)
            {
                DateTime createDate = DateTime.Now;

                if (providerUserKey == null)
                {
                    providerUserKey = Guid.NewGuid();
                }
                else
                {
                    if (!(providerUserKey is Guid))
                    {
                        status = MembershipCreateStatus.InvalidProviderUserKey;
                        return null;
                    }
                }

                Application application = null;

                using (Data.MembershipContext context = new Data.MembershipContext())
                {
                    application = context.ApplicationData
                        .Where(a => a.ApplicationName.Equals(pApplicationName))
                        .FirstOrDefault();
                }

                User user = new User()
                {
                    UserId = (Guid)providerUserKey,
                    UserName = username,
                    LoweredUserName = username.ToLower(),
                    LastActivityDate = createDate,
                    ApplicationId = application.ApplicationId
                };

                Member member = new Member()
                {
                    Password = EncodePassword(password),
                    Email = email,
                    PasswordQuestion = passwordQuestion,
                    PasswordAnswer = EncodePassword(passwordAnswer),
                    PasswordSalt = CreateSalt(),
                    IsApproved = isApproved,                    
                    Comment = string.Empty,
                    CreateDate = createDate,
                    LastPasswordChangedDate = createDate,
                    IsLockedOut = false,
                    FailedPasswordAttemptCount = 0,
                    FailedPasswordAttemptWindowStart = createDate,
                    FailedPasswordAnswerAttemptCount = 0,
                    FailedPasswordAnswerAttemptWindowStart = createDate,
                    Application = application,
                    LastLockoutDate = SqlDateTime.MinValue.Value,
                    LastLoginDate = SqlDateTime.MinValue.Value,
                    User = user
                };

                try
                {
                    using (Data.MembershipContext context = new Data.MembershipContext())
                    {
                        context.Entry(member).State = EntityState.Added;
                        context.Entry(member.Application).State = EntityState.Unchanged;
                        context.SaveChanges();
                        status = MembershipCreateStatus.Success;
                    }
                }
                catch (Exception e)
                {
                    if (WriteExceptionsToEventLog)
                    {
                        WriteToEventLog(e, "CreateUser");
                    }
                    status = MembershipCreateStatus.ProviderError;
                }
                return GetUser(username, false);
            }
            else
            {
                status = MembershipCreateStatus.DuplicateUserName;
            }
            return null;
        }

        //
        // MembershipProvider.DeleteUser
        //

        public override bool DeleteUser(string username, bool deleteAllRelatedData)
        {
            try
            {
                using (Data.MembershipContext context = new Data.MembershipContext())
                {
                    Member member = context.MembershipData
                        .Where(m => m.User.UserName.Equals(username)
                            && m.Application.ApplicationName.Equals(pApplicationName))
                        .FirstOrDefault();

                    if (member != null)
                    {
                        User user = context.UserData.Attach(member.User);
                        
                        //Delete Roles
                        var userRoles = context.UserRoleData
                            .Where(ur => ur.UserId.Equals(user.UserId))
                            .ToList();
                        userRoles.ForEach(ur => context.UserRoleData.Remove(ur));
                        context.SaveChanges();
                        
                        //Delete Profile
                        var userProfiles = context.ProfileData
                            .Where(p => p.UserId.Equals(user.UserId))
                            .ToList();
                        userProfiles.ForEach(p => context.ProfileData.Remove(p));
                        context.SaveChanges();

                        context.Entry(user).State = EntityState.Deleted;
                        context.Entry(member).State = EntityState.Deleted;                                                                     
                        context.SaveChanges();
                        return true;
                    }
                }
            }
            catch (Exception e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "DeleteUser");

                    throw new ProviderException(exceptionMessage);
                }
                else
                {
                    throw e;
                }
            }
            return false;
        }

        //
        // MembershipProvider.GetAllUsers
        //

        public override MembershipUserCollection GetAllUsers(int pageIndex, int pageSize, out int totalRecords)
        {
            int startIndex = pageSize * pageIndex;
            MembershipUserCollection users = new MembershipUserCollection();

            try
            {
                using (Data.MembershipContext context = new Data.MembershipContext())
                {
                    var members = context.MembershipData
                        .Where(m => m.Application.ApplicationName.Equals(ApplicationName))
                        .OrderBy(m => m.User.UserName)
                        .Skip(startIndex)
                        .Take(pageSize);
                    totalRecords = members.Count();
                    foreach (Member member in members)
                    {
                        EfMembershipUser user = new EfMembershipUser(
                            Name,
                            member.User.UserName,
                            member.User.UserId,
                            member.Email,
                            member.PasswordQuestion,
                            member.Comment,
                            member.IsApproved,
                            member.IsLockedOut,
                            member.CreateDate,
                            member.LastLoginDate,
                            member.User.LastActivityDate,
                            member.LastPasswordChangedDate,
                            member.LastLockoutDate);
                        user.Id = member.User.Id;
                        user.FirstName = member.User.FirstName;
                        user.LastName = member.User.LastName;
                        users.Add(user);
                    }
                }
            }
            catch (Exception e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "GetAllUsers ");

                    throw new ProviderException(exceptionMessage);
                }
                else
                {
                    throw e;
                }
            }
            return users;
        }       

        //
        // MembershipProvider.GetNumberOfUsersOnline
        //

        public override int GetNumberOfUsersOnline()
        {
            TimeSpan onlineSpan = new TimeSpan(0, System.Web.Security.Membership.UserIsOnlineTimeWindow, 0);
            DateTime compareTime = DateTime.Now.Subtract(onlineSpan);
            int numOnline = 0;

            try
            {
                using (Data.MembershipContext context = new Data.MembershipContext())
                {
                    numOnline = context.MembershipData
                        .Where(m => m.User.LastActivityDate > compareTime
                            && m.Application.ApplicationName.Equals(pApplicationName))
                        .Count();
                }
            }
            catch (Exception e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "GetNumberOfUsersOnline");

                    throw new ProviderException(exceptionMessage);
                }
                else
                {
                    throw e;
                }
            }

            return numOnline;
        }

        //
        // MembershipProvider.GetPassword
        //

        public override string GetPassword(string username, string answer)
        {
            string password = string.Empty;
            string passwordAnswer = string.Empty;

            if (!EnablePasswordRetrieval)
            {
                throw new ProviderException("Password Retrieval Not Enabled.");
            }

            if (PasswordFormat == MembershipPasswordFormat.Hashed)
            {
                throw new ProviderException("Cannot retrieve Hashed passwords.");
            }

            try
            {
                using (Data.MembershipContext context = new Data.MembershipContext())
                {
                    var member = context.MembershipData
                        .Where(m => m.User.UserName.Equals(username) &&
                            m.Application.ApplicationName.Equals(pApplicationName))
                        .FirstOrDefault();

                    if (member != null)
                    {
                        if (member.IsLockedOut)
                            throw new MembershipPasswordException("The supplied user is locked out.");
                        password = member.Password;
                        passwordAnswer = member.PasswordAnswer;
                    }
                    else
                    {
                        throw new MembershipPasswordException("The supplied user name is not found.");
                    }
                }
            }
            catch (Exception e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "GetPassword");

                    throw new ProviderException(exceptionMessage);
                }
                else
                {
                    throw e;
                }
            }

            if (RequiresQuestionAndAnswer && !CheckPassword(answer, passwordAnswer))
            {
                UpdateFailureCount(username, "passwordAnswer");

                throw new MembershipPasswordException("Incorrect password answer.");
            }


            if (PasswordFormat == MembershipPasswordFormat.Encrypted)
            {
                password = UnEncodePassword(password);
            }

            return password;
        }

        //
        // MembershipProvider.GetUser(string, bool)
        //

        public override MembershipUser GetUser(string username, bool userIsOnline)
        {
            EfMembershipUser user = null;

            try
            {
                using (Data.MembershipContext context = new Data.MembershipContext())
                {
                    Member member = context.MembershipData
                        .Where(m => m.User.UserName.Equals(username)
                            && m.Application.ApplicationName.Equals(pApplicationName))
                        .FirstOrDefault();

                    if (member != null)
                    {
                        user = new EfMembershipUser(
                            Name,
                            member.User.UserName,
                            member.User.UserId,
                            member.Email,
                            member.PasswordQuestion,
                            member.Comment,
                            member.IsApproved,
                            member.IsLockedOut,
                            member.CreateDate,
                            member.LastLoginDate,
                            member.User.LastActivityDate,
                            member.LastPasswordChangedDate,
                            member.LastLockoutDate);
                        user.Id = member.User.Id;
                        user.FirstName = member.User.FirstName;
                        user.LastName = member.User.LastName;

                        if (userIsOnline)
                        {
                            member.User.LastActivityDate = DateTime.Now;
                            context.Entry(member).State = EntityState.Modified;
                            context.SaveChanges();
                        }
                    }
                }
            }
            catch (Exception e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "GetUser(String, Boolean)");

                    throw new ProviderException(exceptionMessage);
                }
                else
                {
                    throw e;
                }
            }

            return user;
        }

        //
        // MembershipProvider.GetUser(object, bool)
        //

        public override MembershipUser GetUser(object providerUserKey, bool userIsOnline)
        {
            EfMembershipUser user = null;

            try
            {
                using (Data.MembershipContext context = new Data.MembershipContext())
                {
                    Member member = context.MembershipData
                        .Where(m => m.User.UserId.Equals((Guid)providerUserKey)
                            && m.Application.ApplicationName.Equals(pApplicationName))
                        .FirstOrDefault();

                    if (member != null)
                    {
                        user = new EfMembershipUser(
                            Name,
                            member.User.UserName,
                            member.User.UserId,
                            member.Email,
                            member.PasswordQuestion,
                            member.Comment,
                            member.IsApproved,
                            member.IsLockedOut,
                            member.CreateDate,
                            member.LastLoginDate,
                            member.User.LastActivityDate,
                            member.LastPasswordChangedDate,
                            member.LastLockoutDate);
                        user.Id = member.User.Id;
                        user.FirstName = member.User.FirstName;
                        user.LastName = member.User.LastName;

                        if (userIsOnline)
                        {
                            member.User.LastActivityDate = DateTime.Now;
                            context.Entry(member).State = EntityState.Modified;
                            context.SaveChanges();
                        }
                    }
                }
            }
            catch (Exception e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "GetUser(String, Boolean)");

                    throw new ProviderException(exceptionMessage);
                }
                else
                {
                    throw e;
                }
            }

            return user;
        }

        //
        // MembershipProvider.UnlockUser
        //

        public override bool UnlockUser(string username)
        {
            try
            {
                using (Data.MembershipContext context = new Data.MembershipContext())
                {
                    var member = context.MembershipData
                        .Where(m => m.User.UserName.Equals(username)
                            && m.Application.ApplicationName.Equals(pApplicationName))
                        .FirstOrDefault();
                    if (member != null)
                    {
                        member.IsLockedOut = false;
                        member.LastLockoutDate = DateTime.Now;
                        context.Entry(member).State = EntityState.Modified;
                        context.SaveChanges();
                        return true;
                    }
                }
            }
            catch (Exception e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "UnlockUser");

                    throw new ProviderException(exceptionMessage);
                }
                else
                {
                    throw e;
                }
            }
            return false;
        }

        //
        // MembershipProvider.GetUserNameByEmail
        //

        public override string GetUserNameByEmail(string email)
        {
            string username = string.Empty;
            try
            {
                using (Data.MembershipContext context = new Data.MembershipContext())
                {
                    var member = context.MembershipData
                        .Where(m => m.Email.Equals(email) && m.Application.ApplicationName.Equals(pApplicationName))
                        .FirstOrDefault();
                    if (member != null)
                    {
                        username = member.User.UserName;
                    }
                }
            }
            catch (Exception e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "GetUserNameByEmail");

                    throw new ProviderException(exceptionMessage);
                }
                else
                {
                    throw e;
                }
            }

            return username;
        }

        //
        // MembershipProvider.ResetPassword
        //

        public override string ResetPassword(string username, string answer)
        {
            string passwordAnswer = "";

            if (!EnablePasswordReset)
            {
                throw new NotSupportedException("Password reset is not enabled.");
            }

            if (answer == null && RequiresQuestionAndAnswer)
            {
                UpdateFailureCount(username, "passwordAnswer");

                throw new ProviderException("Password answer required for password reset.");
            }

            string newPassword =
              System.Web.Security.Membership.GeneratePassword(newPasswordLength, MinRequiredNonAlphanumericCharacters);

            ValidatePasswordEventArgs args =
              new ValidatePasswordEventArgs(username, newPassword, true);

            OnValidatingPassword(args);

            if (args.Cancel)
                if (args.FailureInformation != null)
                    throw args.FailureInformation;
                else
                    throw new MembershipPasswordException("Reset password canceled due to password validation failure.");

            try
            {
                using (Data.MembershipContext context = new Data.MembershipContext())
                {
                    var member = context.MembershipData
                        .Where(m => m.User.UserName.Equals(username)
                            && m.Application.ApplicationName.Equals(pApplicationName))
                        .FirstOrDefault();
                    if (member != null)
                    {
                        if (member.IsLockedOut)
                            throw new MembershipPasswordException("The supplied user is locked out.");

                        passwordAnswer = member.PasswordAnswer;
                    }
                    else
                    {
                        throw new MembershipPasswordException("The supplied user name is not found.");
                    }

                    if (RequiresQuestionAndAnswer && !CheckPassword(answer, passwordAnswer))
                    {
                        UpdateFailureCount(username, "passwordAnswer");

                        throw new MembershipPasswordException("Incorrect password answer.");
                    }

                    member.Password = EncodePassword(newPassword);
                    member.LastPasswordChangedDate = DateTime.Now;
                    context.Entry(member).State = EntityState.Modified;
                    context.SaveChanges();
                    return newPassword;
                }
            }
            catch (Exception e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "ResetPassword");

                    throw new ProviderException(exceptionMessage);
                }
                else
                {
                    throw e;
                }
            }
        }

        //
        // MembershipProvider.UpdateUser
        //

        public override void UpdateUser(MembershipUser user)
        {
            EfMembershipUser efUser = (EfMembershipUser)user;
            try
            {
                using (Data.MembershipContext context = new Data.MembershipContext())
                {
                    var member = context.MembershipData
                        .Where(m => m.User.UserId.Equals((Guid)efUser.ProviderUserKey))
                        .FirstOrDefault();
                    if (member != null)
                    {
                        member.Comment = efUser.Comment;
                        member.Email = efUser.Email;
                        member.User.FirstName = efUser.FirstName;
                        member.IsApproved = efUser.IsApproved;
                        member.User.LastName = efUser.LastName;
                        context.SaveChanges();
                    }                    
                }
            }
            catch (Exception e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "UpdateUser");

                    throw new ProviderException(exceptionMessage);
                }
                else
                {
                    throw e;
                }
            }
        }
       
        //
        // MembershipProvider.ValidateUser
        //

        public override bool ValidateUser(string username, string password)
        {
            bool isValid = false;

            try
            {
                using (Data.MembershipContext context = new Data.MembershipContext())
                {
                    var member = context.MembershipData
                        .Where(m => m.User.UserName.Equals(username)
                            && m.Application.ApplicationName.Equals(pApplicationName)
                            && m.IsLockedOut == false)
                        .FirstOrDefault();
                    if (member != null)
                    {
                        member.LastLoginDate = DateTime.Now;
                        if (member.IsApproved)
                        {
                            if (CheckPassword(password, member.Password))
                            {
                                isValid = true;
                                context.Entry(member).State = EntityState.Modified;
                                context.SaveChanges();
                            }
                            else
                            {
                                UpdateFailureCount(username, "password");
                            }
                        }
                    }
                    else
                    {
                        return false;
                    }
                }
            }
            catch (Exception e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "ValidateUser");

                    throw new ProviderException(exceptionMessage);
                }
                else
                {
                    throw e;
                }
            }
            return isValid;
        }


        //
        // UpdateFailureCount
        //   A helper method that performs the checks and updates associated with
        // password failure tracking.
        //

        private void UpdateFailureCount(string username, string failureType)
        {
            DateTime windowStart = new DateTime();
            int failureCount = 0;

            try
            {
                using (Data.MembershipContext context = new Data.MembershipContext())
                {
                    var member = context.MembershipData
                        .Where(m => m.User.UserName.Equals(username)
                            && m.Application.ApplicationName.Equals(pApplicationName))
                        .FirstOrDefault();
                    if (member != null)
                    {
                        if (failureType == "password")
                        {
                            failureCount = member.FailedPasswordAttemptCount;
                            windowStart = member.FailedPasswordAttemptWindowStart;
                        }

                        if (failureType == "passwordAnswer")
                        {
                            failureCount = member.FailedPasswordAnswerAttemptCount;
                            windowStart = member.FailedPasswordAttemptWindowStart;
                        }

                        DateTime windowEnd = windowStart.AddMinutes(PasswordAttemptWindow);

                        if (failureCount == 0 || DateTime.Now > windowEnd)
                        {
                            // First password failure or outside of PasswordAttemptWindow. 
                            // Start a new password failure count from 1 and a new window starting now.

                            if (failureType == "password")
                            {
                                member.FailedPasswordAttemptCount = 1;
                                member.FailedPasswordAttemptWindowStart = DateTime.Now;
                            }

                            if (failureType == "passwordAnswer")
                            {
                                member.FailedPasswordAnswerAttemptCount = 1;
                                member.FailedPasswordAnswerAttemptWindowStart = DateTime.Now;
                            }
                        }
                        else
                        {
                            if (failureCount++ >= MaxInvalidPasswordAttempts)
                            {
                                // Password attempts have exceeded the failure threshold. Lock out
                                // the user.

                                member.IsLockedOut = true;
                                member.LastLockoutDate = DateTime.Now;
                            }
                            else
                            {
                                if (failureType == "password")
                                    member.FailedPasswordAttemptCount = failureCount;

                                if (failureType == "passwordAnswer")
                                    member.FailedPasswordAnswerAttemptCount = failureCount;
                            }
                        }
                        context.Entry(member).State = EntityState.Modified;
                        context.SaveChanges();
                    }
                }
            }
            catch (Exception e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "UpdateFailureCount");

                    throw new ProviderException(exceptionMessage);
                }
                else
                {
                    throw e;
                }
            }
        }

        //
        // CheckPassword
        //   Compares password values based on the MembershipPasswordFormat.
        //

        private bool CheckPassword(string password, string dbpassword)
        {
            string pass1 = password;
            string pass2 = dbpassword;

            switch (PasswordFormat)
            {
                case MembershipPasswordFormat.Encrypted:
                    pass2 = UnEncodePassword(dbpassword);
                    break;
                case MembershipPasswordFormat.Hashed:
                    pass1 = EncodePassword(password);
                    break;
                default:
                    break;
            }

            if (pass1 == pass2)
            {
                return true;
            }

            return false;
        }


        //
        // EncodePassword
        //   Encrypts, Hashes, or leaves the password clear based on the PasswordFormat.
        //

        private string EncodePassword(string password)
        {
            string encodedPassword = password;

            if (!string.IsNullOrEmpty(password))
            {
                switch (PasswordFormat)
                {
                    case MembershipPasswordFormat.Clear:
                        break;
                    case MembershipPasswordFormat.Encrypted:
                        encodedPassword =
                          Convert.ToBase64String(EncryptPassword(Encoding.Unicode.GetBytes(password)));
                        break;
                    case MembershipPasswordFormat.Hashed:
                        HMACSHA1 hash = new HMACSHA1();
                        hash.Key = HexToByte(machineKey.ValidationKey);
                        encodedPassword =
                          Convert.ToBase64String(hash.ComputeHash(Encoding.Unicode.GetBytes(password)));
                        break;
                    default:
                        throw new ProviderException("Unsupported password format.");
                }
            }

            return encodedPassword;
        }


        //
        // UnEncodePassword
        //   Decrypts or leaves the password clear based on the PasswordFormat.
        //

        private string UnEncodePassword(string encodedPassword)
        {
            string password = encodedPassword;

            switch (PasswordFormat)
            {
                case MembershipPasswordFormat.Clear:
                    break;
                case MembershipPasswordFormat.Encrypted:
                    password =
                      Encoding.Unicode.GetString(DecryptPassword(Convert.FromBase64String(password)));
                    break;
                case MembershipPasswordFormat.Hashed:
                    throw new ProviderException("Cannot unencode a hashed password.");
                default:
                    throw new ProviderException("Unsupported password format.");
            }

            return password;
        }

        //
        // HexToByte
        //   Converts a hexadecimal string to a byte array. Used to convert encryption
        // key values from the configuration.
        //

        private byte[] HexToByte(string hexString)
        {
            byte[] returnBytes = new byte[hexString.Length / 2];
            for (int i = 0; i < returnBytes.Length; i++)
                returnBytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);
            return returnBytes;
        }

        /// <summary>
        /// Creates a random 128 password salt
        /// </summary>
        /// <returns></returns>
        private static string CreateSalt()
        {
            RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
            byte[] buff = new byte[32];
            rng.GetBytes(buff);

            return Convert.ToBase64String(buff);
        }


        //
        // MembershipProvider.FindUsersByName
        //

        public override MembershipUserCollection FindUsersByName(string usernameToMatch, int pageIndex, int pageSize, out int totalRecords)
        {
            int startIndex = pageSize * pageIndex;
            MembershipUserCollection users = new MembershipUserCollection();
            EfMembershipUser user = null;
            try
            {
                using (Data.MembershipContext context = new Data.MembershipContext())
                {
                    var members = context.MembershipData
                        .Where(m => m.User.UserName.StartsWith(usernameToMatch.Replace("%", ""))
                            && m.Application.ApplicationName.Equals(pApplicationName))
                        .OrderBy(m => m.User.UserName)
                        .Skip(startIndex)
                        .Take(pageSize);

                    totalRecords = members.Count();

                    foreach(Member m in members.ToList())
                    {
                        user = new EfMembershipUser(
                            Name,
                            m.User.UserName,
                            m.User.UserId,
                            m.Email,
                            m.PasswordQuestion,
                            m.Comment,
                            m.IsApproved,
                            m.IsLockedOut,
                            m.CreateDate,
                            m.LastLoginDate,
                            m.User.LastActivityDate,
                            m.LastPasswordChangedDate,
                            m.LastLockoutDate);
                        user.Id = m.User.Id;
                        user.FirstName = m.User.FirstName;
                        user.LastName = m.User.LastName;
                        users.Add(user);
                    }                    
                }
            }
            catch (Exception e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "FindUsersByName");

                    throw new ProviderException(exceptionMessage);
                }
                else
                {
                    throw e;
                }
            }
            return users;
        }
       
        //
        // MembershipProvider.FindUsersByEmail
        //

        public override MembershipUserCollection FindUsersByEmail(string emailToMatch, int pageIndex, int pageSize, out int totalRecords)
        {
            int startIndex = pageSize * pageIndex;
            MembershipUserCollection users = new MembershipUserCollection();
            EfMembershipUser user = null;
            try
            {
                using (Data.MembershipContext context = new Data.MembershipContext())
                {
                    var members = context.MembershipData
                        .Where(m => m.Email.Contains(emailToMatch)
                            && m.Application.ApplicationName.Equals(pApplicationName))
                        .OrderBy(m => m.User.UserName)
                        .Skip(startIndex)
                        .Take(pageSize);

                    totalRecords = members.Count();

                    foreach (Member m in members.ToList())
                    {
                        user = new EfMembershipUser(
                            Name,
                            m.User.UserName,
                            m.User.UserId,
                            m.Email,
                            m.PasswordQuestion,
                            m.Comment,
                            m.IsApproved,
                            m.IsLockedOut,
                            m.CreateDate,
                            m.LastLoginDate,
                            m.User.LastActivityDate,
                            m.LastPasswordChangedDate,
                            m.LastLockoutDate);
                        user.Id = m.User.Id;
                        user.FirstName = m.User.FirstName;
                        user.LastName = m.User.LastName;
                        users.Add(user);
                    }          
                }
            }
            catch (Exception e)
            {
                if (WriteExceptionsToEventLog)
                {
                    WriteToEventLog(e, "FindUsersByEmail");

                    throw new ProviderException(exceptionMessage);
                }
                else
                {
                    throw e;
                }
            }
            return users;
        }

        //
        // WriteToEventLog
        //   A helper function that writes exception detail to the event log. Exceptions
        // are written to the event log as a security measure to avoid private database
        // details from being returned to the browser. If a method does not return a status
        // or boolean indicating the action succeeded or failed, a generic exception is also 
        // thrown by the caller.
        //

        private void WriteToEventLog(Exception e, string action)
        {
            string message = action + ": An exception occurred communicating with the data source.\n\n";            
            Log.LogException(message, e, LogCategory.Membership, System.Diagnostics.TraceEventType.Error);
         
        }
    }

    public class EfMembershipUser : MembershipUser
    {
        public int Id {get;set;}
        public string FirstName {get;set;}        
        public string LastName {get;set;}        

        public EfMembershipUser(
            string providername,
            string username,
            object providerUserKey,
            string email,
            string passwordQuestion,
            string comment,
            bool isApproved,
            bool isLockedOut,
            DateTime creationDate,
            DateTime lastLoginDate,
            DateTime lastActivityDate,
            DateTime lastPasswordChangedDate,
            DateTime lastLockedOutDate) :
            base(
                providername,
                username,
                providerUserKey,
                email,
                passwordQuestion,
                comment,
                isApproved,
                isLockedOut,
                creationDate,
                lastLoginDate,
                lastActivityDate,
                lastPasswordChangedDate,
                lastLockedOutDate) { }

        public EfMembershipUser() { }

        public void Delete(EfMembershipUser User)
        {
            User user = GetUserById(User.Id);
            Membership.DeleteUser(user.UserName);
        }

        public void Update(EfMembershipUser User)
        {
            throw new NotImplementedException();
        }

        public static User GetUserById(int Id)
        {
            using (Data.MembershipContext context = new Data.MembershipContext())
            {
                return context.UserData
                    .Where(u => u.Id.Equals(Id))
                    .FirstOrDefault();
            }
        }

        public List<EfMembershipUser> Paged(int maximumRows, int startRowIndex, string search, string filter)
        {
            EfMembershipUser user = new EfMembershipUser();
            List<EfMembershipUser> users = new List<EfMembershipUser>();
            using (Data.MembershipContext context = new Data.MembershipContext())
            {
                List<Member> members = new List<Member>();
                if (!string.IsNullOrEmpty(search))
                {                    
                    members = context.MembershipData
                        .Where(m => m.User.UserName.Contains(search))
                        .OrderBy(m => m.User.UserName)
                        .Skip(startRowIndex)
                        .Take(maximumRows)                        
                        .ToList();                    
                }
                else if (!string.IsNullOrEmpty(filter))
                {
                    members = context.MembershipData
                        .Where(m => m.User.UserName.StartsWith(filter))
                        .OrderBy(m => m.User.UserName)
                        .Skip(startRowIndex)
                        .Take(maximumRows)
                        .ToList();
                }
                else
                {
                    members = context.MembershipData
                       .OrderBy(m => m.User.UserName)
                       .Skip(startRowIndex)
                       .Take(maximumRows)
                       .ToList();
                }
                foreach (Member member in members)
                {
                    user = new EfMembershipUser("EfMembershipProvider",
                        member.User.UserName,
                        member.User.UserId,
                        member.Email,
                        member.PasswordQuestion,
                        member.Comment,
                        member.IsApproved,
                        member.IsLockedOut,
                        member.CreateDate,
                        member.LastLoginDate,
                        member.User.LastActivityDate,
                        member.LastPasswordChangedDate,
                        member.LastLockoutDate);
                    user.Id = member.User.Id;
                    user.FirstName = member.User.FirstName;
                    user.LastName = member.User.LastName; 
                    users.Add(user);
                }                    
            }
            return users;
        }

        public int Count(string search, string filter)
        {
            using (Data.MembershipContext context = new Data.MembershipContext())
            {
                if (!string.IsNullOrEmpty(search))
                {
                    return context.UserData
                        .Where(u => u.UserName.Contains(search))
                        .Count();
                }
                else if (!string.IsNullOrEmpty(filter))
                {
                    return context.UserData
                        .Where(u => u.UserName.StartsWith(filter))
                        .Count();
                }
                else
                {
                    return context.UserData
                        .Count();
                }
            }
        } 
    }
}

I've written a small wrapper for the Enterprise Library database log which is included in the Solution but not seen here.

There is also a Unit Test project with about 30 tests for the custom membership provider.