Metodologia per l'aggiornamento dei gruppi di directory attivi

Se si tratta di una lista sul lato server, non farebbe molta differenza.

Contiene è O (n)
Remove è O (n)

Aggiungi è O (1) o O (n)
Ma è se non è necessario aumentare la lista di O (1) e poiché è stata appena rimossa, non è necessario aumentare l'elenco.

Uno sviluppatore esperto progetterebbe oggetti business che salvano / producono solo modifiche. Hai uno scenario in cui le modifiche da un utente potrebbero essere sovrascritte da un altro.

Le prestazioni sono davvero un problema? Mi sembra che l'NFR più importante sia l'integrità della transazione.

Se raccogli una lista (cioè creane un clone in una struttura di dati in ac #) e poi fai l'aggiornamento in seguito, c'è la possibilità che il sistema di registrazione cambi prima che l'aggiornamento sia completo, nel qual caso la lista non sarà aggiornato e potresti avere risultati errati. Ad esempio, il tuo programma potrebbe annullare le modifiche di qualcun altro se hanno appena apportato una modifica a un gruppo su cui stai lavorando e la tua istantanea proviene da prima del commit. In conclusione, vuoi mantenere la finestra temporale tra read e commit molto piccola.

Per me, la cosa più semplice sarebbe

for each permission that is checked
    grab a reference to the group (e.g. a 'DirectoryEntry' instance)
    if the user isn't in there, add it
    commit
for each permission that is not checked
    grab a reference to the group (e.g. a 'DirectoryEntry' instance)
    if the user is in there, remove it
    commit

Al termine

Grab a fresh list
Compare to the desired results
Display an error if there is any mismatch

Facciamo un passo indietro qui. Stai aggiungendo e rimuovendo utenti da ciò che sembra, al massimo, una manciata di gruppi. Dato il tuo esempio, non posso immaginare che sarebbe molto "process intensive" per calcolare le 3 modifiche che proponi. (Se la lista dei gruppi selezionati è lunga solo 4 elementi e la lista esistente è lunga 5 elementi, non mi preoccuperei nemmeno di iterare su di essi un paio di volte per calcolare un paio di liste di modifiche. pezzo, dubito che noteresti una differenza a meno che tu non stia usando un algoritmo di accesso orribile. Oltre a questo, la maggior parte dei metodi LINQ incorporati e delle raccolte incorporate gestirà tutto ciò correttamente.) Come sempre, non assumere ciò che sarà "troppo intensivo di processo". Misuralo.

La cosa che probabilmente ti farà del male di più farebbe molte chiamate esterne ad Active Directory (solo una supposizione, prova per essere sicuro). Quindi se sei veramente preoccupato, minimizza quelle chiamate. Preferisco di gran lunga fare le 3 chiamate per effettuare le modifiche che cancellare la lavagnetta pulita quindi aggiungere 4 gruppi.

Inoltre, l'eliminazione di un gran numero di record solo per aggiungerli può creare mal di testa per audit trail, ecc. (Potrebbe non essere importante con AD, ma in generale probabilmente non è una buona idea.) Immagina di provare per capire quando un utente è stato rimosso da un gruppo. Voglio dire davvero rimosso, non solo che qualcuno ha giocato con la pagina dei gruppi di modifica.

Inoltre, considera questo. Dato che l'AD è probabilmente usato per controllare l'accesso a molte cose, ci sono molte applicazioni che lo usano mentre sei. Cosa potrebbe succedere a queste app se un utente perde improvvisamente l'accesso? Che cosa succede se queste app memorizzano le autorizzazioni nella cache e accidentalmente colpiscono AD quando cancelli i gruppi e li aggiungi nuovamente? Inoltre, immagina il divertimento di provare a fare un'analisi delle cause alla radice su un bug intermittente in un'app totalmente diversa quando Sarah in contabilità occasionalmente non può fare il suo lavoro perché ha perso l'accesso AD nel momento sbagliato (e quando arrivi a tutto andrà bene e sarà irriproducibile.

Il punto è che, cancellando tutto pulito, ricominciare è probabilmente un modo pigro per farlo. A meno che tu non abbia una giustificazione misurabile per farlo e sia a posto dei rischi, basta scrivere le poche righe di codice in più.