Asp.net mvc 是否有WCF服务位于ASPNET成员资格之上并提供登录/创建用户功能？

我需要一个WCF服务来支持ASPNET成员资格，并允许我调用ASPNET成员资格的所有方法，如

validateUser

，

createUser

等

我需要这个，因为我有防火墙外的应用程序，需要访问单个中央ASPNET成员数据库。如果它们都在防火墙内，我只需将连接字符串指向数据库即可

Microsoft提供以下服务：

当我看到这一幕时，我想‘太好了——这正是我所需要的’。然后我看了一下界面：

public interface AuthenticationService {

    bool ValidateUser(string username, string password, string customCredential);
    bool Login(string username, string password, string customCredential, bool isPersistent);
    bool IsLoggedIn();
    void Logout();
}

哦！没有“CreateUser”等

我找到了一个基本上满足我需求的Codeproject:。问题是它是ASMX，我需要WFC。这也是一个巨大的代码量，我不知道它测试得有多好

我想我可能需要创建自己的服务来实现这一点，但我相信一定有一个现有的例子。我只是还没找到。我对自己写这篇文章有点厌倦，因为在安全问题上总是有陷阱，我不想错过任何东西

---

幸运的是，我在ASP.NET MVC中使用了

IMembershipService

接口，因此我可以很容易地插入任何我想要的内容。“我自己的服务”是最简单的方法吗？

最简单的方法就是将WCF服务中的

CreateUser

函数路由到您的会员提供商

CreateUser

函数

ResponseType CreateUser(UserContainer user);

实施

public ResponseType CreateUser(UserContainer user)
{
    //map user -> a real user object
    RealUser realUser = Convert(user);
    new MyMembershipProvider().CreateUser(realUserObject);
    return true;
}

---

最简单的方法就是将WCF服务中的

CreateUser

函数路由到您的会员资格提供商

CreateUser

函数

ResponseType CreateUser(UserContainer user);

实施

public ResponseType CreateUser(UserContainer user)
{
    //map user -> a real user object
    RealUser realUser = Convert(user);
    new MyMembershipProvider().CreateUser(realUserObject);
    return true;
}

---

试试看。您必须保护此端点

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Activation;
using System.Text.RegularExpressions;
using System.Web.Security;
namespace Salient.ServiceModel.AspNetProviders
{
    [ServiceContract(Namespace = "Salient.ServiceModel.AspNetProviders", Name = "MembershipProvider")]
    public interface IMembershipProvider
    {
        string ProviderName { get; set; }

