1) ErrorAttribute in BaseController:Controller class.
     Can be used on individual Action/Controller/BaseController.
2) Override OnException() in the BaseController:Controller class.
     Will work on Controllers derived from BaseController
3) Application_Error in Global_aspx.

最好的做法是什么
这些方法中的哪一种应用于应用范围广泛的错误处理,或者我们应该使用多个或仅一个.

如果我们在BaseController上处理ErrorAttribute Or / And OnException()的错误,那么我们仍然在Application_Error()中处理它.

我们什么时候应用Application_Error()？

有什么用？

肯定地看看ELMAH的应用范围的错误记录和我的blog post关于ELMAH和ASP.NET MVC

关于显示错误页面,只要使用[HandleError]和HandleErrorAttribute即可,因为它已经处理了所有内容(可选过滤和每个异常类型的可选自定义错误页面).

protected void Page_Load(object sender,EventArgs e)
{
    throw new Exception("test exception");
}

在Global.asax.cs中：

protected void Application_Error(object sender,EventArgs e)
{
    // Code that runs when an unhandled error occurs
    if (Server.GetLastError() is HttpUnhandledException)
        Server.Transfer("ErrUnkNown.aspx");
}

但是从不调用Application_Error事件处理程序.相反,我得到一个运行时错误页面.

在抛出异常后,我需要做什么才能调用Application_Error？

您是否通过调试应用程序进行了检查？

实际上你缺少Server.ClearError()所以异常被传递给asp.net但你应该在这里压制它,因为你自己处理它.

protected void Application_Error(object sender,EventArgs e)
{
    // Code that runs when an unhandled error occurs
    if (Server.GetLastError() is HttpUnhandledException)
    {
        // suppressing the error so it should not pass to asp.net
        Server.ClearError();
        Server.Transfer("ErrUnkNown.aspx");
    }
}

