本文整理汇总了C#中Mono.Cecil.TypeReference.CopyGeneric方法的典型用法代码示例。如果您正苦于以下问题:C# TypeReference.CopyGeneric方法的具体用法?C# TypeReference.CopyGeneric怎么用?C# TypeReference.CopyGeneric使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类Mono.Cecil.TypeReference
的用法示例。
在下文中一共展示了TypeReference.CopyGeneric方法的2个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: ImplementWait
protected virtual IEnumerable<Instruction> ImplementWait(Instruction instruction, TypeReference waitFutureType)
{
//FIXME: We're reordering instructions to keep the stack balanced before/after continuation.
// Better to save/restore the stack instead? ->
// Foo (MayThrow (), GetSomeFuture ().Wait ());
// Normally, if MayThrow () throws an exception, GetSomeFuture () is not called. But because we're
// reordering, GetSomeFuture *is* called, the future is waited, and then MayThrow throws on the continuation.
//FIXME: Support multiple predecessors here!
var lastStack = cfg.FindLastStackItem (block, instruction, IsBarrier).Single (); // this is the Future
// these are the items on the stack before the Future. they will be moved til after the continuation
var continuationInst = cfg.FindStackHeight (block, lastStack, 0, IsBarrier).Single ();
IList<Instruction> precontinuationStack = null;
if (continuationInst != lastStack) {
precontinuationStack = ExtractInstructionRange (continuationInst, lastStack);
// FIXME: Currently, we can't handle any jumps into this critical area
if (precontinuationStack.Any (i => method.Body.IsJumpTarget (i)))
throw new NotSupportedException ("Support for jumps into continuation critical area not implemented");
}
// Insert ldarg.0 for CoroutineFuture.Chain
// FIXME: Right now, we're depending on the C# compiler's behavior re. not separating arg0 from call
InsertBefore (lastStack, Instruction.Create (OpCodes.Ldarg_0));
var chainInstructions = new List<Instruction> ();
chainInstructions.Add (Instruction.Create (OpCodes.Call, chain));
var continuation = Instruction.Create (OpCodes.Ret);
continuations.Add (continuation);
var afterContinuation = Instruction.Create (OpCodes.Ldarg_0);
// CoroutineFuture.Chain returns false if we don't need continuation
chainInstructions.Add (Instruction.Create (OpCodes.Brfalse_S, afterContinuation));
chainInstructions.Add (continuation);
chainInstructions.Add (afterContinuation);
// this is the instruction that will follow if the future is not faulted
var notFaulted = Instruction.Create (OpCodes.Nop);
// check for exceptions
chainInstructions.Add (Instruction.Create (OpCodes.Call, checkException));
chainInstructions.Add (Instruction.Create (OpCodes.Ldarg_0));
chainInstructions.Add (Instruction.Create (OpCodes.Ldfld, chainedFld));
chainInstructions.Add (Instruction.Create (OpCodes.Callvirt, module.Import (getException)));
chainInstructions.Add (Instruction.Create (OpCodes.Brfalse, notFaulted));
// mark exception as handled and throw it again right there
chainInstructions.Add (Instruction.Create (OpCodes.Ldarg_0));
chainInstructions.Add (Instruction.Create (OpCodes.Ldfld, chainedFld));
chainInstructions.Add (Instruction.Create (OpCodes.Dup));
chainInstructions.Add (Instruction.Create (OpCodes.Ldc_I4, -1));
chainInstructions.Add (Instruction.Create (OpCodes.Call, module.Import (setStatus)));
chainInstructions.Add (Instruction.Create (OpCodes.Callvirt, module.Import (getException)));
chainInstructions.Add (Instruction.Create (OpCodes.Throw));
// redirect jumps from our phony Wait call to the chain call.
method.Body.Instructions.RedirectJumps (instruction, chainInstructions [0]);
// -- add continuation to InstructionMap
InstructionMap.Add (chainInstructions [0], chainInstructions);
yield return notFaulted;
// move anything on the stack before the Wait to after the continuation
if (precontinuationStack != null) {
foreach (var inst in precontinuationStack)
yield return inst;
}
// load the continuation result if there is one
// FIXME: Eventually, we prolly don't want to do this if we're just going to pop the result..
// but we'd have to get rid of the pop instruction too...
if (waitFutureType != null /* && instruction.Next.OpCode != OpCodes.Pop */) {
var genWaitFuture = waitFutureType.CopyGeneric (coroutineType, skews);
yield return Instruction.Create (OpCodes.Ldarg_0);
yield return Instruction.Create (OpCodes.Ldfld, chainedFld);
yield return Instruction.Create (OpCodes.Isinst, genWaitFuture);
yield return Instruction.Create (OpCodes.Call, module.ImportFrom (getValue, genWaitFuture));
}
// reset chained to null
yield return Instruction.Create (OpCodes.Ldarg_0);
yield return Instruction.Create (OpCodes.Ldnull);
yield return Instruction.Create (OpCodes.Stfld, chainedFld);
}
示例2: FixTypeToken
// -----
// We are taking a method implementation and extracting it into its own class.
// If the method is generic, we need to make that class generic and update any
// type refs to the old method's generic parameters to refer to the new class's
// generic parameters instead.
protected TypeReference FixTypeToken(TypeReference token)
{
return module.Import (token.CopyGeneric (coroutineType, skews));
}