        [OperationContract]
        ProviderProperties GetProviderProperties();
        [OperationContract]
        MembershipUser GetUserByKey(object providerUserKey, bool userIsOnline);
        [OperationContract]
        MembershipCreateResult CreateUser(string username, string password,
                                          string email, string passwordQuestion,
                                          string passwordAnswer, bool isApproved,
                                          object providerUserKey);
        [OperationContract]
        MembershipCreateResult AddUser(MembershipUser user);
        [OperationContract]
        bool ChangePasswordQuestionAndAnswer(string username, string password,
                                             string newPasswordQuestion, string newPasswordAnswer);
        [OperationContract]
        string GetPassword(string username, string answer);
        [OperationContract]
        bool ChangePassword(string username, string oldPassword, string newPassword);
        [OperationContract]
        string ResetPassword(string username, string answer);
        [OperationContract]
        void UpdateUser(MembershipUser user);
        [OperationContract]
        bool ValidateUser(string username, string password);
        [OperationContract]
        bool UnlockUser(string userName);
        [OperationContract]
        MembershipUser GetUserByName(string username, bool userIsOnline);
        [OperationContract]
        string GetUserNameByEmail(string email);
        [OperationContract]
        bool DeleteUser(string username, bool deleteAllRelatedData);
        [OperationContract]
        MembershipFindResult GetAllUsers(int pageIndex, int pageSize);
        [OperationContract]
        int GetNumberOfUsersOnline();
        [OperationContract]
        MembershipFindResult FindUsersByName(string usernameToMatch, int pageIndex,
                                             int pageSize);
        [OperationContract]
        MembershipFindResult FindUsersByEmail(string emailToMatch, int pageIndex,
                                              int pageSize);
    }
    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    public class MembershipProvider : IMembershipProvider
    {
        private System.Web.Security.MembershipProvider Provider
        {
            get
            {
                if (string.IsNullOrEmpty(ProviderName))
                {
                    return Membership.Provider;
                }
                return Membership.Providers[ProviderName];
            }
        }
        #region IMembershipProvider Members
        public DateTime TestInput(DateTime date)
        {
            return date;
        }
        public string ProviderName { get; set; }
        public ProviderProperties GetProviderProperties()
        {
            var returnValue = new ProviderProperties
                                  {
                                      ApplicationName = Provider.ApplicationName,
                                      EnablePasswordReset = Provider.EnablePasswordReset,
                                      EnablePasswordRetrieval = Provider.EnablePasswordRetrieval,
                                      MaxInvalidPasswordAttempts = Provider.MaxInvalidPasswordAttempts,
                                      MinRequiredNonAlphanumericCharacters =
                                          Provider.MinRequiredNonAlphanumericCharacters,
                                      MinRequiredPasswordLength = Provider.MinRequiredPasswordLength,
                                      PasswordAttemptWindow = Provider.PasswordAttemptWindow,
                                      PasswordFormat = Provider.PasswordFormat,
                                      PasswordStrengthRegularExpression = Provider.PasswordStrengthRegularExpression,
                                      RequiresQuestionAndAnswer = Provider.RequiresQuestionAndAnswer,
                                      RequiresUniqueEmail = Provider.RequiresUniqueEmail
                                  };
            return returnValue;
        }
        public MembershipUser GetUserByKey(object providerUserKey, bool userIsOnline)
        {
            return Provider.GetUser(providerUserKey, userIsOnline);
        }
        public MembershipCreateResult CreateUser(string username, string password,
                                                 string email, string passwordQuestion,
                                                 string passwordAnswer, bool isApproved,
                                                 object providerUserKey)
        {
            MembershipCreateStatus status;
            MembershipUser user = Provider.CreateUser(username, password, email, passwordQuestion, passwordAnswer,
                                                      isApproved,
                                                      providerUserKey, out status);
            return new MembershipCreateResult(user, status);
        }
        public MembershipCreateResult AddUser(MembershipUser user)
        {
            return new MembershipCreateResult(user, MembershipCreateStatus.DuplicateEmail);
        }
        public bool ChangePasswordQuestionAndAnswer(string username, string password,
                                                    string newPasswordQuestion, string newPasswordAnswer)
        {
            return Provider.ChangePasswordQuestionAndAnswer(username, password, newPasswordQuestion, newPasswordAnswer);
        }
        public string GetPassword(string username, string answer)
        {
            return Provider.GetPassword(username, answer);
        }
        public bool ChangePassword(string username, string oldPassword, string newPassword)
        {
            return Provider.ChangePassword(username, oldPassword, newPassword);
        }
        public string ResetPassword(string username, string answer)
        {
            return Provider.ResetPassword(username, answer);
        }
        public void UpdateUser(MembershipUser user)
        {
            Provider.UpdateUser(user);
        }
        public bool ValidateUser(string username, string password)
        {
            return Provider.ValidateUser(username, password);
        }
        public bool UnlockUser(string userName)
        {
            return Provider.UnlockUser(userName);
        }
        public MembershipUser GetUserByName(string username, bool userIsOnline)
        {
            return Provider.GetUser(username, userIsOnline);
        }
        public string GetUserNameByEmail(string email)
        {
            return Provider.GetUserNameByEmail(email);
        }
        public bool DeleteUser(string username, bool deleteAllRelatedData)
        {
            return Provider.DeleteUser(username, deleteAllRelatedData);
        }
        public MembershipFindResult GetAllUsers(int pageIndex, int pageSize)
        {
            int totalRecords;
            MembershipUserCollection users = Provider.GetAllUsers(pageIndex, pageSize, out totalRecords);
            var list = new List<MembershipUser>();
            foreach (MembershipUser user in users)
            {
                list.Add(user);
            }
            return new MembershipFindResult(list, totalRecords);
        }
        public int GetNumberOfUsersOnline()
        {
            return Provider.GetNumberOfUsersOnline();
        }
        public MembershipFindResult FindUsersByName(string usernameToMatch, int pageIndex,
                                                    int pageSize)
        {
            int totalRecords;
            MembershipUserCollection users = Provider.FindUsersByName(usernameToMatch, pageIndex, pageSize,
                                                                      out totalRecords);
            var list = new List<MembershipUser>();
            foreach (MembershipUser user in users)
            {
                list.Add(user);
            }
            return new MembershipFindResult(list, totalRecords);
        }
        public MembershipFindResult FindUsersByEmail(string emailToMatch, int pageIndex,
                                                     int pageSize)
        {
            int totalRecords;
            MembershipUserCollection users = Provider.FindUsersByEmail(emailToMatch, pageIndex, pageSize,
                                                                       out totalRecords);
            var list = new List<MembershipUser>();
            foreach (MembershipUser user in users)
            {
                list.Add(user);
            }
            return new MembershipFindResult(list, totalRecords);
        }
        #endregion
    }
    [DataContract]
    public class MembershipFindResult
    {
        [DataMember]
        public int RecordCount;
        [DataMember]
        public IEnumerable<MembershipUser> Users;
        public MembershipFindResult()
        {
        }
        public MembershipFindResult(IEnumerable<MembershipUser> users, int recordCount)
        {
            Users = users;
            RecordCount = recordCount;
        }
    }
    [DataContract]
    public class MembershipCreateResult
    {
        [DataMember]
        public MembershipCreateStatus CreateStatus;
        [DataMember]
        public MembershipUser User;
        public MembershipCreateResult()
        {
        }
        public MembershipCreateResult(MembershipUser user, MembershipCreateStatus createStatus)
        {
            User = user;
            CreateStatus = createStatus;
        }
    }
    [DataContract]
    public class ProviderProperties
    {
        public ProviderProperties()
        {
        }
        public ProviderProperties(bool enablePasswordRetrieval, bool enablePasswordReset, bool requiresQuestionAndAnswer,
                                  int maxInvalidPasswordAttempts,
                                  int passwordAttemptWindow, bool requiresUniqueEmail,
                                  MembershipPasswordFormat passwordFormat, int minRequiredPasswordLength,
                                  int minRequiredNonAlphanumericCharacters,
                                  string passwordStrengthRegularExpression, string applicationName)
        {
            EnablePasswordRetrieval = enablePasswordRetrieval;
            EnablePasswordReset = enablePasswordReset;
            RequiresQuestionAndAnswer = requiresQuestionAndAnswer;
            MaxInvalidPasswordAttempts = maxInvalidPasswordAttempts;
            PasswordAttemptWindow = passwordAttemptWindow;
            RequiresUniqueEmail = requiresUniqueEmail;
            PasswordFormat = passwordFormat;
            MinRequiredPasswordLength = minRequiredPasswordLength;
            MinRequiredNonAlphanumericCharacters = minRequiredNonAlphanumericCharacters;
            PasswordStrengthRegularExpression = passwordStrengthRegularExpression;
            ApplicationName = applicationName;
        }
        [DataMember]
        public bool EnablePasswordRetrieval { get;  set; }
        [DataMember]
        public bool EnablePasswordReset { get;  set; }
        [DataMember]
        public bool RequiresQuestionAndAnswer { get;  set; }
        [DataMember]
        public int MaxInvalidPasswordAttempts { get;  set; }
        [DataMember]
        public int PasswordAttemptWindow { get;  set; }
        [DataMember]
        public bool RequiresUniqueEmail { get;  set; }
        [DataMember]
        public MembershipPasswordFormat PasswordFormat { get;  set; }
        [DataMember]
        public int MinRequiredPasswordLength { get;  set; }
        [DataMember]
        public int MinRequiredNonAlphanumericCharacters { get;  set; }
        [DataMember]
        public string PasswordStrengthRegularExpression { get;  set; }
        [DataMember]
        public string ApplicationName { get;  set; }
    }
}