/**
 * Apply the given set of {@link ContentProviderOperation},executing inside
 * a {@link sqliteDatabase} transaction. All changes will be rolled back if
 * any single one fails.
 */
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final sqliteDatabase db = mOpenHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        final int numOperations = operations.size();
        final ContentProviderResult[] results = new ContentProviderResult[numOperations];
        for (int i = 0; i < numOperations; i++) {
            results[i] = operations.get(i).apply(this,results,i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

@NonNull
@Override
public ContentProviderResult[] applyBatch(@NonNull ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    ContentProviderResult[] result = null;
    isApplyingBatch = true;
    final sqliteDatabase db = db();
    db.beginTransaction();
    try {
        result = super.applyBatch(operations);
        db.setTransactionSuccessful();
    } finally {
        db.endTransaction();
        isApplyingBatch = false;
    }
    return result;
}

private void flushApksToDbInBatch(Map<String,Long> appIds) throws RepoUpdater.UpdateException {
    List<Apk> apksToSaveList = new ArrayList<>();
    for (Map.Entry<String,List<Apk>> entries : apksToSave.entrySet()) {
        for (Apk apk : entries.getValue()) {
            apk.appId = appIds.get(apk.packageName);
        }
        apksToSaveList.addAll(entries.getValue());
    }

    calcApkCompatibilityFlags(apksToSaveList);

    ArrayList<ContentProviderOperation> apkOperations = insertApks(apksToSaveList);

    try {
        context.getContentResolver().applyBatch(TempApkProvider.getAuthority(),apkOperations);
    } catch (remoteexception | OperationApplicationException e) {
        throw new RepoUpdater.UpdateException(repo,"An internal error occurred while updating the database",e);
    }
}

private static @NonNull RefreshResult updateContactsDatabase(@NonNull Context context,@NonNull String localNumber,@NonNull List<ContactTokenDetails> activetokens,boolean removeMissing)
{
  Optional<AccountHolder> account = getorCreateAccount(context);

  if (account.isPresent()) {
    try {
      List<String> newUsers = DatabaseFactory.getContactsDatabase(context)
                                             .setRegisteredUsers(account.get().getAccount(),localNumber,activetokens,removeMissing);

      return new RefreshResult(newUsers,account.get().isFresh());
    } catch (remoteexception | OperationApplicationException e) {
      Log.w(TAG,e);
    }
  }

  return new RefreshResult(new LinkedList<String>(),false);
}

/**
 * Apply the given set of {@link ContentProviderOperation},i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) throws OperationApplicationException {
    ContentProviderResult[] results;

    sqliteDatabase db = mOpenHelper.getWritableDatabase();

    db.beginTransaction();
    try {
        inBatch.set(true);
        results = super.applyBatch(operations);
        inBatch.set(false);

        db.setTransactionSuccessful();
    } finally {
        db.endTransaction();
    }

    notifyChange();

    return results;
}

/**
 * Since old repository URL Could be used,do not actually update the existing record,* but create a new one.
 */
public static int updateUrl(Context mContext,long id,String url) {
    ArrayList<ContentProviderOperation> ops = new ArrayList<>();

    ops.add(ContentProviderOperation
                    .newDelete(ContentUris.withAppendedId(ProviderContract.Repos.ContentUri.repos(),id))
                    .build());

    ops.add(ContentProviderOperation
                    .newInsert(ProviderContract.Repos.ContentUri.repos())
                    .withValue(ProviderContract.Repos.Param.REPO_URL,url)
                    .build());

    try {
        mContext.getContentResolver().applyBatch(ProviderContract.AUTHORITY,ops);
    } catch (remoteexception | OperationApplicationException e) {
        e.printstacktrace();
        throw new RuntimeException(e);
    }

    return 1;
}

public static void set(Context context,List<VersionedRook> books) {
    ArrayList<ContentProviderOperation> ops = new ArrayList<>();

    /* Delete all prevIoUs. */
    ops.add(ContentProviderOperation
            .newDelete(ProviderContract.CurrentRooks.ContentUri.currentRooks())
            .build());

    /* Insert each one. */
    for (VersionedRook book: books) {
        ContentValues values = new ContentValues();
        CurrentRooksClient.toContentValues(values,book);

        ops.add(ContentProviderOperation
                .newInsert(ProviderContract.CurrentRooks.ContentUri.currentRooks())
                .withValues(values)
                .build());
    }

    try {
        context.getContentResolver().applyBatch(ProviderContract.AUTHORITY,ops);
    } catch (remoteexception | OperationApplicationException e) {
        e.printstacktrace();
    }
}

public static int delete(Context context,long[] noteIds) {
    int deleted = 0;

    ArrayList<ContentProviderOperation> ops = new ArrayList<>();

    for (long noteId: noteIds) {
        ops.add(ContentProviderOperation
                .newDelete(ProviderContract.Notes.ContentUri.notes())
                .withSelection(ProviderContract.Notes.UpdateParam._ID + "=" + noteId,null)
                .build()
        );
    }

    try {
        context.getContentResolver().applyBatch(ProviderContract.AUTHORITY,ops);
    } catch (remoteexception | OperationApplicationException e) {
        e.printstacktrace();
        throw new RuntimeException(e);
    }

    if (BuildConfig.LOG_DEBUG) LogUtils.d(TAG,"Deleted " + deleted + " notes");

    return deleted;
}

@NonNull
@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) throws OperationApplicationException {
    try {
        Field uriField = ContentProviderOperation.class.getDeclaredField("mUri");
        uriField.setAccessible(true);
        for (ContentProviderOperation operation : operations) {
            Uri pluginUri = Uri.parse(operation.getUri().getQueryParameter(KEY_URI));
            uriField.set(operation,pluginUri);
        }
    } catch (Exception e) {
        return new ContentProviderResult[0];
    }

    if (operations.size() > 0) {
        ContentProvider provider = getContentProvider(operations.get(0).getUri());
        if (provider != null) {
            return provider.applyBatch(operations);
        }
    }

    return new ContentProviderResult[0];
}

@NonNull
@Override
public ContentProviderResult[] applyBatch(
        @NonNull ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final Context context = getContext();
    if (context == null) {
        return new ContentProviderResult[0];
    }
    final SampleDatabase database = SampleDatabase.getInstance(context);
    database.beginTransaction();
    try {
        final ContentProviderResult[] result = super.applyBatch(operations);
        database.setTransactionSuccessful();
        return result;
    } finally {
        database.endTransaction();
    }
}

@Test
public void cheese_applyBatch() throws remoteexception,OperationApplicationException {
    final ArrayList<ContentProviderOperation> operations = new ArrayList<>();
    operations.add(ContentProviderOperation
            .newInsert(SampleContentProvider.URI_CHEESE)
            .withValue(Cheese.COLUMN_NAME,"Peynir")
            .build());
    operations.add(ContentProviderOperation
            .newInsert(SampleContentProvider.URI_CHEESE)
            .withValue(Cheese.COLUMN_NAME,"Queso")
            .build());
    final ContentProviderResult[] results = mContentResolver.applyBatch(
            SampleContentProvider.AUTHORITY,operations);
    assertthat(results.length,is(2));
    final Cursor cursor = mContentResolver.query(SampleContentProvider.URI_CHEESE,new String[]{Cheese.COLUMN_NAME},null,null);
    assertthat(cursor,notNullValue());
    assertthat(cursor.getCount(),is(2));
    assertthat(cursor.movetoFirst(),is(true));
    cursor.close();
}

/**
 * Apply the given set of {@link ContentProviderOperation},executing inside
 * a {@link sqliteDatabase} transaction. All changes will be rolled back if
 * any single one fails.
 */
@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final sqliteDatabase db = mOpenHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        final int numOperations = operations.size();
        final ContentProviderResult[] results = new ContentProviderResult[numOperations];
        for (int i = 0; i < numOperations; i++) {
            results[i] = operations.get(i).apply(this,i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

private static @NonNull RefreshResult updateContactsDatabase(@NonNull Context context,false);
}

@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    if (DBG) Log.d(TAG,"applyBatch");
    ContentProviderResult[] result = null;
    sqliteDatabase db = mDbHolder.get();
    db.beginTransaction();
    try {
         result = super.applyBatch(operations);
         db.setTransactionSuccessful();
    } finally {
        db.endTransaction();
    }
    if (result != null) {
        mCr.notifyChange(MusicStore.ALL_CONTENT_URI,null);
    }
    return result;
}

@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    sqliteDatabase db = mDbHolder.get();
    db.beginTransaction();
    ContentProviderResult[] result = null;
    try {
        result = super.applyBatch(operations);
        db.setTransactionSuccessful();
        ContentResolver res = mCr;
        res.notifyChange(ScraperStore.ALL_CONTENT_URI,null);
        return result;
    } finally {
        db.endTransaction();
    }
}

