Salve a tutti,

sto sviluppando una applicazione in ASP.NET 2.0 che dovrà supportare all'incirca 600.000 utenti.
Qeusti utenti hanno molte informazioni di profilo e queste informazioni devono essere filtrate in modo da poter ricavare una lista di utenti.
Per esempio il profilo dell'utente può essere composto da azienda e località e devo essere in grado di poter filtrare gli utenti in base a queste informazioni.
Con il funzionamento normale del profileprovider questo non è possibile (almeno in maniera diretta) quindi sto pensando di estendere sia il membership provider che il profile provider in modo da poter arrivare ad ottenere il mio risultato.
L'applicazione dovrà essere multi DB quindi quello che volevo chiedervi è se la struttura che ho pensato per estendere tali provider è giusta.
Qeullo che ho pensato è di creare una classe astratta che eredita dal MembershipProvider ed all'interno dichiarare alcuni metodi astratti che sono quelli che mi servono per raggiungere l'obiettivo.
Visto che devo anche creare un MembershipProvider custom ed un MembershipUser il codice qua sotto è per questi ultimi....ma che se funziona può essere tranquillamente adattato al resto.


public abstract class CustomMembershipProvider: MembershipProvider
{
       public CustomMembershipProvider
       {
           
       }

       public abstract void DoSomeStuff();
       public abstract CollectionOfSomething ReturnSomeStuff(string parms);

}



a questo punto implementerei i vari provider concreti del tipo:


public sealed class CustomSqlMembershipProvider: CustomMembershipProvider
{
       public CustomSqlMembershipProvider
       {
           
       }

       public void DoSomeStuff()
      {
        ...........
      }
       public abstract CollectionOfSomething ReturnSomeStuff(string parms)
       {
        ...................
       }

       .........................
}

public sealed class CustomMySqlMembershipProvider: CustomMembershipProvider
{
       public CustomMySqlMembershipProvider
       {
           
       }

       public void DoSomeStuff()
      {
        ...........
      }
       public abstract CollectionOfSomething ReturnSomeStuff(string parms)
       {
        ...................
       }

       .........................
}


La cosa che vi chiedo è se questa struttura vi sembra corretta oppure no.
L'altra cosa, se la risposta fosse positiva è:
All'interno del della classe astratta come faccio ad istanziare la classe concreta? Passo per il web.config e l'Activator.CreateInstance?
la soluzione che proponi mi sembra logica, se ti vuoi risparmiare un pò di fatica esiste già un ProfileProvedere che invece di memorizzare tutte le proprietà serializzata fa lo storage in colonne di db separare, adesso mi sfugge il link.

per la dependency iniection usi come hai detto il Web.config, ti conviene crearti una sezione di configurazione personalizzata, e dotarla di un metodo statico che restituisca l'istanza corrente.

per creare l'istanza concreat puoi usare ProvidersHelper (System.Web.Configuration)

ciao marco

p.s. ho fatto esempi a grandi linee

Chi parla senza modestia troverà difficile rendere buone le proprie parole.
Confucio

http://nostromo.spaces.live.com/default.aspx
Grazie della tua risposta.....e sono contento che condividi il mio approccio.
Il Profile Provider in effetti lo copierò da quello che dici te....se non mi sbaglio parli quello presente su www.asp.net nella sezione SandBox, giusto?

Per il MembershipProvider invece dovrò riscriverlo tutto da solo poichè alcune sue funzionalità fanno parte proprio del membership e non del profile....pace mi divertirò un pò!!!

Se qualcuno ha qualche altra considerazione è sempre bene accetto
esatto intendevo proprio quella implementazione mi sfuggiva il link e dire che era anche facile

ciao marco

Chi parla senza modestia troverà difficile rendere buone le proprie parole.
Confucio

http://nostromo.spaces.live.com/default.aspx
Ciao a tutti

ho fatto alcune prove ed ho quasi finito il custom membershipprovider.
Volevo solo dire che alla domanda


All'interno del della classe astratta come faccio ad istanziare la classe concreta? Passo per il web.config e l'Activator.CreateInstance?


Mi rispondo da solo e dico....

"MA COSA STO DICENDO"?

Infatti crearsi una sezione del web.config personalizzata ed utilizzare la creazione di un istanza con l'activator non serve a nulla poichè ci pensa direttamente il framework

Ecco un piccolo esempio di cio che ho fatto:

ho creato il MembershipUser custom (che eredita il System.Web.Security.MembershipUser) con una proprietà aggiuntiva che è il suo ID:

 public class EpsMembershipUser: System.Web.Security.MembershipUser
{
#region Members

        private int _id;

        #endregion

        #region Properties

        public int ID
        {
            get { return _id; }
            set { __id= value; }
        }


        #endregion

        #region Ctor

        public EpsMembershipUser(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,
                                  int id)
            : base(providername,
                                                           username,
                                                           providerUserKey,
                                                           email,
                                                           passwordQuestion,
                                                           comment,
                                                           isApproved,
                                                           isLockedOut,
                                                           creationDate,
                                                           lastLoginDate,
                                                           lastActivityDate,
                                                           lastPasswordChangedDate,
                                                           lastLockedOutDate)
        {

            this.ID= id;
}

        #endregion
}


poi ho creato la mi classe base del MembershipProvider (che eredita il System.Web.Security.MembershipProvider) con un metodo astratto che mi permette di recuperare un utente tramite il suo id:


public abstract class EpsMembershipProvider: System.Web.Security.MembershipProvider
    {
        public abstract MembershipUser GetUser(int userId);
    }


poi ho creato la classe concreta del provider che eredita dal mio EpsMembershipProvider ed implementa il metodo astratto:


public sealed class EpsSqlMembershipProvider: EpsMembershipProvider
{
        //Implementazione di tutti i metodi astratti del MembershipProvider
         ................................
         ................................

       //Implementazione del metodo astratto GetUser del mio Provider base
public override MembershipUser GetUser(int userId)
        {

//Recupero del membership dal DB
.......................
.......................

//Istanza del EpsMembershipUser

EpsMembershipUser user = new EpsMembershipUser();

//Valorizzazione di user
.......................

return user
        }
}


La classe sopra appena finita la convertirò per funzionare anche con MySql visto che la mia esigenza è quella di avere un indipendenza dal DB

in fine ho messo nel web.config sotto la sezione Membership il mio provider per Sql

<membership defaultProvider="EpsMembershipProvider">
      <providers>
        <clear/>
        <add name="EpsMembershipProvider" type="Eps.Web.Security.EpsSqlMembershipProvider, Eps.SqlMembershipProvider" connectionStringName="EpsTest"/>
      </providers>
    </membership>


A questo punto nella mia pagina ASPX non ho fatto altro che fare questo:


//Faccio il casting del provider restituito dal Membership del framework al
//mio provider astratto
Eps.Web.Security.EpsMembershipProvider provider =
            (Eps.Web.Security.EpsMembershipProvider)Membership.Provider;

//Istanzio il MembershipUser custom e richiamo il metodo GetUser(int id) del mio
//provider
Eps.Web.Security.EpsMembershipUser user =
           (Eps.Web.Security.EpsMembershipUser)provider.GetUser(67543);

//Utilizzo la variabile personalizzata del mio EpsMembershipUser
lblUserID.Text = user.ID.ToString();



A questo punto è tutto fatto....io sono contento e spero che sia stato di aiuto a qualcun'altro :) :)
ottima osservazione  .
effettivamente ereditando da MembershipProvider non è necessario reimplementare la logica di inizializzazione, comunque alla fine come avevi scritto userai l'Activator.CreateInstance, solo che lo farà asp.net per te :D

ciao marco

Chi parla senza modestia troverà difficile rendere buone le proprie parole.
Confucio

http://nostromo.spaces.live.com/default.aspx
357 messaggi dal 10 giugno 2003
Ciao,

scusate se mi intrometto in questa discussione ma visto che state parlando di
Membership ho una domandina da farvi...
quando devo creare il form di autenticazione cosa conviene piu' passare il suo userName o il suo Guid al ticket di autenticazione?
parlo sempre in termini di risparmio di operazioni e di sicurezza...

ciao,
ale
Ciao,

Al ticket di autenticazione ti conviene passare lo userName per due motivi:

1) Il comportamento standard del membership fa tutto per userName o eMail
2) La sicurezza è pressochè identica, se non per il fatto che il GUID è incomprensibile

Utilizzare il GUID ti porterebbe inoltre a recuperare il GUID dell'utente e quindi sono operazioni in più visto che il membership non lo restituisce.

ciao ciao

Torna al forum | Feed RSS

ASPItalia.com non è responsabile per il contenuto dei messaggi presenti su questo servizio, non avendo nessun controllo sui messaggi postati nei propri forum, che rappresentano l'espressione del pensiero degli autori.