使用系统；
使用系统集合；
使用System.Collections.Generic；
使用System.Runtime.Serialization；
使用System.ServiceModel；
使用System.ServiceModel.Activation；
使用System.Text.RegularExpressions；
使用System.Web.Security；
namespace.ServiceModel.AspNetProviders
{
[ServiceContract（Namespace=“excellent.ServiceModel.AspNetProviders”，Name=“MembershipProvider”）]
公共接口IMembershipProvider
{
字符串提供程序名{get；set；}
[经营合同]
ProviderProperties GetProviderProperties（）；
[经营合同]
MembershipUser GetUserByKey（对象提供者UserKey，bool userIsOnline）；
[经营合同]
MembershipCreateResult CreateUser（字符串用户名、字符串密码、，
字符串电子邮件，字符串密码问题，
字符串密码应答，布尔被批准，
对象提供者（用户密钥）；
[经营合同]
MembershipCreateResult-AddUser（MembershipUser用户）；
[经营合同]
bool ChangePasswordQuestionAndAnswer（字符串用户名、字符串密码、，
字符串newPasswordQuestion，字符串newPasswordAnswer）；
[经营合同]
字符串GetPassword（字符串用户名、字符串答案）；
[经营合同]
bool ChangePassword（字符串用户名、字符串旧密码、字符串新密码）；
[经营合同]
字符串重置密码（字符串用户名、字符串答案）；
[经营合同]
void UpdateUser（成员身份用户）；
[经营合同]
bool ValidateUser（字符串用户名、字符串密码）；
[经营合同]
bool UnlockUser（字符串用户名）；
[经营合同]
MembershipUserGetUserByName（字符串用户名，boolUserIsOnline）；
[经营合同]
字符串getUsernameBayEmail（字符串电子邮件）；
[经营合同]
bool DeleteUser（字符串用户名，bool deleteAllRelatedData）；
[经营合同]
MembershipFindResult GetAllUsers（int-pageIndex，int-pageSize）；
[经营合同]
int GetNumberOfUsersOnline（）；
[经营合同]
MembershipFindResult FindUserByName（字符串用户名匹配，int-pageIndex，
int pageSize）；
[经营合同]
MembershipFindResult FindUsersByEmail（字符串emailToMatch，int-pageIndex，
int pageSize）；
}
[AspNetCompatibilityRequirements（RequirementsMode=AspNetCompatibilityRequirementsMode.Allowed）]
公共类成员身份提供程序：IMembershipProvider
{
private System.Web.Security.MembershipProvider提供程序
{
得到
{
if（string.IsNullOrEmpty（ProviderName））
{
返回成员资格。提供程序；
}
返回成员资格。提供程序[ProviderName]；
}
}
#区域IMembershipProvider成员
公共日期时间测试输入（日期时间日期）
{
返回日期；
}
公共字符串提供程序名称{get；set；}
公共ProviderProperties GetProviderProperties（）
{
var returnValue=新ProviderProperties
{
ApplicationName=Provider.ApplicationName，
EnablePasswordReset=Provider.EnablePasswordReset，
EnablePasswordRetrieval=Provider.EnablePasswordRetrieval，
MaxInvalidPasswordAttempts=Provider.MaxInvalidPasswordAttempts，
最小必需非字母数字字符=
Provider.MinRequiredNonalphanumeric字符，
MinRequiredPasswordLength=Provider.MinRequiredPasswordLength，
PasswordAttemptWindow=Provider.PasswordAttemptWindow，
帕斯沃