@Override
public void transactionSuccess() {
    try {
        ContentProviderResult[] cpr = context.getContentResolver().applyBatch(
                dsUri.getAuthority(),trans);
        if(cpr == null || cpr.length != trans.size()){
            throw new DaoException();
        }
        for (int i = 0; i < cpr.length; i++) {
            if (cpr[i] == null || ( cpr[i].count == null && cpr[i].uri == null)) {
                throw new DaoException();
            }
        }
    } catch (remoteexception | OperationApplicationException e) {
        throw new DaoException();
    } finally {
        trans = null;
    }
}

@Override
public ContentProviderResult[] applyBatch( ArrayList<ContentProviderOperation> operations )
        throws OperationApplicationException {

    ContentProviderResult[] contentProviderResults;
    try {
        getWritableDatabase().beginTransaction();
        contentProviderResults = new ContentProviderResult[operations
                .size()];

        int i = 0;
        for (ContentProviderOperation cpo : operations) {
            contentProviderResults[i] = cpo.apply(this,contentProviderResults,i);
            if(contentProviderResults[i] == null || (contentProviderResults[i].count == null && contentProviderResults[i].uri == null)){
                throw new DaoException();
            }
            i++;
        }
        getWritableDatabase().setTransactionSuccessful();
    } finally{
        if (getWritableDatabase().inTransaction()) {
            getWritableDatabase().endTransaction();
        }            
    }
    return contentProviderResults;
}

/**
 * Apply the given set of {@link ContentProviderOperation},executing inside
 * a {@link sqliteDatabase} transaction. All changes will be rolled back if
 * any single one fails.
 */
