Client-Anwendungsdienste mit benutzerdefiniertem Mitgliedsprovider nicht möglich

Question

Ich habe eine Windows-Forms-Anwendung, die ich für die Verwendung mit einem ASP.NET-Dienst konfiguriert habe, der ein Authentifizierungsdienst ist, der einen benutzerdefinierten MembershipProvider verwendet.

Wenn ich Membership.CreateUser in der Windows-Anwendung aufrufen, wird eine NotSupportedException ausgelöst, die besagt: "Die angegebene Methode wird nicht unterstützt.".

Ich habe versucht, eine Webseite in der Website zu erstellen und den MembershipProvider zu testen, alles funktioniert gut, wenn Sie von der Website aus arbeiten.

Irgendwelche Ideen oder einen Link für die Verwendung von benutzerdefinierten (nicht SqlMembershipProvider) MitgliedschaftProvider wird wirklich geschätzt!

Bearbeiten: Die Methode ValidateUser funktioniert. Der außer Kraft gesetzt AngelegtVon funktioniert nicht Ich versuchte Aufschalten Sub AngelegtVon (.......) Da MembershipUser Return Neuer Benutzer() End Sub Aber ich immer noch die gleiche excetption erhalten wie zuvor.

Answer 1

Die Clientanwendungsdienste unterstützen die CreateUser-Methode nicht. Hier

ist AngelegtVon Methode Quellcode von ClientFormsAuthenticationMembershipProvider:

public override MembershipUser CreateUser 
(
    string username, 
    string password, 
    string email, 
    string passwordQuestion, 
    string passwordAnswer, 
    bool isApproved, 
    object providerUserKey, 
    out MembershipCreateStatus status 
) 
{ 
    throw new NotSupportedException(); 
} 

Answer 2

This page zeigt, wie Sie einen benutzerdefinierten Mitgliedschaftsanbieter implementieren. Ich bin mir nicht sicher, ob es bei deinem Problem helfen wird.

Answer 3

Ich denke, dass benutzerdefinierte Mitgliedschaftsanbieter sind, wenn ein ASP.NET AJAX-Dienst (Client Application Service) zu implementieren. Für einfache Windows-Anwendung My.User.CurrentPrinciple kann verwendet werden, um zu authentifizieren.

Answer 4

Sie werden einen JSON-Proxy über Ihren benutzerdefinierten Anbieter erstellen möchten. Etwas, das Sie im Auge behalten sollten, ist die Sicherung des Proxy-Endpunkts! SICHERN SIE DEN PROXY-ENDPUNKT!

Ich habe nicht jede Methode in dieser Klasse getestet, aber vorherige Implementierungen funktionierte gut, so dass es wahrscheinlich Sie dahin bringen wird, wo Sie gehen müssen.

SICHERN SIE DEN ENDPUNKT!

// <copyright project="Salient.ScriptModel" file="MembershipService.svc" company="Sky Sanders"> 
// This source is a Public Domain Dedication. 
// http://skysanders.net/subtext 
// Attribution is appreciated 
// </copyright> 
// <version>1.0</version> 
using System; 
using System.Collections.Generic; 
using System.Runtime.Serialization; 
using System.ServiceModel; 
using System.ServiceModel.Activation; 
using System.Web.Security; 

namespace Salient.ScriptModel 
{ 
    [ServiceContract(Namespace = "Salient.ScriptModel", Name = "MembershipProvider")] 
    public interface IMembershipProvider 
    { 
     string ProviderName { get; set; } 

     [OperationContract] 
     DateTime TestInput(DateTime date); 

     [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; } 
    } 

} 

EDIT: musste Kommentare entfernen, um zu passen. Achte auf meinen Blog für eine vollständige Implementierung

p.s. SICHER DIESER ENDPUNKT!