/examples/LinFu.AOP.Samples/lib/LinFu.Core.xml

http://github.com/philiplaureano/LinFu · XML · 8820 lines · 8807 code · 13 blank · 0 comment · 0 complexity · 1cd6dbb55b0150450458ffc2ba0ab17d MD5 · raw file

Large files are truncated click here to view the full file

    

  1. <?xml version="1.0"?>
    2. 

  2. <doc>
    3. 

  3.   <assembly>
    4. 

  4.     <name>LinFu.Core</name>
    5. 

  5.   </assembly>
    6. 

  6.   <members>
    7. 

  7.     <member name="T:LinFu.AOP.Cecil.Interfaces.IMethodBodyRewriter">
    8. 

  8.       <summary>
    9. 

  9.             Represents a type that can modify method bodies.
    10. 

  10.             </summary>
    11. 

  11.     </member>
    12. 

  12.     <member name="M:LinFu.AOP.Cecil.Interfaces.IMethodBodyRewriter.Rewrite(Mono.Cecil.MethodDefinition,Mono.Cecil.Cil.CilWorker,System.Collections.Generic.IEnumerable{Mono.Cecil.Cil.Instruction})">
    13. 

  13.       <summary>
    14. 

  14.             Rewrites a target method using the given CilWorker.
    15. 

  15.             </summary>
    16. 

  16.       <param name="method">The target method.</param>
    17. 

  17.       <param name="IL">The CilWorker that will be used to rewrite the target method.</param>
    18. 

  18.       <param name="oldInstructions">The original instructions from the target method body.</param>
    19. 

  19.     </member>
    20. 

  20.     <member name="T:LinFu.AOP.Cecil.Interfaces.IHostWeaver`1">
    21. 

  21.       <summary>
    22. 

  22.             Represents a weaver class that can modify its host.
    23. 

  23.             </summary>
    24. 

  24.       <typeparam name="THost">The host that holds the item to be modified.</typeparam>
    25. 

  25.     </member>
    26. 

  26.     <member name="M:LinFu.AOP.Cecil.Interfaces.IHostWeaver`1.ImportReferences(Mono.Cecil.ModuleDefinition)">
    27. 

  27.       <summary>
    28. 

  28.             Imports references into the target <see cref="T:Mono.Cecil.ModuleDefinition" /> instance.
    29. 

  29.             </summary>
    30. 

  30.       <param name="module">The module that will hold the modified item.</param>
    31. 

  31.     </member>
    32. 

  32.     <member name="M:LinFu.AOP.Cecil.Interfaces.IHostWeaver`1.AddAdditionalMembers(`0)">
    33. 

  33.       <summary>
    34. 

  34.             Adds additional members to the host type.
    35. 

  35.             </summary>
    36. 

  36.       <param name="host">The host that holds the current item being modified.</param>
    37. 

  37.     </member>
    38. 

  38.     <member name="T:LinFu.AOP.Cecil.Interfaces.IMethodRewriter">
    39. 

  39.       <summary>
    40. 

  40.             Represents a type that can modify method bodies.
    41. 

  41.             </summary>
    42. 

  42.     </member>
    43. 

  43.     <member name="M:LinFu.AOP.Cecil.Interfaces.IMethodRewriter.AddLocals(Mono.Cecil.MethodDefinition)">
    44. 

  44.       <summary>
    45. 

  45.             Adds local variables to the <paramref name="hostMethod" />.
    46. 

  46.             </summary>
    47. 

  47.       <param name="hostMethod">The target method.</param>
    48. 

  48.     </member>
    49. 

  49.     <member name="T:LinFu.AOP.Cecil.BaseMethodRewriter">
    50. 

  50.       <summary>
    51. 

  51.             Represents the basic implementation of a method rewriter class.
    52. 

  52.             </summary>
    53. 

  53.     </member>
    54. 

  54.     <member name="M:LinFu.AOP.Cecil.BaseMethodRewriter.Rewrite(Mono.Cecil.MethodDefinition,Mono.Cecil.Cil.CilWorker,System.Collections.Generic.IEnumerable{Mono.Cecil.Cil.Instruction})">
    55. 

  55.       <summary>
    56. 

  56.             Rewrites a target method using the given CilWorker.
    57. 

  57.             </summary>
    58. 

  58.       <param name="method">The target method.</param>
    59. 

  59.       <param name="IL">The CilWorker that will be used to rewrite the target method.</param>
    60. 

  60.       <param name="oldInstructions">The original instructions from the target method body.</param>
    61. 

  61.     </member>
    62. 

  62.     <member name="M:LinFu.AOP.Cecil.BaseMethodRewriter.AddAdditionalMembers(Mono.Cecil.TypeDefinition)">
    63. 

  63.       <summary>
    64. 

  64.             Adds additional members to the host type.
    65. 

  65.             </summary>
    66. 

  66.       <param name="host">The host type.</param>
    67. 

  67.     </member>
    68. 

  68.     <member name="M:LinFu.AOP.Cecil.BaseMethodRewriter.ImportReferences(Mono.Cecil.ModuleDefinition)">
    69. 

  69.       <summary>
    70. 

  70.             Adds additional references to the target module.
    71. 

  71.             </summary>
    72. 

  72.       <param name="module">The host module.</param>
    73. 

  73.     </member>
    74. 

  74.     <member name="M:LinFu.AOP.Cecil.BaseMethodRewriter.AddLocals(Mono.Cecil.MethodDefinition)">
    75. 

  75.       <summary>
    76. 

  76.             Adds local variables to the <paramref name="hostMethod" />.
    77. 

  77.             </summary>
    78. 

  78.       <param name="hostMethod">The target method.</param>
    79. 

  79.     </member>
    80. 

  80.     <member name="M:LinFu.AOP.Cecil.BaseMethodRewriter.ShouldRewrite(Mono.Cecil.MethodDefinition)">
    81. 

  81.       <summary>
    82. 

  82.             Determines whether or not the given method should be modified.
    83. 

  83.             </summary>
    84. 

  84.       <param name="targetMethod">The target method.</param>
    85. 

  85.       <returns>A <see cref="T:System.Boolean" /> indicating whether or not a method should be rewritten.</returns>
    86. 

  86.     </member>
    87. 

  87.     <member name="M:LinFu.AOP.Cecil.BaseMethodRewriter.RewriteMethodBody(Mono.Cecil.MethodDefinition,Mono.Cecil.Cil.CilWorker,System.Collections.Generic.IEnumerable{Mono.Cecil.Cil.Instruction})">
    88. 

  88.       <summary>
    89. 

  89.             Rewrites the instructions in the target method body.
    90. 

  90.             </summary>
    91. 

  91.       <param name="method">The target method.</param>
    92. 

  92.       <param name="IL">The <see cref="T:Mono.Cecil.Cil.CilWorker" /> instance that represents the method body.</param>
    93. 

  93.       <param name="oldInstructions">The IL instructions of the original method body.</param>
    94. 

  94.     </member>
    95. 

  95.     <member name="T:LinFu.AOP.Cecil.CatchAllThrownExceptions">
    96. 

  96.       <summary>
    97. 

  97.             Represents a method rewriter that modifies a method body to support dynamic exception handling.
    98. 

  98.             </summary>
    99. 

  99.     </member>
    100. 

  100.     <member name="M:LinFu.AOP.Cecil.CatchAllThrownExceptions.ImportReferences(Mono.Cecil.ModuleDefinition)">
    101. 

  101.       <summary>
    102. 

  102.             Adds additional references to the target module.
    103. 

  103.             </summary>
    104. 

  104.       <param name="module">The host module.</param>
    105. 

  105.     </member>
    106. 

  106.     <member name="M:LinFu.AOP.Cecil.CatchAllThrownExceptions.AddLocals(Mono.Cecil.MethodDefinition)">
    107. 

  107.       <summary>
    108. 

  108.             Adds local variables to the <paramref name="hostMethod" />.
    109. 

  109.             </summary>
    110. 

  110.       <param name="hostMethod">The target method.</param>
    111. 

  111.     </member>
    112. 

  112.     <member name="M:LinFu.AOP.Cecil.CatchAllThrownExceptions.RewriteMethodBody(Mono.Cecil.MethodDefinition,Mono.Cecil.Cil.CilWorker,System.Collections.Generic.IEnumerable{Mono.Cecil.Cil.Instruction})">
    113. 

  113.       <summary>
    114. 

  114.             Rewrites the instructions in the target method body to support dynamic exception handling.
    115. 

  115.             </summary>
    116. 

  116.       <param name="targetMethod">The target method.</param>
    117. 

  117.       <param name="IL">The <see cref="T:Mono.Cecil.Cil.CilWorker" /> instance that represents the method body.</param>
    118. 

  118.       <param name="oldInstructions">The IL instructions of the original method body.</param>
    119. 

  119.     </member>
    120. 

  120.     <member name="M:LinFu.AOP.Cecil.CatchAllThrownExceptions.SaveExceptionInfo(Mono.Cecil.MethodDefinition,LinFu.AOP.Cecil.Interfaces.IEmitInvocationInfo)">
    121. 

  121.       <summary>
    122. 

  122.             Saves the current <see cref="T:LinFu.AOP.Interfaces.IExceptionHandlerInfo" /> instance.
    123. 

  123.             </summary>
    124. 

  124.       <param name="targetMethod">The target method.</param>
    125. 

  125.       <param name="emitter">The <see cref="T:LinFu.AOP.Cecil.Interfaces.IEmitInvocationInfo" /> instance that will emit the current method context.</param>
    126. 

  126.     </member>
    127. 

  127.     <member name="T:LinFu.AOP.Cecil.Interfaces.IInstructionEmitter">
    128. 

  128.       <summary>
    129. 

  129.             Represents a type that is capable of manipulating instructions within a given method body.
    130. 

  130.             </summary>
    131. 

  131.     </member>
    132. 

  132.     <member name="M:LinFu.AOP.Cecil.Interfaces.IInstructionEmitter.Emit(Mono.Cecil.Cil.CilWorker)">
    133. 

  133.       <summary>
    134. 

  134.             Emits a set of instructions to the given <paramref name="IL">CilWorker</paramref>.
    135. 

  135.             </summary>
    136. 

  136.       <param name="IL">The <see cref="T:Mono.Cecil.Cil.CilWorker" /> responsible for the target method body.</param>
    137. 

  137.     </member>
    138. 

  138.     <member name="T:LinFu.AOP.Cecil.AddMethodReplacementImplementation">
    139. 

  139.       <summary>
    140. 

  140.             Represents an instruction emitter that adds method body replacement support to a given method body.
    141. 

  141.             </summary>
    142. 

  142.     </member>
    143. 

  143.     <member name="M:LinFu.AOP.Cecil.AddMethodReplacementImplementation.#ctor(LinFu.AOP.Cecil.IMethodBodyRewriterParameters)">
    144. 

  144.       <summary>
    145. 

  145.             Initializes a new instance of the <see cref="T:LinFu.AOP.Cecil.AddMethodReplacementImplementation" /> class.
    146. 

  146.             </summary>
    147. 

  147.       <param name="parameters">The set of parameters that describe the target method body.</param>
    148. 

  148.     </member>
    149. 

  149.     <member name="M:LinFu.AOP.Cecil.AddMethodReplacementImplementation.Emit(Mono.Cecil.Cil.CilWorker)">
    150. 

  150.       <summary>
    151. 

  151.             Adds method body interception to the target method.
    152. 

  152.             </summary>
    153. 

  153.       <param name="IL">The <see cref="T:Mono.Cecil.Cil.CilWorker" /> pointing to the target method body.</param>
    154. 

  154.     </member>
    155. 

  155.     <member name="T:LinFu.AOP.Cecil.AddOriginalInstructions">
    156. 

  156.       <summary>
    157. 

  157.             Represents an instruction emitter that adds the original method instructions to a given method body.
    158. 

  158.             </summary>
    159. 

  159.     </member>
    160. 

  160.     <member name="M:LinFu.AOP.Cecil.AddOriginalInstructions.#ctor(System.Collections.Generic.IEnumerable{Mono.Cecil.Cil.Instruction},Mono.Cecil.Cil.Instruction)">
    161. 

  161.       <summary>
    162. 

  162.             Initializes a new instance of the <see cref="T:LinFu.AOP.Cecil.AddOriginalInstructions" /> class.
    163. 

  163.             </summary>
    164. 

  164.       <param name="oldInstructions">The original method instructions.</param>
    165. 

  165.       <param name="endLabel">The instruction label that marks the end of the method body.</param>
    166. 

  166.     </member>
    167. 

  167.     <member name="M:LinFu.AOP.Cecil.AddOriginalInstructions.Emit(Mono.Cecil.Cil.CilWorker)">
    168. 

  168.       <summary>
    169. 

  169.             Adds the original instructions to a given method body.
    170. 

  170.             </summary>
    171. 

  171.       <param name="IL">The <see cref="T:Mono.Cecil.Cil.CilWorker" /> responsible for the target method body.</param>
    172. 

  172.     </member>
    173. 

  173.     <member name="T:LinFu.AOP.Cecil.AssemblyDefinitionExtensions">
    174. 

  174.       <summary>
    175. 

  175.             A class that extends <see cref="T:Mono.Cecil.AssemblyDefinition" /> instances.
    176. 

  176.             </summary>
    177. 

  177.     </member>
    178. 

  178.     <member name="M:LinFu.AOP.Cecil.AssemblyDefinitionExtensions.RemoveStrongName(Mono.Cecil.AssemblyDefinition)">
    179. 

  179.       <summary>
    180. 

  180.             Removes the strong-name signature from the <paramref name="sourceAssembly" />.
    181. 

  181.             </summary>
    182. 

  182.       <param name="sourceAssembly">
    183. 

  183.       </param>
    184. 

  184.     </member>
    185. 

  185.     <member name="T:LinFu.AOP.Cecil.Extensions.CecilVisitorExtensions">
    186. 

  186.       <summary>
    187. 

  187.             A helper class that extends Cecil to support LinFu's weaver model.
    188. 

  188.             </summary>
    189. 

  189.     </member>
    190. 

  190.     <member name="M:LinFu.AOP.Cecil.Extensions.CecilVisitorExtensions.Accept(Mono.Cecil.IReflectionVisitable,LinFu.AOP.Cecil.Interfaces.ITypeWeaver)">
    191. 

  191.       <summary>
    192. 

  192.             Allows a <see cref="T:LinFu.AOP.Cecil.Interfaces.ITypeWeaver" /> instance to traverse any <see cref="T:Mono.Cecil.IReflectionVisitable" />
    193. 

  193.             instance.
    194. 

  194.             </summary>
    195. 

  195.       <param name="visitable">The visitable object.</param>
    196. 

  196.       <param name="typeWeaver">The type weaver.</param>
    197. 

  197.     </member>
    198. 

  198.     <member name="M:LinFu.AOP.Cecil.Extensions.CecilVisitorExtensions.Accept(Mono.Cecil.IReflectionStructureVisitable,LinFu.AOP.Cecil.Interfaces.ITypeWeaver)">
    199. 

  199.       <summary>
    200. 

  200.             Allows a <see cref="T:LinFu.AOP.Cecil.Interfaces.ITypeWeaver" /> instance to traverse any <see cref="T:Mono.Cecil.IReflectionStructureVisitable" />
    201. 

  201.             instance.
    202. 

  202.             </summary>
    203. 

  203.       <param name="visitable">The visitable object.</param>
    204. 

  204.       <param name="typeWeaver">The type weaver.</param>
    205. 

  205.     </member>
    206. 

  206.     <member name="M:LinFu.AOP.Cecil.Extensions.CecilVisitorExtensions.Accept(Mono.Cecil.IReflectionStructureVisitable,LinFu.AOP.Cecil.Interfaces.IMethodWeaver)">
    207. 

  207.       <summary>
    208. 

  208.             Allows a <see cref="T:LinFu.AOP.Cecil.Interfaces.IMethodWeaver" /> instance to traverse any <see cref="T:Mono.Cecil.IReflectionVisitable" />
    209. 

  209.             instance.
    210. 

  210.             </summary>
    211. 

  211.       <param name="visitable">The visitable object.</param>
    212. 

  212.       <param name="methodWeaver">The method weaver.</param>
    213. 

  213.     </member>
    214. 

  214.     <member name="M:LinFu.AOP.Cecil.Extensions.CecilVisitorExtensions.Accept(Mono.Cecil.IReflectionVisitable,LinFu.AOP.Cecil.Interfaces.IMethodWeaver)">
    215. 

  215.       <summary>
    216. 

  216.             Allows a <see cref="T:LinFu.AOP.Cecil.Interfaces.IMethodWeaver" /> instance to traverse any <see cref="T:Mono.Cecil.IReflectionVisitable" />
    217. 

  217.             instance.
    218. 

  218.             </summary>
    219. 

  219.       <param name="visitable">The visitable object.</param>
    220. 

  220.       <param name="methodWeaver">The method weaver.</param>
    221. 

  221.     </member>
    222. 

  222.     <member name="T:LinFu.AOP.Cecil.EmitAfterInvoke">
    223. 

  223.       <summary>
    224. 

  224.             Represents a type that emits the call to the <see cref="T:LinFu.AOP.Interfaces.IAfterInvoke" /> instance.
    225. 

  225.             </summary>
    226. 

  226.     </member>
    227. 

  227.     <member name="M:LinFu.AOP.Cecil.EmitAfterInvoke.#ctor(Mono.Cecil.Cil.VariableDefinition,Mono.Cecil.Cil.VariableDefinition,Mono.Cecil.Cil.VariableDefinition,Mono.Cecil.Cil.VariableDefinition)">
    228. 

  228.       <summary>
    229. 

  229.             Initializes a new instance of the <see cref="T:LinFu.AOP.Cecil.EmitAfterInvoke" /> class.
    230. 

  230.             </summary>
    231. 

  231.       <param name="surroundingImplementation">The variable that contains the <see cref="T:LinFu.AOP.Interfaces.IAroundInvoke" /> instance.</param>
    232. 

  232.       <param name="surroundingClassImplementation">The variable that contains the class-level <see cref="T:LinFu.AOP.Interfaces.IAroundInvoke" /> instance.</param>
    233. 

  233.       <param name="invocationInfo">The variable that contains the <see cref="T:LinFu.AOP.Interfaces.IInvocationInfo" /> instance.</param>
    234. 

  234.       <param name="returnValue">The local vaiable that contains the return value of the target method.</param>
    235. 

  235.     </member>
    236. 

  236.     <member name="M:LinFu.AOP.Cecil.EmitAfterInvoke.Emit(Mono.Cecil.Cil.CilWorker)">
    237. 

  237.       <summary>
    238. 

  238.             Emits the call to the <see cref="T:LinFu.AOP.Interfaces.IAfterInvoke" /> instance.
    239. 

  239.             </summary>
    240. 

  240.       <param name="IL">The <see cref="T:Mono.Cecil.Cil.CilWorker" /> that points to the current method body.</param>
    241. 

  241.     </member>
    242. 

  242.     <member name="T:LinFu.AOP.Cecil.EmitBeforeInvoke">
    243. 

  243.       <summary>
    244. 

  244.             Represents a type that emits the call to the <see cref="T:LinFu.AOP.Interfaces.IBeforeInvoke" /> instance.
    245. 

  245.             </summary>
    246. 

  246.     </member>
    247. 

  247.     <member name="M:LinFu.AOP.Cecil.EmitBeforeInvoke.#ctor(Mono.Cecil.Cil.VariableDefinition,Mono.Cecil.Cil.VariableDefinition,Mono.Cecil.Cil.VariableDefinition,System.Type)">
    248. 

  248.       <summary>
    249. 

  249.             Initializes a new instance of the <see cref="T:LinFu.AOP.Cecil.EmitBeforeInvoke" /> class.
    250. 

  250.             </summary>
    251. 

  251.       <param name="invocationInfo">The variable that contains the <see cref="T:LinFu.AOP.Interfaces.IInvocationInfo" /> instance.</param>
    252. 

  252.       <param name="surroundingClassImplementation">The variable that contains the class-level <see cref="T:LinFu.AOP.Interfaces.IAroundInvoke" /> instance.</param>
    253. 

  253.       <param name="surroundingImplementation">The variable that contains the instance-level <see cref="T:LinFu.AOP.Interfaces.IAroundInvoke" /> instance.</param>
    254. 

  254.       <param name="registryType">The interception registry type that will be responsible for handling class-level interception events.</param>
    255. 

  255.     </member>
    256. 

  256.     <member name="M:LinFu.AOP.Cecil.EmitBeforeInvoke.Emit(Mono.Cecil.Cil.CilWorker)">
    257. 

  257.       <summary>
    258. 

  258.             Emits the call to the <see cref="T:LinFu.AOP.Interfaces.IAfterInvoke" /> instance.
    259. 

  259.             </summary>
    260. 

  260.       <param name="IL">The <see cref="T:Mono.Cecil.Cil.CilWorker" /> that points to the current method body.</param>
    261. 

  261.     </member>
    262. 

  262.     <member name="T:LinFu.AOP.Cecil.ExceptionHandlerInfo">
    263. 

  263.       <summary>
    264. 

  264.             Represents a class that describes the context of a thrown exception.
    265. 

  265.             </summary>
    266. 

  266.     </member>
    267. 

  267.     <member name="M:LinFu.AOP.Cecil.ExceptionHandlerInfo.#ctor(System.Exception,LinFu.AOP.Interfaces.IInvocationInfo)">
    268. 

  268.       <summary>
    269. 

  269.             Initializes a new instance of the <see cref="T:LinFu.AOP.Cecil.ExceptionHandlerInfo" /> class.
    270. 

  270.             </summary>
    271. 

  271.       <param name="ex">The thrown exception.</param>
    272. 

  272.       <param name="invocationInfo">The <see cref="T:LinFu.AOP.Interfaces.IInvocationInfo" /> instance that describes the context of the method call.</param>
    273. 

  273.     </member>
    274. 

  274.     <member name="P:LinFu.AOP.Cecil.ExceptionHandlerInfo.Exception">
    275. 

  275.       <summary>
    276. 

  276.             Gets the value indicating the thrown exception.
    277. 

  277.             </summary>
    278. 

  278.       <value>The thrown exception.</value>
    279. 

  279.     </member>
    280. 

  280.     <member name="P:LinFu.AOP.Cecil.ExceptionHandlerInfo.InvocationInfo">
    281. 

  281.       <summary>
    282. 

  282.             Gets the value indicating the <see cref="T:LinFu.AOP.Interfaces.IInvocationInfo" /> instance that describes the context of the method
    283. 

  283.             that threw the exception.
    284. 

  284.             </summary>
    285. 

  285.       <value>The <see cref="T:LinFu.AOP.Interfaces.IInvocationInfo" /> instance.</value>
    286. 

  286.     </member>
    287. 

  287.     <member name="P:LinFu.AOP.Cecil.ExceptionHandlerInfo.ReturnValue">
    288. 

  288.       <summary>
    289. 

  289.             Gets or sets the value indicating the return value that will be used in place of the original return value if 
    290. 

  290.             the exception is intercepted by an <see cref="T:LinFu.AOP.Interfaces.IExceptionHandler" /> instance.
    291. 

  291.             </summary>
    292. 

  292.       <value>The method return value.</value>
    293. 

  293.     </member>
    294. 

  294.     <member name="P:LinFu.AOP.Cecil.ExceptionHandlerInfo.ShouldSkipRethrow">
    295. 

  295.       <summary>
    296. 

  296.             Gets or sets the value indicating whether or not the exception should be rethrown after
    297. 

  297.             the <see cref="T:LinFu.AOP.Interfaces.IExceptionHandler" /> handles the given exception.
    298. 

  298.             </summary>
    299. 

  299.       <value>This should be <c>true</c> if the exception should be rethrown, otherwise, it must be <c>false</c>.</value>
    300. 

  300.     </member>
    301. 

  301.     <member name="T:LinFu.AOP.Cecil.Extensions.ExceptionHandlerInterceptionExtensions">
    302. 

  302.       <summary>
    303. 

  303.             Represents an extension class that adds support for intercepting exceptions thrown at runtime.
    304. 

  304.             </summary>
    305. 

  305.     </member>
    306. 

  306.     <member name="M:LinFu.AOP.Cecil.Extensions.ExceptionHandlerInterceptionExtensions.InterceptAllExceptions(Mono.Cecil.IReflectionVisitable)">
    307. 

  307.       <summary>
    308. 

  308.             Enables exception interception on the given type.
    309. 

  309.             </summary>
    310. 

  310.       <param name="visitable">The target type.</param>
    311. 

  311.     </member>
    312. 

  312.     <member name="M:LinFu.AOP.Cecil.Extensions.ExceptionHandlerInterceptionExtensions.InterceptAllExceptions(Mono.Cecil.IReflectionStructureVisitable)">
    313. 

  313.       <summary>
    314. 

  314.             Enables exception interception on the given type.
    315. 

  315.             </summary>
    316. 

  316.       <param name="visitable">The target type.</param>
    317. 

  317.     </member>
    318. 

  318.     <member name="M:LinFu.AOP.Cecil.Extensions.ExceptionHandlerInterceptionExtensions.InterceptExceptions(Mono.Cecil.IReflectionVisitable,LinFu.AOP.Cecil.Interfaces.IMethodFilter)">
    319. 

  319.       <summary>
    320. 

  320.             Enables exception interception on the given type.
    321. 

  321.             </summary>
    322. 

  322.       <param name="visitable">The target type.</param>
    323. 

  323.       <param name="methodFilter">The <see cref="T:LinFu.AOP.Cecil.Interfaces.IMethodFilter" /> instance that will determine which methods should support exception interception.</param>
    324. 

  324.     </member>
    325. 

  325.     <member name="M:LinFu.AOP.Cecil.Extensions.ExceptionHandlerInterceptionExtensions.InterceptExceptions(Mono.Cecil.IReflectionStructureVisitable,LinFu.AOP.Cecil.Interfaces.IMethodFilter)">
    326. 

  326.       <summary>
    327. 

  327.             Enables exception interception on the given type.
    328. 

  328.             </summary>
    329. 

  329.       <param name="visitable">The target type.</param>
    330. 

  330.       <param name="methodFilter">The <see cref="T:LinFu.AOP.Cecil.Interfaces.IMethodFilter" /> instance that will determine which methods should support exception interception.</param>
    331. 

  331.     </member>
    332. 

  332.     <member name="M:LinFu.AOP.Cecil.Extensions.ExceptionHandlerInterceptionExtensions.InterceptExceptions(Mono.Cecil.IReflectionStructureVisitable,System.Func{Mono.Cecil.MethodReference,System.Boolean})">
    333. 

  333.       <summary>
    334. 

  334.             Enables exception interception on the given type.
    335. 

  335.             </summary>
    336. 

  336.       <param name="visitable">The target type.</param>
    337. 

  337.       <param name="methodFilter">The method filter functor that will determine which methods should support exception interception.</param>
    338. 

  338.     </member>
    339. 

  339.     <member name="M:LinFu.AOP.Cecil.Extensions.ExceptionHandlerInterceptionExtensions.InterceptExceptions(Mono.Cecil.IReflectionVisitable,System.Func{Mono.Cecil.MethodReference,System.Boolean})">
    340. 

  340.       <summary>
    341. 

  341.             Enables exception interception on the given type.
    342. 

  342.             </summary>
    343. 

  343.       <param name="visitable">The target type.</param>
    344. 

  344.       <param name="methodFilter">The method filter functor that will determine which methods should support exception interception.</param>
    345. 

  345.     </member>
    346. 

  346.     <member name="T:LinFu.AOP.Cecil.Factories.AddInvocationInfoActionFactory">
    347. 

  347.       <summary>
    348. 

  348.             A factory instance that creates <see cref="T:System.Action`1" /> delegates
    349. 

  349.             that emit the necessary <see cref="T:LinFu.AOP.Interfaces.IInvocationInfo" /> information
    350. 

  350.             and store it in a local variable named '__invocationInfo___'.
    351. 

  351.             </summary>
    352. 

  352.     </member>
    353. 

  353.     <member name="M:LinFu.AOP.Cecil.Factories.AddInvocationInfoActionFactory.CreateInstance(LinFu.IoC.Interfaces.IFactoryRequest)">
    354. 

  354.       <summary>
    355. 

  355.             Generates the <see cref="T:System.Action`1" /> delegate that will emit
    356. 

  356.             the necessary <see cref="T:LinFu.AOP.Interfaces.IInvocationInfo" /> information.
    357. 

  357.             </summary>
    358. 

  358.       <param name="request">The <see cref="T:LinFu.IoC.Interfaces.IFactoryRequest" /> instance that describes the requested service type.</param>
    359. 

  359.       <returns>A delegate that can emit the necessary <see cref="T:LinFu.AOP.Interfaces.IInvocationInfo" /> context that will allow other developers to infer information about the method currently being executed.</returns>
    360. 

  360.     </member>
    361. 

  361.     <member name="T:LinFu.AOP.Cecil.Factories.AssemblyWeaverActionFactory">
    362. 

  362.       <summary>
    363. 

  363.             Represents a class that generates <see cref="T:System.Action`2" /> instances
    364. 

  364.             that apply a specific method weaver (with the name given in the first delegate parameter)
    365. 

  365.             to every type in every module of an <see cref="T:Mono.Cecil.AssemblyDefinition" /> instance.
    366. 

  366.             </summary>
    367. 

  367.     </member>
    368. 

  368.     <member name="M:LinFu.AOP.Cecil.Factories.AssemblyWeaverActionFactory.CreateInstance(LinFu.IoC.Interfaces.IFactoryRequest)">
    369. 

  369.       <summary>
    370. 

  370.             Generates <see cref="T:System.Action`2" /> instances
    371. 

  371.             that apply a specific method weaver (with the name given in the first delegate parameter)
    372. 

  372.             to every type in every module of an <see cref="T:Mono.Cecil.AssemblyDefinition" /> instance.
    373. 

  373.             </summary>
    374. 

  374.       <param name="request">The <see cref="T:LinFu.IoC.Interfaces.IFactoryRequest" /> that describes the service request.</param>
    375. 

  375.       <returns>An action delegate that will apply a specific method weaver to all the types in the given assembly.</returns>
    376. 

  376.     </member>
    377. 

  377.     <member name="T:LinFu.AOP.Cecil.Factories.TypeWeaverActionFactory">
    378. 

  378.       <summary>
    379. 

  379.             Represents a class that generates <see cref="T:System.Action`2" /> instances
    380. 

  380.             that apply a specific method weaver (with the name given in the first delegate parameter)
    381. 

  381.             to a specific <see cref="T:Mono.Cecil.TypeDefinition" /> instance.
    382. 

  382.             </summary>
    383. 

  383.     </member>
    384. 

  384.     <member name="M:LinFu.AOP.Cecil.Factories.TypeWeaverActionFactory.CreateInstance(LinFu.IoC.Interfaces.IFactoryRequest)">
    385. 

  385.       <summary>
    386. 

  386.             Generates the <see cref="T:System.Action`2" /> instance that will
    387. 

  387.             weave the target type.
    388. 

  388.             </summary>
    389. 

  389.       <param name="request">The <see cref="T:LinFu.IoC.Interfaces.IFactoryRequest" /> that describes the service request.</param>
    390. 

  390.       <returns>The <see cref="T:System.Action`2" /> instance that will weave the target type.</returns>
    391. 

  391.     </member>
    392. 

  392.     <member name="T:LinFu.AOP.Cecil.GetMethodReplacementProvider">
    393. 

  393.       <summary>
    394. 

  394.             Represents a class that emits the instructions that obtain an instance-level <see cref="T:LinFu.AOP.Interfaces.IMethodReplacementProvider" /> instance.
    395. 

  395.             </summary>
    396. 

  396.     </member>
    397. 

  397.     <member name="M:LinFu.AOP.Cecil.GetMethodReplacementProvider.#ctor(Mono.Cecil.Cil.VariableDefinition,Mono.Cecil.MethodDefinition,System.Func{Mono.Cecil.ModuleDefinition,Mono.Cecil.MethodReference})">
    398. 

  398.       <summary>
    399. 

  399.             Initializes a new instance of the <see cref="T:LinFu.AOP.Cecil.GetMethodReplacementProvider" /> class.
    400. 

  400.             </summary>
    401. 

  401.       <param name="methodReplacementProvider">The local variable that contains the <see cref="T:LinFu.AOP.Interfaces.IMethodReplacementProvider" /> instance.</param>
    402. 

  402.       <param name="hostMethod">The target method.</param>
    403. 

  403.       <param name="resolveGetProviderMethod">The functor that will resolve the GetProvider method.</param>
    404. 

  404.     </member>
    405. 

  405.     <member name="M:LinFu.AOP.Cecil.GetMethodReplacementProvider.Emit(Mono.Cecil.Cil.CilWorker)">
    406. 

  406.       <summary>
    407. 

  407.             Emits the instructions that obtain the <see cref="T:LinFu.AOP.Interfaces.IMethodReplacementProvider" /> instance.
    408. 

  408.             </summary>
    409. 

  409.       <param name="IL">The <see cref="T:Mono.Cecil.Cil.CilWorker" /> instance.</param>
    410. 

  410.     </member>
    411. 

  411.     <member name="T:LinFu.AOP.Cecil.GetSurroundingClassImplementation">
    412. 

  412.       <summary>
    413. 

  413.             Represents a class that emits the instructions that obtain the <see cref="T:LinFu.AOP.Interfaces.IAroundInvoke" /> instance.
    414. 

  414.             </summary>
    415. 

  415.     </member>
    416. 

  416.     <member name="M:LinFu.AOP.Cecil.GetSurroundingClassImplementation.#ctor(Mono.Cecil.Cil.VariableDefinition,Mono.Cecil.Cil.VariableDefinition,System.Reflection.MethodInfo)">
    417. 

  417.       <summary>
    418. 

  418.             Initializes a new instance of the <see cref="T:LinFu.AOP.Cecil.GetSurroundingClassImplementation" /> class.
    419. 

  419.             </summary>
    420. 

  420.       <param name="invocationInfo">The variable that contains the <see cref="T:LinFu.AOP.Interfaces.IInvocationInfo" /> instance.</param>
    421. 

  421.       <param name="surroundingClassImplementation">The variable that contains the <see cref="T:LinFu.AOP.Interfaces.IAroundInvoke" /> instance.</param>
    422. 

  422.       <param name="getSurroundingImplementationMethod">The method that will obtain the <see cref="T:LinFu.AOP.Interfaces.IAroundInvoke" /> instance.</param>
    423. 

  423.     </member>
    424. 

  424.     <member name="M:LinFu.AOP.Cecil.GetSurroundingClassImplementation.Emit(Mono.Cecil.Cil.CilWorker)">
    425. 

  425.       <summary>
    426. 

  426.             Emits the instructions that obtain the <see cref="T:LinFu.AOP.Interfaces.IAroundInvoke" /> instance.
    427. 

  427.             </summary>
    428. 

  428.       <param name="IL">The <see cref="T:Mono.Cecil.Cil.CilWorker" /> that points to the current method body.</param>
    429. 

  429.     </member>
    430. 

  430.     <member name="T:LinFu.AOP.Cecil.GetSurroundingImplementationInstance">
    431. 

  431.       <summary>
    432. 

  432.             Represents a class that emits the instructions that obtain the current <see cref="T:LinFu.AOP.Interfaces.IAroundInvoke" /> instance.
    433. 

  433.             </summary>
    434. 

  434.     </member>
    435. 

  435.     <member name="M:LinFu.AOP.Cecil.GetSurroundingImplementationInstance.#ctor(Mono.Cecil.Cil.VariableDefinition,Mono.Cecil.Cil.VariableDefinition,Mono.Cecil.Cil.VariableDefinition,Mono.Cecil.Cil.Instruction)">
    436. 

  436.       <summary>
    437. 

  437.             Initializes a new instance of the <see cref="T:LinFu.AOP.Cecil.GetSurroundingImplementationInstance" /> class.
    438. 

  438.             </summary>
    439. 

  439.       <param name="aroundInvokeProvider">The variable that will hold the <see cref="T:LinFu.AOP.Interfaces.IAroundInvokeProvider" /> instance.</param>
    440. 

  440.       <param name="invocationInfo">
    441. 

  441.       </param>
    442. 

  442.       <param name="surroundingImplementation">
    443. 

  443.       </param>
    444. 

  444.       <param name="skipGetSurroundingImplementation">
    445. 

  445.       </param>
    446. 

  446.     </member>
    447. 

  447.     <member name="M:LinFu.AOP.Cecil.GetSurroundingImplementationInstance.Emit(Mono.Cecil.Cil.CilWorker)">
    448. 

  448.       <summary>
    449. 

  449.             Emits the instructions that obtain the current <see cref="T:LinFu.AOP.Interfaces.IAroundInvoke" /> instance.
    450. 

  450.             </summary>
    451. 

  451.       <param name="IL">
    452. 

  452.       </param>
    453. 

  453.     </member>
    454. 

  454.     <member name="T:LinFu.AOP.Cecil.GetAroundInvokeProvider">
    455. 

  455.       <summary>
    456. 

  456.             Represents a class that emits the call to obtain the <see cref="T:LinFu.AOP.Interfaces.IAroundInvokeProvider" /> instance.
    457. 

  457.             </summary>
    458. 

  458.     </member>
    459. 

  459.     <member name="M:LinFu.AOP.Cecil.GetAroundInvokeProvider.#ctor(Mono.Cecil.Cil.VariableDefinition,System.String)">
    460. 

  460.       <summary>
    461. 

  461.             Initializes a new instance of the <see cref="T:LinFu.AOP.Cecil.GetAroundInvokeProvider" /> class.
    462. 

  462.             </summary>
    463. 

  463.       <param name="aroundInvokeProvider">The local variable that holds the <see cref="T:LinFu.AOP.Interfaces.IAroundInvokeProvider" /> instance.</param>
    464. 

  464.       <param name="providerName">The name of the <see cref="T:LinFu.AOP.Interfaces.IAroundInvokeProvider" /> property.</param>
    465. 

  465.     </member>
    466. 

  466.     <member name="M:LinFu.AOP.Cecil.GetAroundInvokeProvider.Emit(Mono.Cecil.Cil.CilWorker)">
    467. 

  467.       <summary>
    468. 

  468.             Emits the call to obtain the <see cref="T:LinFu.AOP.Interfaces.IAroundInvokeProvider" /> instance.
    469. 

  469.             </summary>
    470. 

  470.       <param name="IL">The <see cref="T:Mono.Cecil.Cil.CilWorker" /> pointing to the target method body.</param>
    471. 

  471.     </member>
    472. 

  472.     <member name="T:LinFu.AOP.Cecil.GetInterceptionDisabled">
    473. 

  473.       <summary>
    474. 

  474.             Represents a class that emits the instructions that determine whether or not method interception is disabled.
    475. 

  475.             </summary>
    476. 

  476.     </member>
    477. 

  477.     <member name="M:LinFu.AOP.Cecil.GetInterceptionDisabled.#ctor(LinFu.AOP.Cecil.IMethodBodyRewriterParameters)">
    478. 

  478.       <summary>
    479. 

  479.             Initializes a new instance of the <see cref="T:LinFu.AOP.Cecil.GetInterceptionDisabled" /> class.
    480. 

  480.             </summary>
    481. 

  481.       <param name="parameters">The <see cref="T:LinFu.AOP.Cecil.IMethodBodyRewriterParameters" /> instance.</param>
    482. 

  482.     </member>
    483. 

  483.     <member name="M:LinFu.AOP.Cecil.GetInterceptionDisabled.#ctor(Mono.Cecil.MethodReference,Mono.Cecil.Cil.VariableDefinition)">
    484. 

  484.       <summary>
    485. 

  485.             Initializes a new instance of the <see cref="T:LinFu.AOP.Cecil.GetInterceptionDisabled" /> class.
    486. 

  486.             </summary>
    487. 

  487.       <param name="hostMethod">The target method.</param>
    488. 

  488.       <param name="interceptionDisabled">The local variable that determines whether or not method interception is disabled.</param>
    489. 

  489.     </member>
    490. 

  490.     <member name="M:LinFu.AOP.Cecil.GetInterceptionDisabled.Emit(Mono.Cecil.Cil.CilWorker)">
    491. 

  491.       <summary>
    492. 

  492.             Emits the instructions that determine whether or not method interception is disabled.
    493. 

  493.             </summary>
    494. 

  494.       <param name="IL">The <see cref="T:Mono.Cecil.Cil.CilWorker" /> instance responsible for adding or removing instructions to the method body.</param>
    495. 

  495.     </member>
    496. 

  496.     <member name="T:LinFu.AOP.Cecil.GetClassMethodReplacementProvider">
    497. 

  497.       <summary>
    498. 

  498.             Represents a class that emits the instructions that obtain a class-level <see cref="T:LinFu.AOP.Interfaces.IMethodReplacementProvider" /> instance.
    499. 

  499.             </summary>
    500. 

  500.     </member>
    501. 

  501.     <member name="M:LinFu.AOP.Cecil.GetClassMethodReplacementProvider.#ctor(LinFu.AOP.Cecil.IMethodBodyRewriterParameters,System.Func{Mono.Cecil.ModuleDefinition,Mono.Cecil.MethodReference})">
    502. 

  502.       <summary>
    503. 

  503.             Initializes a new instance of the <see cref="T:LinFu.AOP.Cecil.GetClassMethodReplacementProvider" /> class.
    504. 

  504.             </summary>
    505. 

  505.       <param name="parameters">The method body rewriter paramters that describe the </param>
    506. 

  506.       <param name="resolveGetProviderMethod">The functor that resolves the method that obtains the method replacement provider instance.</param>
    507. 

  507.     </member>
    508. 

  508.     <member name="M:LinFu.AOP.Cecil.GetClassMethodReplacementProvider.#ctor(Mono.Cecil.Cil.VariableDefinition,Mono.Cecil.Cil.VariableDefinition,System.Func{Mono.Cecil.ModuleDefinition,Mono.Cecil.MethodReference})">
    509. 

  509.       <summary>
    510. 

  510.             Initializes a new instance of the <see cref="T:LinFu.AOP.Cecil.GetClassMethodReplacementProvider" /> class.
    511. 

  511.             </summary>
    512. 

  512.       <param name="invocationInfo">The variable that contains the <see cref="T:LinFu.AOP.Interfaces.IInvocationInfo" /> instance.</param>
    513. 

  513.       <param name="classMethodReplacementProvider">The variable that contains the class method replacement provider instance.</param>
    514. 

  514.       <param name="resolveGetProviderMethod">The functor that resolves the method that obtains the method replacement provider instance.</param>
    515. 

  515.     </member>
    516. 

  516.     <member name="M:LinFu.AOP.Cecil.GetClassMethodReplacementProvider.Emit(Mono.Cecil.Cil.CilWorker)">
    517. 

  517.       <summary>
    518. 

  518.             Emits the instructions that obtain a class-level <see cref="T:LinFu.AOP.Interfaces.IMethodReplacementProvider" /> instance.
    519. 

  519.             </summary>
    520. 

  520.       <param name="IL">The <see cref="T:Mono.Cecil.Cil.CilWorker" /> instance that points to the instructions in the method body.</param>
    521. 

  521.     </member>
    522. 

  522.     <member name="T:LinFu.AOP.Cecil.Extensions.FieldInterceptionExtensions">
    523. 

  523.       <summary>
    524. 

  524.             Represents an extension class that adds field interception support to a given type.
    525. 

  525.             </summary>
    526. 

  526.     </member>
    527. 

  527.     <member name="M:LinFu.AOP.Cecil.Extensions.FieldInterceptionExtensions.InterceptAllFields(Mono.Cecil.IReflectionStructureVisitable)">
    528. 

  528.       <summary>
    529. 

  529.             Adds field interception support to the target type.
    530. 

  530.             </summary>
    531. 

  531.       <param name="targetType">The type that will be modified.</param>
    532. 

  532.     </member>
    533. 

  533.     <member name="M:LinFu.AOP.Cecil.Extensions.FieldInterceptionExtensions.InterceptAllInstanceFields(Mono.Cecil.IReflectionStructureVisitable)">
    534. 

  534.       <summary>
    535. 

  535.             Adds field interception support intercepting all instance fields on the target type.
    536. 

  536.             </summary>
    537. 

  537.       <param name="targetType">The type that will be modified.</param>
    538. 

  538.     </member>
    539. 

  539.     <member name="M:LinFu.AOP.Cecil.Extensions.FieldInterceptionExtensions.InterceptAllStaticFields(Mono.Cecil.IReflectionStructureVisitable)">
    540. 

  540.       <summary>
    541. 

  541.             Adds field interception support intercepting all static fields on the target type.
    542. 

  542.             </summary>
    543. 

  543.       <param name="targetType">The type that will be modified.</param>
    544. 

  544.     </member>
    545. 

  545.     <member name="M:LinFu.AOP.Cecil.Extensions.FieldInterceptionExtensions.InterceptAllFields(Mono.Cecil.IReflectionVisitable)">
    546. 

  546.       <summary>
    547. 

  547.             Adds field interception support to the target type.
    548. 

  548.             </summary>
    549. 

  549.       <param name="targetType">The type that will be modified.</param>
    550. 

  550.     </member>
    551. 

  551.     <member name="M:LinFu.AOP.Cecil.Extensions.FieldInterceptionExtensions.InterceptAllInstanceFields(Mono.Cecil.IReflectionVisitable)">
    552. 

  552.       <summary>
    553. 

  553.             Adds field interception support intercepting all instance fields on the target type.
    554. 

  554.             </summary>
    555. 

  555.       <param name="targetType">The type that will be modified.</param>
    556. 

  556.     </member>
    557. 

  557.     <member name="M:LinFu.AOP.Cecil.Extensions.FieldInterceptionExtensions.InterceptAllStaticFields(Mono.Cecil.IReflectionVisitable)">
    558. 

  558.       <summary>
    559. 

  559.             Adds field interception support intercepting all static fields on the target type.
    560. 

  560.             </summary>
    561. 

  561.       <param name="targetType">The type that will be modified.</param>
    562. 

  562.     </member>
    563. 

  563.     <member name="M:LinFu.AOP.Cecil.Extensions.FieldInterceptionExtensions.InterceptFields(Mono.Cecil.IReflectionVisitable,System.Func{Mono.Cecil.MethodReference,System.Boolean},System.Func{Mono.Cecil.FieldReference,System.Boolean})">
    564. 

  564.       <summary>
    565. 

  565.             Adds field interception support to the target type.
    566. 

  566.             </summary>
    567. 

  567.       <param name="targetType">The type that will be modified.</param>
    568. 

  568.       <param name="methodFilter">The filter that determines which methods on the target type will be modified to support field interception.</param>
    569. 

  569.       <param name="fieldFilter">The filter that determines which fields should be intercepted.</param>
    570. 

  570.     </member>
    571. 

  571.     <member name="M:LinFu.AOP.Cecil.Extensions.FieldInterceptionExtensions.InterceptFields(Mono.Cecil.IReflectionStructureVisitable,LinFu.AOP.Cecil.ITypeFilter,LinFu.AOP.Cecil.Interfaces.IFieldFilter)">
    572. 

  572.       <summary>
    573. 

  573.             Adds field interception support to the target type.
    574. 

  574.             </summary>
    575. 

  575.       <param name="targetType">The type that will be modified.</param>
    576. 

  576.       <param name="hostTypeFilter">The filter that determines the host types to be modified.</param>
    577. 

  577.       <param name="fieldFilter">The field filter that determines the fields that will be intercepted.</param>
    578. 

  578.     </member>
    579. 

  579.     <member name="M:LinFu.AOP.Cecil.Extensions.FieldInterceptionExtensions.InterceptFields(Mono.Cecil.IReflectionStructureVisitable,System.Func{Mono.Cecil.MethodReference,System.Boolean},System.Func{Mono.Cecil.FieldReference,System.Boolean})">
    580. 

  580.       <summary>
    581. 

  581.             Adds field interception support to the target type.
    582. 

  582.             </summary>
    583. 

  583.       <param name="targetType">The type that will be modified.</param>
    584. 

  584.       <param name="methodFilter">The filter that determines which methods on the target type will be modified to support field interception.</param>
    585. 

  585.       <param name="fieldFilter">The filter that determines which fields should be intercepted.</param>
    586. 

  586.     </member>
    587. 

  587.     <member name="T:LinFu.AOP.Cecil.Interfaces.IFieldFilter">
    588. 

  588.       <summary>
    589. 

  589.             Represents a type that determines whether or not a particular field get or set should be intercepted.
    590. 

  590.             </summary>
    591. 

  591.     </member>
    592. 

  592.     <member name="M:LinFu.AOP.Cecil.Interfaces.IFieldFilter.ShouldWeave(Mono.Cecil.MethodReference,Mono.Cecil.FieldReference)">
    593. 

  593.       <summary>
    594. 

  594.             Determines whether or not a particular field get or set should be intercepted.
    595. 

  595.             </summary>
    596. 

  596.       <param name="hostMethod">The host method.</param>
    597. 

  597.       <param name="targetField">The target field.</param>
    598. 

  598.       <returns>Returns <c>true</c> if the field should be intercepted; otherwise, it will return <c>false</c>.</returns>
    599. 

  599.     </member>
    600. 

  600.     <member name="T:LinFu.AOP.Cecil.FieldFilterAdapter">
    601. 

  601.       <summary>
    602. 

  602.             Represents an adapter class that maps a functor to an <see cref="T:LinFu.AOP.Cecil.Interfaces.IFieldFilter" /> instance.
    603. 

  603.             </summary>
    604. 

  604.     </member>
    605. 

  605.     <member name="M:LinFu.AOP.Cecil.FieldFilterAdapter.#ctor(System.Func{Mono.Cecil.FieldReference,System.Boolean})">
    606. 

  606.       <summary>
    607. 

  607.             Initializes a new instance of the <see cref="T:LinFu.AOP.Cecil.FieldFilterAdapter" /> class.
    608. 

  608.             </summary>
    609. 

  609.       <param name="filter">The field filter.</param>
    610. 

  610.     </member>
    611. 

  611.     <member name="M:LinFu.AOP.Cecil.FieldFilterAdapter.ShouldWeave(Mono.Cecil.MethodReference,Mono.Cecil.FieldReference)">
    612. 

  612.       <summary>
    613. 

  613.             Determines whether or not a particular field get or set should be intercepted.
    614. 

  614.             </summary>
    615. 

  615.       <param name="hostMethod">The host method.</param>
    616. 

  616.       <param name="targetField">The target field.</param>
    617. 

  617.       <returns>Returns <c>true</c> if the field should be intercepted; otherwise, it will return <c>false</c>.</returns>
    618. 

  618.     </member>
    619. 

  619.     <member name="T:LinFu.AOP.Cecil.IgnoredInstancesRegistry">
    620. 

  620.       <summary>
    621. 

  621.             Represents a class that keeps track of the internal object instances that should be ignored
    622. 

  622.             by the interception routines.
    623. 

  623.             </summary>
    624. 

  624.     </member>
    625. 

  625.     <member name="M:LinFu.AOP.Cecil.IgnoredInstancesRegistry.Contains(System.Object)">
    626. 

  626.       <summary>
    627. 

  627.             Determines whether or not the registry contains the given ignored object.
    628. 

  628.             </summary>
    629. 

  629.       <param name="target">The target object.</param>
    630. 

  630.       <returns>Returns <c>true</c> if the object should be ignored; otherwise, it will return <c>false</c>.</returns>
    631. 

  631.     </member>
    632. 

  632.     <member name="M:LinFu.AOP.Cecil.IgnoredInstancesRegistry.AddInstance(System.Object)">
    633. 

  633.       <summary>
    634. 

  634.             Adds an instance to the list of ignored instances.
    635. 

  635.             </summary>
    636. 

  636.       <param name="target">The target instance to be ignored by the interception routines.</param>
    637. 

  637.     </member>
    638. 

  638.     <member name="T:LinFu.AOP.Cecil.Interfaces.IMethodFilter">
    639. 

  639.       <summary>
    640. 

  640.             Represents a type that determines which host methods should be modified for method call interception.
    641. 

  641.             </summary>
    642. 

  642.     </member>
    643. 

  643.     <member name="M:LinFu.AOP.Cecil.Interfaces.IMethodFilter.ShouldWeave(Mono.Cecil.MethodReference)">
    644. 

  644.       <summary>
    645. 

  645.             Determines whether or not a particular method should be modified.
    646. 

  646.             </summary>
    647. 

  647.       <param name="targetMethod">The target method to be modified.</param>
    648. 

  648.       <returns>Returns <c>true</c> if the method should be modified; otherwise, it will return <c>false</c>.</returns>
    649. 

  649.     </member>
    650. 

  650.     <member name="T:LinFu.AOP.Cecil.Interfaces.IMethodCallFilter">
    651. 

  651.       <summary>
    652. 

  652.             Represents a type that determines the method calls that need to be intercepted.
    653. 

  653.             </summary>
    654. 

  654.     </member>
    655. 

  655.     <member name="M:LinFu.AOP.Cecil.Interfaces.IMethodCallFilter.ShouldWeave(Mono.Cecil.TypeReference,Mono.Cecil.MethodReference,Mono.Cecil.MethodReference)">
    656. 

  656.       <summary>
    657. 

  657.             Determines whether or not a particular method call should be intercepted.
    658. 

  658.             </summary>
    659. 

  659.       <param name="targetType">The host type that contains the method call.</param>
    660. 

  660.       <param name="hostMethod">The method that contains the current method call.</param>
    661. 

  661.       <param name="currentMethodCall">The method call to be intercepted.</param>
    662. 

  662.       <returns>Returns <c>true</c> if the method call should be intercepted; otherwise, it will return <c>false</c>.</returns>
    663. 

  663.     </member>
    664. 

  664.     <member name="T:LinFu.AOP.Cecil.IMethodBodyRewriterParameters">
    665. 

  665.       <summary>
    666. 

  666.             Represents the parameters used to add interception to a given method body.
    667. 

  667.             </summary>
    668. 

  668.     </member>
    669. 

  669.     <member name="P:LinFu.AOP.Cecil.IMethodBodyRewriterParameters.TargetMethod">
    670. 

  670.       <summary>
    671. 

  671.             Gets the value indicating the TargetMethod to be modified.
    672. 

  672.             </summary>
    673. 

  673.       <value>The method to be modified.</value>
    674. 

  674.     </member>
    675. 

  675.     <member name="P:LinFu.AOP.Cecil.IMethodBodyRewriterParameters.AroundInvokeProvider">
    676. 

  676.       <summary>
    677. 

  677.             Gets the value indicating the local variable used to store the <see cref="T:LinFu.AOP.Interfaces.IAroundInvokeProvider" /> instance.
    678. 

  678.             </summary>
    679. 

  679.       <value>The <see cref="T:LinFu.AOP.Interfaces.IAroundInvokeProvider" /> instance.</value>
    680. 

  680.     </member>
    681. 

  681.     <member name="P:LinFu.AOP.Cecil.IMethodBodyRewriterParameters.MethodReplacementProvider">
    682. 

  682.       <summary>
    683. 

  683.             Gets the value indicating the local variable used to store the <see cref="T:LinFu.AOP.Interfaces.IMethodReplacementProvider" /> instance.
    684. 

  684.             </summary>
    685. 

  685.       <value>The <see cref="T:LinFu.AOP.Interfaces.IMethodReplacementProvider" /> instance.</value>
    686. 

  686.     </member>
    687. 

  687.     <member name="P:LinFu.AOP.Cecil.IMethodBodyRewriterParameters.ClassMethodReplacementProvider">
    688. 

  688.       <summary>
    689. 

  689.             Gets the value indicating the class-level<see cref="T:LinFu.AOP.Interfaces.IMethodReplacementProvider" /> instance.
    690. 

  690.             </summary>
    691. 

  691.       <value>The class-level<see cref="T:LinFu.AOP.Interfaces.IMethodReplacementProvider" /> instance.</value>
    692. 

  692.     </member>
    693. 

  693.     <member name="P:LinFu.AOP.Cecil.IMethodBodyRewriterParameters.InterceptionDisabled">
    694. 

  694.       <summary>
    695. 

  695.             Gets the value indicating the local variable that will store the value that determines whether or not
    696. 

  696.             interception is disabled.
    697. 

  697.             </summary>
    698. 

  698.       <value>The value that determines whether or not interception is disabled.</value>
    699. 

  699.     </member>
    700. 

  700.     <member name="P:LinFu.AOP.Cecil.IMethodBodyRewriterParameters.InvocationInfo">
    701. 

  701.       <summary>
    702. 

  702.             Gets the value indicating the local variable that will store the <see cref="T:LinFu.AOP.Interfaces.IInvocationInfo" /> instance.
    703. 

  703.             </summary>
    704. 

  704.       <value>The local variable that will store the <see cref="T:LinFu.AOP.Interfaces.IInvocationInfo" /> instance.</value>
    705. 

  705.     </member>
    706. 

  706.     <member name="P:LinFu.AOP.Cecil.IMethodBodyRewriterParameters.ReturnValue">
    707. 

  707.       <summary>
    708. 

  708.             Gets the value indicating the local variable that will store the return value.
    709. 

  709.             </summary>
    710. 

  710.       <value>The value indicating the local variable that will store the return value.</value>
    711. 

  711.     </member>
    712. 

  712.     <member name="P:LinFu.AOP.Cecil.IMethodBodyRewriterParameters.RegistryType">
    713. 

  713.       <summary>
    714. 

  714.             Gets the value indicating the interception registry type that will be responsible for handling class-level interception events.
    715. 

  715.             </summary>
    716. 

  716.       <value>The interception registry type that will be responsible for handling class-level interception events.</value>
    717. 

  717.     </member>
    718. 

  718.     <member name="P:LinFu.AOP.Cecil.IMethodBodyRewriterParameters.GetMethodReplacementProviderMethod">
    719. 

  719.       <summary>
    720. 

  720.             Gets the value indicating the functor that resolves the GetMethodReplacementProvider method.
    721. 

  721.             </summary>
    722. 

  722.       <value>The functor that resolves the GetMethodReplacementProvider method.</value>
    723. 

  723.     </member>
    724. 

  724.     <member name="P:LinFu.AOP.Cecil.IMethodBodyRewriterParameters.OldInstructions">
    725. 

  725.       <summary>
    726. 

  726.             Gets the value indicating the list of old instructions in the current method body.
    727. 

  727.             </summary>
    728. 

  728.       <value>The value indicating the list of old instructions in the current method body.</value>
    729. 

  729.     </member>
    730. 

  730.     <member name="T:LinFu.AOP.Cecil.Interfaces.INewInstanceFilter">
    731. 

  731.       <summary>
    732. 

  732.             Represents a type that determines the constructor calls that will be intercepted by the postweaver.
    733. 

  733.             </summary>
    734. 

  734.     </member>
    735. 

  735.     <member name="M:LinFu.AOP.Cecil.Interfaces.INewInstanceFilter.ShouldWeave(Mono.Cecil.MethodReference,Mono.Cecil.TypeReference,Mono.Cecil.MethodReference)">
    736. 

  736.       <summary>
    737. 

  737.             Determines whether or not a particular constructor call should be intercepted by the postweaver.
    738. 

  738.             </summary>
    739. 

  739.       <param name="currentConstructor">The constructor used to instantiate the current instance.</param>
    740. 

  740.       <param name="concreteType">The concrete type that contains the new instance call.</param>
    741. 

  741.       <param name="hostMethod">The host method that contains the new operator call.</param>
    742. 

  742.       <returns>Returns <c>true</c> if the new operator call should be intercepted; otherwise, it should return <c>false</c>.</returns>
    743. 

  743.     </member>
    744. 

  744.     <member name="T:LinFu.AOP.Cecil.MethodCallFilterAdapter">
    745. 

  745.       <summary>
    746. 

  746.             Represents a type that converts functors into method call filter instances.
    747. 

  747.             </summary>
    748. 

  748.     </member>
    749. 

  749.     <member name="M:LinFu.AOP.Cecil.MethodCallFilterAdapter.#ctor(System.Func{Mono.Cecil.MethodReference,System.Boolean},System.Func{Mono.Cecil.MethodReference,System.Boolean})">
    750. 

  750.       <summary>
    751. 

  751.             Initializes a new instance of the <see cref="T:LinFu.AOP.Cecil.MethodCallFilterAdapter" /> class.
    752. 

  752.             </summary>
    753. 

  753.       <param name="hostMethodFilter">The method filter that will determine the host methods that will be modified for interception.</param>
    754. 

  754.       <param name="methodCallFilter">The method filter that will determine which method calls will be intercepted.</param>
    755. 

  755.     </member>
    756. 

  756.     <member name="M:LinFu.AOP.Cecil.MethodCallFilterAdapter.ShouldWeave(Mono.Cecil.TypeReference,Mono.Cecil.MethodReference,Mono.Cecil.MethodReference)">
    757. 

  757.       <summary>
    758. 

  758.             Determines whether or not a particular method call should be intercepted.
    759. 

  759.             </summary>
    760. 

  760.       <param name="targetType">The host type that contains the method call.</param>
    761. 

  761.       <param name="hostMethod">The method that contains the current method call.</param>
    762. 

  762.       <param name="currentMethodCall">The method call to be intercepted.</param>
    763. 

  763.       <returns>Returns <c>true</c> if the method call should be intercepted; otherwise, it will return <c>false</c>.</returns>
    764. 

  764.     </member>
    765. 

  765.     <member name="T:LinFu.AOP.Cecil.NewInstanceInterceptionAdapter">
    766. 

  766.       <summary>
    767. 

  767.             Represents an adapter class that maps <see cref="T:LinFu.AOP.Cecil.Interfaces.INewInstanceFilter" /> instances to 
    768. 

  768.             functors.
    769. 

  769.             </summary>
    770. 

  770.     </member>
    771. 

  771.     <member name="M:LinFu.AOP.Cecil.NewInstanceInterceptionAdapter.#ctor(System.Func{Mono.Cecil.MethodReference,Mono.Cecil.TypeReference,Mono.Cecil.MethodReference,System.Boolean})">
    772. 

  772.       <summary>
    773. 

  773.             Initializes a new instance of the <see cref="T:LinFu.AOP.Cecil.NewInstanceInterceptionAdapter" /> class.
    774. 

  774.             </summary>
    775. 

  775.       <param name="filter">The filter that determines which instances will be intercepted.</param>
    776. 

  776.     </member>
    777. 

  777.     <member name="M:LinFu.AOP.Cecil.NewInstanceInterceptionAdapter.ShouldWeave(Mono.Cecil.MethodReference,Mono.Cecil.TypeReference,Mono.Cecil.MethodReference)">
    778. 

  778.       <summary>
    779. 

  779.             Determines whether or not a particular constructor call should be intercepted by the postweaver.
    780. 

  780.             </summary>
    781. 

  781.       <param name="currentConstructor">The constructor used to instantiate the current instance.</param>
    782. 

  782.       <param name="concreteType">The concrete type that contains the new instance call.</param>
    783. 

  783.       <param name="hostMethod">The host method that contains the new operator call.</param>
    784. 

  784.       <returns>Returns <c>true</c> if the new operator call should be intercepted; otherwise, it should return <c>false</c>.</returns>
    785. 

  785.     </member>
    786. 

  786.     <member name="T:LinFu.AOP.Cecil.Interfaces.IWeaver`2">
    787. 

  787.       <summary>
    788. 

  788.             Represents a class that can weave (or modify) 
    789. 

  789.             a member embedded in an assembly.
    790. 

  790.             </summary>
    791. 

  791.       <typeparam name="T">The type of object to modify.</typeparam>
    792. 

  792.       <typeparam name="THost">The host that holds the item to be modified.</typeparam>
    793. 

  793.     </member>
    794. 

  794.     <member name="M:LinFu.AOP.Cecil.Interfaces.IWeaver`2.ShouldWeave(`0)">
    795. 

  795.       <summary>
    796. 

  796.             Determines whether or not the current item should be modified.
    797. 

  797.             </summary>
    798. 

  798.       <param name="item">The target item.</param>
    799. 

  799.       <returns>Returns <c>true</c> if the current item can be modified; otherwise, it should return <c>false.</c></returns>
    800. 

  800.     </member>
    801. 

  801.     <member name="M:LinFu.AOP.Cecil.Interfaces.IWeaver`2.Weave(`0)">
    802. 

  802.       <summary>
    803. 

  803.             Modifies the target <paramref name="item" />.
    804. 

  804.             </summary>
    805. 

  805.       <param name="item">The item to be modified.</param>
    806. 

  806.     </member>
    807. 

  807.     <member name="T:LinFu.AOP.Cecil.Interfaces.ITypeWeaver">
    808. 

  808.       <summary>
    809. 

  809.             Represents a type that can modify an existing <see cref="T:Mono.Cecil.TypeDefinition" />.
    810. 

  810.             </summary>
    811. 

  811.     </member>
    812. 

  812.     <member name="T:LinFu.AOP.Cecil.ImplementFieldInterceptionHostWeaver">
    813. 

  813.       <summary>
    814. 

  814.             Represents a type weaver that modifies types to implement the <s…
    815.