@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final sqliteDatabase db = mDatabaseHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        final int numOperations = operations.size();
        final ContentProviderResult[] results = new ContentProviderResult[numOperations];
        for (int i = 0; i < numOperations; i++) {
            results[i] = operations.get(i).apply(this,i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

/**
 * Apply the given set of {@link ContentProviderOperation},executing inside
 * a {@link sqliteDatabase} transaction. All changes will be rolled back if
 * any single one fails.
 */
@NonNull
@Override
public ContentProviderResult[] applyBatch(@NonNull ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final sqliteDatabase db = mOpenHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        final int numOperations = operations.size();
        final ContentProviderResult[] results = new ContentProviderResult[numOperations];
        for (int i = 0; i < numOperations; i++) {
            results[i] = operations.get(i).apply(this,i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

/**
 * Apply the given set of {@link ContentProviderOperation},i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

@Override
protected Void doInBackground(Void... params) {
    @DvrStorageStatusManager.StorageStatus int storageStatus = getDvrStorageStatus();
    if (storageStatus == DvrStorageStatusManager.STORAGE_STATUS_MISSING) {
        return null;
    }
    List<ContentProviderOperation> ops = getDeleteOps(storageStatus
            == DvrStorageStatusManager.STORAGE_STATUS_TOTAL_CAPACITY_TOO_SMALL);
    if (ops == null || ops.isEmpty()) {
        return null;
    }
    Log.i(TAG,"New device storage mounted. # of recordings to be forgotten : "
            + ops.size());
    for (int i = 0 ; i < ops.size() && !isCancelled() ; i += BATCH_OPERATION_COUNT) {
        int toIndex = (i + BATCH_OPERATION_COUNT) > ops.size()
                ? ops.size() : (i + BATCH_OPERATION_COUNT);
        ArrayList<ContentProviderOperation> batchOps =
                new ArrayList<>(ops.subList(i,toIndex));
        try {
            mContext.getContentResolver().applyBatch(TvContract.AUTHORITY,batchOps);
        } catch (remoteexception | OperationApplicationException e) {
            Log.e(TAG,"Failed to clean up  RecordedPrograms.",e);
        }
    }
    return null;
}

public void scannedChannelHandlingCompleted() {
    mIsScanning.set(false);
    if (!mPrevIoUsScannedChannels.isEmpty()) {
        ArrayList<ContentProviderOperation> ops = new ArrayList<>();
        for (TunerChannel channel : mPrevIoUsScannedChannels) {
            ops.add(ContentProviderOperation.newDelete(
                    TvContract.buildChannelUri(channel.getChannelId())).build());
        }
        try {
            mContext.getContentResolver().applyBatch(TvContract.AUTHORITY,ops);
        } catch (remoteexception | OperationApplicationException e) {
            Log.e(TAG,"Error deleting obsolete channels",e);
        }
    }
    if (mChannelScanListener != null && mChannelScanHandler != null) {
        mChannelScanHandler.post(new Runnable() {
            @Override
            public void run() {
                mChannelScanListener.onChannelHandlingDone();
            }
        });
    } else {
        Log.e(TAG,"Error. mChannelScanListener is null.");
    }
}

@Override
public ContentProviderResult[] applyBatch (ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    Log_OC.d("FileContentProvider","applying batch in provider " + this +
            " (temporary: " + istemporary() + ")" );
    ContentProviderResult[] results = new ContentProviderResult[operations.size()];
    int i=0;

    sqliteDatabase db = mDbHelper.getWritableDatabase();
    db.beginTransaction();  // it's supposed that transactions can be nested
    try {
        for (ContentProviderOperation operation : operations) {
            results[i] = operation.apply(this,i);
            i++;
        }
        db.setTransactionSuccessful();
    } finally {
        db.endTransaction();
    }
    Log_OC.d("FileContentProvider","applied batch in provider " + this);
    return results;
}

/**
 * Apply the given set of {@link ContentProviderOperation},i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

public static Uri add(ContactSpec spec) {

        // original code http://stackoverflow.com/questions/4744187/how-to-add-new-contacts-in-android
        // good blog http://androiddevelopement.blogspot.de/2011/07/insert-update-delete-view-contacts-in.html

        ArrayList<ContentProviderOperation> ops = new ArrayList<>();

        addContactBase(ops);
        addContactdisplayName(spec,ops);
        addContactAddress(spec,ops);

        try {
            ContentProviderResult[] results = InstrumentationRegistry.getTargetContext().getContentResolver().applyBatch(ContactsContract.AUTHORITY,ops);
            return results[0].uri;
        } catch (remoteexception | OperationApplicationException e) {
            throw new IllegalStateException("Could not add contact",e);
        }
    }

@Override
public @NonNull ContentProviderResult[] applyBatch(@NonNull ArrayList<ContentProviderOperation> operations) throws OperationApplicationException {
    final sqliteDatabase db = helper.getWritableDatabase();

    db.beginTransaction();

    try {
        final ContentProviderResult[] results =
                super.applyBatch(operations);
        db.setTransactionSuccessful();

        return results;
    } finally {
        db.endTransaction();
    }
}

@Override
public ContentProviderResult[] applyBatch(
        ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    /*sqliteDatabase db = sqlOpenHelper.getWritableDatabase();
    isInBatchMode.set(true);
    db.beginTransaction();
    try {
        final ContentProviderResult[] retResult = super.applyBatch(operations);
        db.setTransactionSuccessful();
        getContext().getContentResolver().notifyChange(ApparelContract.CONTENT_URI,null);
        return retResult;
    }
    finally {
        isInBatchMode.remove();
        db.endTransaction();
    }*/
    return null;
}

/**
 * Apply the given set of {@link ContentProviderOperation},executing inside
 * a {@link sqliteDatabase} transaction. All changes will be rolled back if
 * any single one fails.
 */
@Override
public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final sqliteDatabase db = mDbHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        final int numOperations = operations.size();
        final ContentProviderResult[] results = new ContentProviderResult[numOperations];
        for (int i = 0; i < numOperations; i++) {
            results[i] = operations.get(i).apply(this,i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

/**
 * Apply the given set of {@link ContentProviderOperation},i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

private void deleteMultiContract(List<Contact> contacts) {
    showProgressDialog();
    ArrayList<ContentProviderOperation> ops = new ArrayList<>();
    for (int i = 0; i < contacts.size(); i++) {
        Log.d(TAG,"deleteMultiContract contacts.dataId == " + contacts.get(i).dataId + ",name == " + contacts.get(i).displayName);
        ops.add(ContentProviderOperation.newDelete(ContactsContract.Data.CONTENT_URI)
                .withSelection(ContactsContract.Data._ID + "=?",new String[]{contacts.get(i).dataId})
                .build());
    }
    try {
        getContentResolver().applyBatch(ContactsContract.AUTHORITY,ops);
    } catch (remoteexception | OperationApplicationException e) {
        e.printstacktrace();
    }
    UpdateContactService.updateContacts(MainActivity.this,(ArrayList<Contact>) contacts);
    mHandler.postDelayed(new Runnable() {
        @Override
        public void run() {
            mContactTask = new HandleContactTask();
            mContactTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
        }
    },100);
}

/**
 * Apply the given set of {@link ContentProviderOperation},executing inside
 * a {@link sqliteDatabase} transaction. All changes will be rolled back if
 * any single one fails.
 */
@NonNull
public ContentProviderResult[] applyBatch(@NonNull ArrayList<ContentProviderOperation> operations)
        throws OperationApplicationException {
    final sqliteDatabase db = mOpenHelper.getWritableDatabase();
    db.beginTransaction();
    try {
        final int numOperations = operations.size();
        final ContentProviderResult[] results = new ContentProviderResult[numOperations];
        for (int i = 0; i < numOperations; i++) {
            results[i] = operations.get(i).apply(this,i);
        }
        db.setTransactionSuccessful();
        return results;
    } finally {
        db.endTransaction();
    }
}

void fixContactPhonetic(Set<ContactLite> contactIds) {
    ArrayList<ContentProviderOperation> ops = new ArrayList<>();
    for (ContactLite contact : contactIds) {
        ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
                .withSelection(
                        String.format("%s = ?",ContactsContract.Data._ID),new String[]{String.valueOf(contact.dataId)})
                .withValue(ContactsContract.CommonDataKinds.Structuredname.PHONETIC_GIVEN_NAME,contact.phoneticGivenname)
                .withValue(ContactsContract.CommonDataKinds.Structuredname.PHONETIC_MIDDLE_NAME,contact.phoneticMiddleName)
                .withValue(ContactsContract.CommonDataKinds.Structuredname.PHONETIC_FAMILY_NAME,contact.phoneticFamilyName)
                .withValue(ContactsContract.CommonDataKinds.Structuredname.PHONETIC_NAME_STYLE,contact.phoneticNameStyle)
                .build());
    }
    try {
        context.getContentResolver().applyBatch(ContactsContract.AUTHORITY,ops);
    } catch (remoteexception | OperationApplicationException e) {
        Log.e(TAG,"Error when updating",e);
    }
    Log.i(TAG,"Fix done:" + contactIds.size());
}

private void updateCache() {

        ArrayList<ContentProviderOperation> ops = new ArrayList<>();
        ops.addAll(deleteFromCache(toDelete));
        ops.addAll(insertIntoCache(toInsert));

        if (ops.size() > 0) {
            try {
                context.getContentResolver().applyBatch(InstalledAppProvider.getAuthority(),ops);
                Utils.debugLog(TAG,"Finished executing " + ops.size() + " CRUD operations on installed app cache.");
            } catch (remoteexception | OperationApplicationException e) {
                Log.e(TAG,"Error updating installed app cache: " + e);
            }
        }

    }

@NonNull
@Override
public ContentProviderResult[] applyBatch(@NonNull ArrayList<ContentProviderOperation> operations)
    throws OperationApplicationException {
    ContentProviderResult[] result = null;
    isApplyingBatch = true;
    final sqliteDatabase db = db();
    db.beginTransaction();
    try {
        result = super.applyBatch(operations);
        db.setTransactionSuccessful();
    } finally {
        db.endTransaction();
        isApplyingBatch = false;
    }
    return result;
}

private void flushApksToDbInBatch() throws RepoUpdater.UpdateException {
    List<Apk> apksToSaveList = new ArrayList<>();
    for (Map.Entry<String,List<Apk>> entries : apksToSave.entrySet()) {
        apksToSaveList.addAll(entries.getValue());
    }

    calcApkCompatibilityFlags(apksToSaveList);

    ArrayList<ContentProviderOperation> apkOperations = new ArrayList<>();
    ContentProviderOperation clearOrphans = deleteOrphanedApks(appsToSave,apksToSave);
    if (clearOrphans != null) {
        apkOperations.add(clearOrphans);
    }
    apkOperations.addAll(insertOrUpdateApks(apksToSaveList));

    try {
        context.getContentResolver().applyBatch(TempApkProvider.getAuthority(),e);
    }
}

private void updateCache() {

        ArrayList<ContentProviderOperation> ops = new ArrayList<>();
        ops.addAll(deleteFromCache(toDelete));
        ops.addAll(insertIntoCache(toInsert));

        if (ops.size() > 0) {
            try {
                context.getContentResolver().applyBatch(InstalledAppProvider.getAuthority(),"Error updating installed app cache: " + e);
            }
        }

    }

private void flushApksToDbInBatch() throws RepoUpdater.UpdateException {
    List<Apk> apksToSaveList = new ArrayList<>();
    for (Map.Entry<String,e);
    }
}

public synchronized static void updateEvent(Context context,Contact contact,DateUnkNownYear newBirthday) throws EventException {
    // Todo UNIFORMISE
    for (CalendarEvent event : getEventsSavedOrCreateNewsForEachYear(context,contact)) {
        // Construct each anniversary of new birthday
        int year = new DateTime(event.getDate()).getYear();
        Date newBirthdayDate = DateUnkNownYear.getDateWithYear(newBirthday.getDate(),year);
        event.setDateStart(newBirthdayDate);
        event.setAllDay(true);
        ArrayList<ContentProviderOperation> operations = new ArrayList<>();
        ContentProviderOperation contentProviderOperation = EventProvider.update(event);
        operations.add(contentProviderOperation);
        try {
            ContentProviderResult[] contentProviderResults =
                    context.getContentResolver().applyBatch(CalendarContract.AUTHORITY,operations);
            for(ContentProviderResult contentProviderResult : contentProviderResults) {
                if (contentProviderResult.count != 0)
                    Log.d(TAG,"Update event : " + event.toString());
            }
        } catch (remoteexception|OperationApplicationException e) {
            Log.e(TAG,"Unable to update event : " + e.getMessage());
        }
    }
}

public synchronized static void deleteEventsFromContact(Context context,Contact contact) {
    ArrayList<ContentProviderOperation> operations = new ArrayList<>();
    try {
        for (CalendarEvent event : getEventsSavedForEachYear(context,contact)) {
            operations.add(ReminderProvider.deleteall(context,event.getId()));
            operations.add(EventProvider.delete(event));
        }
        ContentProviderResult[] contentProviderResults =
                context.getContentResolver().applyBatch(CalendarContract.AUTHORITY,operations);
        for(ContentProviderResult contentProviderResult : contentProviderResults) {
            Log.d(TAG,contentProviderResult.toString());
            if (contentProviderResult.uri != null)
                Log.d(TAG,contentProviderResult.uri.toString());
        }
    } catch (remoteexception |OperationApplicationException |EventException e) {
        Log.e(TAG,"Unable to deleteById events : " + e.getMessage());
    }
}

一、概述

ASP.NET Core MVC 提供了基于角色( Role )、声明( Chaim ) 和策略 ( Policy ) 等的授权方式。在实际应用中，可能采用部门（ Department , 本文采用用户组 Group ）、职位 ( 可继续沿用 Role )、权限( Permission )的方式进行授权。要达到这个目的，仅仅通过自定义 IAuthorizationPolicyProvider 是不行的。本文通过自定义 IApplicationModelProvide 进行扩展。

二、PermissionAuthorizeAttribute : IPermissionAuthorizeData

AuthorizeAttribute 类实现了 IAuthorizeData 接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

namespace Microsoft.AspNetCore.Authorization
{
  /// <summary>
  /// Defines the set of data required to apply authorization rules to a resource.
 /// </summary>
 public interface IAuthorizeData
 {
 /// <summary>
 /// Gets or sets the policy name that determines access to the resource.
 /// </summary>
 string Policy { get; set; }
 /// <summary>
 /// Gets or sets a comma delimited list of roles that are allowed to access the resource.
 /// </summary>
 string Roles { get; set; }
 /// <summary>
 /// Gets or sets a comma delimited list of schemes from which user information is constructed.
 /// </summary>
 string AuthenticationSchemes { get; set; }
 }
}

使用 AuthorizeAttribute 不外乎如下几种形式：

1
2
3
4

[Authorize]
[Authorize("SomePolicy")]
[Authorize(Roles = "角色1,角色2")]
[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]

当然，参数还可以组合起来。另外，Roles 和 AuthenticationSchemes 的值以半角逗号分隔，是 Or 的关系；多个 Authorize 是 And 的关系；Policy 、Roles 和 AuthenticationSchemes 如果同时使用，也是 And 的关系。

如果要扩展 AuthorizeAttribute，先扩展 IAuthorizeData 增加新的属性：

1
2
3
4
5

public interface IPermissionAuthorizeData : IAuthorizeData
{
    string Groups { get; set; }
    string Permissions { get; set; }
}

然后定义 AuthorizeAttribute:

1
2
3
4
5
6
7
8
9

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
public class PermissionAuthorizeAttribute : Attribute, IPermissionAuthorizeData
{
    public string Policy { get; set; }
 public string Roles { get; set; }
 public string AuthenticationSchemes { get; set; }
 public string Groups { get; set; }
 public string Permissions { get; set; }
}

现在，在 Controller 或 Action 上就可以这样使用了：

1
2
3

[PermissionAuthorize(Roles = "经理,副经理")] // 经理或部门经理
[PermissionAuthorize(Groups = "研发部,生产部", Roles = "经理"] // 研发部经理或生成部经理。Groups 和 Roles 是 `And` 的关系。
[PermissionAuthorize(Groups = "研发部,生产部", Roles = "经理", Permissions = "请假审批"] // 研发部经理或生成部经理，并且有请假审批的权限。Groups 、Roles 和 Permission 是 `And` 的关系。

数据已经准备好，下一步就是怎么提取出来。通过扩展 AuthorizationApplicationModelProvider 来实现。

三、PermissionAuthorizationApplicationModelProvider : IApplicationModelProvider

AuthorizationApplicationModelProvider 类的作用是构造 AuthorizeFilter 对象放入 ControllerModel 或 ActionModel 的 Filters 属性中。具体过程是先提取 Controller 和 Action 实现了 IAuthorizeData 接口的 Attribute，如果使用的是默认的DefaultAuthorizationPolicyProvider，则会先创建一个 AuthorizationPolicy 对象作为 AuthorizeFilter 构造函数的参数。
创建 AuthorizationPolicy 对象是由 AuthorizationPolicy 的静态方法 public static async Task<AuthorizationPolicy> CombineAsync(IAuthorizationPolicyProvider policyProvider, IEnumerable<IAuthorizeData> authorizeData) 来完成的。该静态方法会解析 IAuthorizeData 的数据，但不懂解析 IPermissionAuthorizeData。

因为 AuthorizationApplicationModelProvider 类对 AuthorizationPolicy.CombineAsync 静态方法有依赖，这里不得不做一个类似的 PermissionAuthorizationApplicationModelProvider 类，在本类实现 CombineAsync 方法。暂且不论该方法放在本类是否合适的问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

       public static AuthorizeFilter GetFilter(IAuthorizationPolicyProvider policyProvider, IEnumerable<IAuthorizeData> authData)
       {
           // The default policy provider will make the same policy for given input, so make it only once.
           // This will always execute synchronously.
 if (policyProvider.GetType() == typeof(DefaultAuthorizationPolicyProvider))
 {
 var policy = CombineAsync(policyProvider, authData).GetAwaiter().GetResult();
 return new AuthorizeFilter(policy);
 }
 else
 {
 return new AuthorizeFilter(policyProvider, authData);
 }
 }
 private static async Task<AuthorizationPolicy> CombineAsync(IAuthorizationPolicyProvider policyProvider, IEnumerable<IAuthorizeData> authorizeData)
 {
 if (policyProvider == null)
 {
 throw new ArgumentNullException(nameof(policyProvider));
 }
 if (authorizeData == null)
 {
 throw new ArgumentNullException(nameof(authorizeData));
 }
 var policyBuilder = new AuthorizationPolicyBuilder();
 var any = false;
 foreach (var authorizeDatum in authorizeData)
 {
 any = true;
 var useDefaultPolicy = true;
 if (!string.IsNullOrWhiteSpace(authorizeDatum.Policy))
 {
 var policy = await policyProvider.GetPolicyAsync(authorizeDatum.Policy);
 if (policy == null)
 {
 //throw new InvalidOperationException(Resources.FormatException_AuthorizationPolicyNotFound(authorizeDatum.Policy));
 throw new InvalidOperationException(nameof(authorizeDatum.Policy));
 }
policyBuilder.Combine(policy);
 useDefaultPolicy = false;
 }
 var rolesSplit = authorizeDatum.Roles?.Split('','');
 if (rolesSplit != null && rolesSplit.Any())
 {
 var trimmedRolesSplit = rolesSplit.Where(r => !string.IsNullOrWhiteSpace(r)).Select(r => r.Trim());
 policyBuilder.RequireRole(trimmedRolesSplit);
 useDefaultPolicy = false;
 }
 if(authorizeDatum is IPermissionAuthorizeData permissionAuthorizeDatum )
 {
 var groupsSplit = permissionAuthorizeDatum.Groups?.Split('','');
 if (groupsSplit != null && groupsSplit.Any())
 {
 var trimmedGroupsSplit = groupsSplit.Where(r => !string.IsNullOrWhiteSpace(r)).Select(r => r.Trim());
 policyBuilder.RequireClaim("Group", trimmedGroupsSplit); // TODO: 注意硬编码
 useDefaultPolicy = false;
 }
 var permissionsSplit = permissionAuthorizeDatum.Permissions?.Split('','');
 if (permissionsSplit != null && permissionsSplit.Any())
 {
 var trimmedPermissionsSplit = permissionsSplit.Where(r => !string.IsNullOrWhiteSpace(r)).Select(r => r.Trim());
 policyBuilder.RequireClaim("Permission", trimmedPermissionsSplit);// TODO: 注意硬编码
 useDefaultPolicy = false;
 }
 }
 var authTypesSplit = authorizeDatum.AuthenticationSchemes?.Split('','');
 if (authTypesSplit != null && authTypesSplit.Any())
 {
 foreach (var authType in authTypesSplit)
 {
 if (!string.IsNullOrWhiteSpace(authType))
 {
 policyBuilder.AuthenticationSchemes.Add(authType.Trim());
 }
 }
 }
 if (useDefaultPolicy)
 {
policyBuilder.Combine(await policyProvider.GetDefaultPolicyAsync());
 }
 }
 return any ? policyBuilder.Build() : null;
 }

if(authorizeDatum is IPermissionAuthorizeData permissionAuthorizeDatum ) 为扩展部分。

四、Startup

注册 PermissionAuthorizationApplicationModelProvider 服务，需要在 AddMvc 之后替换掉 AuthorizationApplicationModelProvider 服务。

1
2

services.AddMvc();
services.Replac(ServiceDescriptor.Transient<IApplicationModelProvider,PermissionAuthorizationApplicationModelProvider>());

五、Jwt 示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

[Route("api/[controller]")]
[ApiController]
public class ValuesController : ControllerBase
{
 private readonly JwtSecurityTokenHandler _tokenHandler = new JwtSecurityTokenHandler();
 [HttpGet]
 [Route("SignIn")]
 public async Task<ActionResult<string>> SignIn()
 {
 var user = new ClaimsPrincipal(new ClaimsIdentity(new[]
 {
 // 备注：Claim Type: Group 和 Permission 这里使用的是硬编码，应该定义为类似于 ClaimTypes.Role 的常量；另外，下列模拟数据不一定合逻辑。
 new Claim(ClaimTypes.Name, "Bob"),
 new Claim(ClaimTypes.Role, "经理"), // 注意：不能使用逗号分隔来达到多个角色的目的，下同。
 new Claim(ClaimTypes.Role, "副经理"),
 new Claim("Group", "研发部"),
 new Claim("Group", "生产部"),
 new Claim("Permission", "请假审批"),
 new Claim("Permission", "权限1"),
 new Claim("Permission", "权限2"),
 }, JwtBearerDefaults.AuthenticationScheme));
 var token = new JwtSecurityToken(
 "SignalRAuthenticationSample",
 "SignalRAuthenticationSample",
 user.Claims,
 expires: DateTime.UtcNow.AddDays(30),
 signingCredentials: SignatureHelper.GenerateSigningCredentials("1234567890123456"));
 return _tokenHandler.WriteToken(token);
 }
 [HttpGet]
 [Route("Test")]
 [PermissionAuthorize(Groups = "研发部,生产部", Roles = "经理", Permissions = "请假审批"] // 研发部经理或生成部经理，并且有请假审批的权限。Groups 、Roles 和 Permission 是 `And` 的关系。
 public async Task<ActionResult<IEnumerable<string>>> Test()
 {
 var user = HttpContext.User;
 return new string[] { "value1", "value2" };
 }
 }

六、问题

AuthorizeFilter 类显示实现了 IFilterFactory 接口的 CreateInstance 方法：

1
2
3
4
5
6
7
8
9
10
11
12

IFilterMetadata IFilterFactory.CreateInstance(IServiceProvider serviceProvider)
{
    if (Policy != null || PolicyProvider != null)
    {
 // The filter is fully constructed. Use the current instance to authorize.
 return this;
 }

 Debug.Assert(AuthorizeData != null);
 var policyProvider = serviceProvider.GetRequiredService<IAuthorizationPolicyProvider>();
 return AuthorizationApplicationModelProvider.GetFilter(policyProvider, AuthorizeData);
}

竟然对 AuthorizationApplicationModelProvider.GetFilter 静态方法产生了依赖。庆幸的是，如果通过 AuthorizeFilter(IAuthorizationPolicyProvider policyProvider, IEnumerable<IAuthorizeData> authorizeData) 或 AuthorizeFilter(AuthorizationPolicy policy) 创建 AuthorizeFilter 对象不会产生什么不良影响。

七、下一步

[PermissionAuthorize(Groups = "研发部,生产部", Roles = "经理", Permissions = "请假审批"] 这种形式还是不够灵活，哪怕用多个 Attribute, And 和 Or 的逻辑组合不一定能满足需求。可以在 IPermissionAuthorizeData 新增一个 Rule 属性，实现类似的效果：

1

[PermissionAuthorize(Rule = "(Groups:研发部,生产部)&&(Roles:请假审批||Permissions:超级权限)"]

通过 Rule 计算复杂的授权。

八、如果通过自定义 IAuthorizationPolicyProvider 实现？

另一种方式是自定义 IAuthorizationPolicyProvider ，不过还需要自定义 AuthorizeFilter。因为当不是使用 DefaultAuthorizationPolicyProvider 而是自定义 IAuthorizationPolicyProvider 时，AuthorizationApplicationModelProvider（或前文定义的 PermissionAuthorizationApplicationModelProvider）会使用 AuthorizeFilter(IAuthorizationPolicyProvider policyProvider, IEnumerable<IAuthorizeData> authorizeData) 创建 AuthorizeFilter 对象，而不是 AuthorizeFilter(AuthorizationPolicy policy)。这会造成 AuthorizeFilter 对象在 OnAuthorizationAsync 时会间接调用 AuthorizationPolicy.CombineAsync 静态方法。

这可以说是一个设计上的缺陷，不应该让 AuthorizationPolicy.CombineAsync 静态方法存在，哪怕提供个 IAuthorizationPolicyCombiner 也好。另外，上文提到的 AuthorizationApplicationModelProvider.GetFilter 静态方法同样不是一种好的设计。等微软想通吧。

参考资料

https://docs.microsoft.com/zh-cn/aspnet/core/security/authorization/iauthorizationpolicyprovider?view=aspnetcore-2.1

排版问题：http://blog.tubumu.com/2018/11/28/aspnetcore-mvc-extend-authorization/