C# ICollection.Reverse方法代码示例

 public static int Insert(this Collection<Instruction> collection, int index, ICollection<Instruction> instructions)
 {
     foreach (var instruction in instructions.Reverse())
     {
         collection.Insert(index, instruction);
     }
     return index + instructions.Count();
 }

 public static void InsertAfterInstructions(this ILProcessor il, Instruction target,
     ICollection<Instruction> instructions)
 {
     foreach (var instruction in instructions.Reverse())
     {
         il.InsertAfter(target, instruction);
     }
 }

 void TestDictionary(ICollection<KeyValuePair<int, int>> data)
 {
     var sw = new Stopwatch();
     sw.Start();
     var dic = new Dictionary<int, int>(data.Count);
     foreach (var d in data)
         dic[d.Key] = d.Value;
     sw.Stop();
     var sw2 = new Stopwatch();
     sw2.Start();
     foreach (var d in data.Reverse())
         Assert.AreEqual(d.Value, dic[d.Key]);
     sw2.Stop();
     Console.WriteLine("Dictionary: creation=" + sw.Elapsed + ", search=" + sw2.Elapsed);
 }

    /// <summary>
    /// Inserts a set of instructions at a given <paramref name="exitPointInstructionIndex"/>, ensuring that all branches that previously
    /// pointed to the return statement now point to the new instructions.
    /// 
    /// It's important that this method is only called for RET instruction exit points, otherwise we'd also need to fix
    /// up ExceptionHandler delimiter points.
    /// </summary>
    public static void InsertAtMethodReturnPoint(this MethodBody methodBody, int exitPointInstructionIndex, ICollection<Instruction> instructions)
    {
        var exitPointInstruction = methodBody.Instructions[exitPointInstructionIndex];

        var targetUpdateActions = GetMethodReturnPointReferenceTargetUpdateActions(methodBody.Instructions, exitPointInstruction).ToList();

        foreach (var instruction in instructions.Reverse())
        {
            methodBody.Instructions.Insert(exitPointInstructionIndex, instruction);
        }

        var newTargetInstruction = instructions.First();
        foreach (var targetUpdateAction in targetUpdateActions)
        {
            targetUpdateAction(newTargetInstruction);
        }
    }

        private static HandlerMiddleware GetFirstMiddleware(ICollection<KeyValuePair<object, object[]>> middlewareItems)
        {
            if (middlewareItems.Count == 0)
                return EmptyHandlerMiddleware.Instance;

            var middlewares = new List<HandlerMiddleware>();
            foreach (var item in middlewareItems.Reverse())
            {
                var lastMiddleware = middlewares.LastOrDefault() ?? EmptyHandlerMiddleware.Instance;

                IEnumerable<object> args = new object[] { lastMiddleware };
                if (item.Value != null && item.Value.Any())
                {
                    args = args.Concat(item.Value);
                }

                middlewares.Add(GetHandlerMiddleware(item.Key, args.ToArray()));
            }
            middlewares.Reverse();
            return middlewares.FirstOrDefault();
        }

        protected virtual ResultExecutedContext InvokeActionResultFilters(
            ControllerContext context, ICollection<IResultFilter> filters, ActionResult result)
        {
            Precondition.Require(context, () => Error.ArgumentNull("context"));
            Precondition.Require(result, () => Error.ArgumentNull("result"));
            Precondition.Require(filters, () => Error.ArgumentNull("filters"));

            ResultExecutionContext rec = new ResultExecutionContext(context, result);
            Func<ResultExecutedContext> continuation = () => {
                InvokeActionResult(context, result);
                return new ResultExecutedContext(context, rec.Result, null);
            };

            Func<ResultExecutedContext> thunk = filters.Reverse().Aggregate(continuation,
                (next, filter) => () => InvokeActionResultFilter(filter, rec, next));
            return thunk();
        }

        protected virtual ActionExecutedContext InvokeActionFilters(
            ControllerContext context, ActionDescriptor action, 
            ICollection<IActionFilter> filters)
        {
            Precondition.Require(context, () => Error.ArgumentNull("context"));
            Precondition.Require(action, () => Error.ArgumentNull("action"));
            Precondition.Require(filters, () => Error.ArgumentNull("filters"));
            
            ActionExecutionContext exc = new ActionExecutionContext(context, action);
            Func<ActionExecutedContext> continuation = () =>
                new ActionExecutedContext(exc, null) { 
					Result = InvokeActionMethod(context, action, context.Parameters) 
				};

            Func<ActionExecutedContext> thunk = filters.Reverse().Aggregate(continuation,
                (next, filter) => () => InvokeActionFilter(filter, exc, next));
            return thunk();
        }

        protected virtual void Rollback(ICollection<NewPackageAction> executedActions, IExecutionContext context)
        {
            if (executedActions.Count > 0)
            {
                // Only print the rollback warning if we have something to rollback
                context.Log(MessageLevel.Warning, Strings.ActionExecutor_RollingBack);
            }

            foreach (var action in executedActions.Reverse())
            {
                IActionHandler handler;
                if (!_actionHandlers.TryGetValue(action.ActionType, out handler))
                {
                    NuGetTraceSources.ActionExecutor.Error(
                        "rollback/unhandledaction",
                        "[{0}] Skipping unknown action: {1}",
                        action.PackageIdentity,
                        action.ToString());
                }
                else
                {
                    NuGetTraceSources.ActionExecutor.Info(
                        "rollback/executing",
                        "[{0}] Executing action: {1}",
                        action.PackageIdentity,
                        action.ToString());
                    handler.Rollback(action, context);
                }
            }
        }

		protected virtual IAsyncResult BeginInvokeActionFilters(ControllerContext context,
			ActionDescriptor action, ICollection<IActionFilter> filters, IDictionary<string, object> parameters,
			AsyncCallback callback, object state)
		{
			Func<ActionExecutedContext> endContinuation = null;

			BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState) {
				ActionExecutionContext preContext = new ActionExecutionContext(context, action);
				IAsyncResult innerAsyncResult = null;

				Func<Func<ActionExecutedContext>> beginContinuation = () => {
					innerAsyncResult = BeginInvokeActionMethod(context, action, parameters, asyncCallback, asyncState);
					return () => new ActionExecutedContext(preContext, null) {
						Result = EndInvokeActionMethod(innerAsyncResult)
					};
				};
				Func<Func<ActionExecutedContext>> thunk = filters.Reverse().Aggregate(beginContinuation,
					(next, filter) => () => InvokeActionFilterAsynchronously(filter, preContext, next));
				endContinuation = thunk();

				if (innerAsyncResult != null)
				{
					return innerAsyncResult;
				}
				else
				{
					MvcAsyncResult newAsyncResult = new MvcAsyncResult(asyncState);
					newAsyncResult.MarkCompleted(true, asyncCallback);

					return newAsyncResult;
				}
			};
			EndInvokeDelegate<ActionExecutedContext> endDelegate = delegate(IAsyncResult asyncResult) {
				return endContinuation();
			};
			return AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _invokeMethodFiltersTag);
		}