castle.dynamicproxy2 2.1.0.0 → 2.2.0.0

data/docs/ASL - Apache Software Foundation License.txt

@@ -0,0 +1,57 @@
+Apache License, Version 2.0
+
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+
+   1. You must give any other recipients of the Work or Derivative Works a copy of this License; and
+
+   2. You must cause any modified files to carry prominent notices stating that You changed the files; and
+
+   3. You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+
+   4. If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

data/docs/Committers.txt

@@ -0,0 +1,80 @@
+This file names who's behind the Castle Team. You can find more about us at http://www.castleproject.org/community/team.html
+
+Committers
+==========
+(ordered by the date when joined the project)
+
+- hammett/Hamilton Verissimo
+- Henry Concei��o
+- Kevin Williams
+- Craig Neuwirt
+- Gilles Bayon
+- Andrew Hallock
+- Jason Nelson
+- Dru Sellers
+- John Morales
+- CobraLord
+- Dan
+- Tatham Oddie
+- Fabio David Batista
+- Chad Humphries
+- Ayende Rahien
+- G. Richard Bellamy
+- Roelof Blom
+- Ahmed Ghandour 
+- Josh Robb
+- Ernst Naezer
+- Marc-Andre Cournoyer
+- Fabian Schmied
+- Dave Godfrey
+- Markus Zywitza
+- Lee Henson
+- Ken Egozi
+- Chris Ortman
+- Jonathon Rossi
+- Tuna Toks�z
+- Krzysztof Kozmic
+- Mauricio Scheffer
+- John Simons
+
+Managers 
+========
+
+  Patch Manager
+  -------------
+
+  - Josh Robb
+
+  Documentation Manager
+  ---------------------
+
+  - 
+
+
+PMC Members 
+===========
+(ordered by the date when joined the PMC)
+
+- hammett/Hamilton Verissimo (Chair)
+- Henry Concei��o
+- Kevin Williams
+- Craig Neuwirt
+- Gilles Bayon
+- Chad Humphries
+- Ayende Rahien
+- Fabio David Batista
+- Roelof Blom
+- Josh Robb
+- Jonathon Rossi
+
+Emeritus 
+========
+(no longer active committers)
+
+- Gilles Bayon
+- Dan
+- Andrew Hallock
+- John Morales
+- CobraLord
+- Tatham Oddie
+- Ahmed Ghandour 

data/docs/ReleaseNotes/Changes.txt

@@ -0,0 +1,234 @@
+2.2.0 (2010-01-11)
+==================
+- Fixed medium trust issue introduced in 2.2.0 Beta 1 where it would try to create a trace logger.
+- Some changes to the way explicit interface methods are implemented to support WPF databinding.
+
+2.2.0 Beta 1 (2009-12-04)
+=========================
+- Fixed DYNPROXY-ISSUE-120: Add logging to DynamicProxy.
+  Introduced basic logging for cache hit/miss, methods that cannot be intercepted, and overriding Equals/GetHashCode.
+- Applied patch from James Curran fixing DYNPROXY-ISSUE-124: "InterfaceProxyWithoutTargetGenerator ctor missing selector parameter".
+- Fixed DYNPROXY-ISSUE-105: Invocation types should be cached and shared among proxy implementations.
+- BREAKING CHANGE - implemented DYNPROXY-ISSUE-91: Allow CreateInterfaceProxyWithTargetInterface to be able to permanently change target.
+- Fixed DYNPROXY-ISSUE-122: "interceptor selector should not affect caching"
+- Fixed DYNPROXY-ISSUE-121: "proxy with target interface incorrectly forwards to mixins"
+- Added ability to change proxy target on mixin methods on interface proxy with target interface
+- Added generic overloads for CreateInterfaceProxyWithTargetInterface to make it consistent with other methods
+- BREAKING CHANGE - changed behavior of invocation.MethodInvocationTarget to be more consistent.
+- Fixed DYNPROXY-ISSUE-117: Fix BaseTypeForInterfaceProxy. Added checks for base type being null, not a class type, being sealed and not having
+  default accessible constructor.
+- Fixed DYNPROXY-ISSUE-112: Reimplement DefaultAttributeAssembler to make use of CustomAttributeData to avoid exceptions on unreplicable attributes.
+- Fixed DYNPROXY-ISSUE-118: Can't proxy remoting transparent interface proxies.
+- Fixed DYNPROXY-ISSUE-94: CreateProxyWithTarget fails if you use ProxyGenerationHook
+- Fixed DYNPROXY-ISSUE-89: Proxy generation fails when IProxyGenerationHook chooses not to proxy mixin method
+- Improved (a lot) range of supported scenarios, especially around generics.
+- Improved exception messages in exceptions thrown at users, with short explanation of what they may have done wrong and how to fix it. 
+- Fixed DYNPROXY-ISSUE-113: AbstractTypeEmitter can now be used to emit interfaces
+- Fixed DYNPROXY-ISSUE-108: Obtaining replicated custom attributes on proxy may fail when property setter throws exception on default value
+- Moved custom attribute replication from CustomAttributeUtil to new interface - IAttributeDisassembler
+- Exposed IAttributeDisassembler via ProxyGenerationOptions, so that users can plug their implementation for some convoluted scenarios. 
+- Fixed DYNPROXY-ISSUE-106: Proxying COM interfaces produces invalid proxies
+- Change in behavior - interfaces are now implemented explicitly (except for class proxy, when class implements the member virtually)
+- Fixed DYNPROXY-ISSUE-96: Implement order of precenence.
+- Interface proxy now can proxy explicit interface implementation
+- Fixed DYNPROXY-ISSUE-103: Proxy with interfaces having methods with identical signature is invalid
+- Fixed DYNPROXY-ISSUE-102: Intercept non-virtual interface implementation
+- Fixed DYNPROXY-ISSUE-100: Additional interfaces on proxy with target interface can cause stack overflow. Now a check is performed and if proxy
+  is the target of invocation, or the target is null an exception is thrown.
+- Changed behavior of interface proxies with target interface (all interface proxies actually, but the change in behavior is visible in proxies
+  with target interface). Now the target is being casted using 'as' operator to the target interface of invocation, so if the type of target object
+  implements additional interfaces invocation target will be set to the proxy target, and to null otherwise. This is consisted with how interface
+  proxies with target work.
+- Fixed bug reported by Jos� F. Romaniello - can not assign new target to interface proxy with target interface, in certain scenarios:
+  http://groups.google.com/group/castle-project-users/browse_thread/thread/2e507f47dbb831f1
+- Applied Krzysztof Kozmic's clean up patch with some minor changes
+  (http://groups.google.com/group/castle-project-devel/browse_thread/thread/853fa870326f7f71/9237bb890ca6dab7)
+  - Moved MethodInfos of AbstractInvocation methods to InvocationMethods class, where all the other methods are.
+  - Extracted MethodInfos obtained inline to their own classes in Castle.DynamicProxy.Tokens namespace. This should
+    improve performance a little bit.
+  - Removed two ctors from AbstractInvocation (that didn't have interfMethod parameter).
+  - Updated generated proxies to call other two Invocation ctors.
+  - Some tidying up in BaseProxyGenerator to remove duplication after updating calls to Invocation ctors.
+  - Removed collecting and generating tokenCaches for System.Object methods, since we never use these anyway.
+  - Removed redundant casts in code.
+  - Changed code using non-generic collections to use their generic conterparts.
+  - Some more minor tidying up.
+- Improved exception message when can not instantiate class proxy due to invalid arguments.
+- Reverted changes introduced in fix for DYNPROXY-ISSUE-97 for the constructor issue. It actually is an issue with params object[] which is confusing
+  and can lead to errors like the one reported, and the fix was inconsistent with the other overload that had arguments passed as explicit object[]
+  and could break the other overload in some scenarios.
+- Marked the overload of CreateClassProxy having params object[] as obsolete
+- Introduced another overload that takes constructor arguments as explicit array, and interceptors as params IInterceptor[] which is the pattern
+  for all other overloads anyway.
+- Fixed DYNPROXY-ISSUE-99: "Generated proxy class has no namespace", which due to a bug in WPF caused issues with databinding. Now proxies are in
+  namespace Castle.Proxies.
+- Fixed DYNPROXY-97: This issue are actually three separate bugs:
+  First relates to the improper handling of types with generic methods having parameters being an array of generic type of T
+  Second was related to improper handing of hierarchy of generic constraints, but it seems Fabian's fix to GenericUtil fixed that earlier.
+  Third issue was related to improper handing of certain kinds of constructor arguments passed to class proxy generator.
+- Fixed DYNPROXY-90: "DP2: Inherited interfaces w/ target does not to work"
+- Fixed DYNPROXY-88: "proxy generation fail when multiple interfaces have common base interface"
+  They both were actually special cases of one issue with invalid collection of interface members.
+- Fixed DYNPROXY-92: "Proxy fails when creating a Proxy for certain Generic signatures"
+  The problem was that GenericUtil.cs wrongfully copied generic arguments whose constraints referenced the proxied method without adjusting those
+  constraints.
+
+2.1.0 (2009-05-04)
+==================
+- Fixed DYNPROXY-87: "Mixin takes precedence over target object"
+  changed DP to throw exceptions when two mixins implement the same interface or a mixin implements the same interface as its target class/object
+
+- Applied Krzysztof Kozmic's patch improving the XML documentation of IInterceptorSelector
+  and IProxyGenerationHook.
+
+2.1.0 RC1 (2009-03-10)
+======================
+- Applied Krzysztof Kozmic's patch improving the XML documentation and parameter names of IProxyBuilder, DefaultProxyBuilder and ProxyGenerator.
+
+- Applied Krzysztof Kozmic's patch heavily improving the XML documentation of ProxyGenerator.
+
+- Fixed DYNPROXY-ISSUE-84: "UseSingleInterfaceProxy on ProxyGenerationOptions is never used and should be removed"
+
+- Fixed DYNPROXY-ISSUE-58/DYNPROXY-ISSUE-77: "Inherited interface seems not to work"
+  using Dimitri Goethals' test case and Ayende Rahien/Andrey Shchekin's patch.
+
+- Fixed DYNPROXY-ISSUE-52: "DynamicProxy 1.1.5 doesn't work on Medium Trust"
+  uses the assembly's fullname instead of calling GetName()
+
+- Fixed DYNPROXY-ISSUE-82: "Not allow generics & NoGeneric methods with same signature"
+  using Fabio Maulo's test case and Krzysztof Kozmic patch.
+
+- Applied Neil Bourgeois's patch fixing DYNPROXY-ISSUE-78
+  "Custom attributes of virtual properties absent on proxy"
+
+- Applied Craig Vermeer's patch fixing an issue with generating default constructors for DYNPROXY-ISSUE-81
+  "No Default Constructor in generated Class Proxy"
+
+- Added support for IInterceptorSelector (patch provided by Krzysztof Kozmic).
+- Removed ProxyGenerationOptions.UseSelector.
+
+- Added support for generic methods when specifying additional interfaces to CreateInterfaceProxyWithoutTarget (reported by Craig Neuwirth, cause
+  found by Krzysztof Kozmic)
+
+- Added support for provide additional interfaces for target interface proxies.
+
+- Added workarounds for dictionary deserialization scenarios (reported by Gr�gory C�let)
+
+- Fixed mixin-related bug with serialization (per Rogelio again)
+- Made interface proxies without target and with target interface support mixins
+
+- Fixed ProxyGenerationOptions equality issues with ordering and different instances of the same mixin types (thanks for finding
+  the bug, Rogelio)
+
+- Readded mixin support (via Rogelio J. Baucells)
+
+- ClassEmitter now supports emitting fields with specific attributes
+
+- Added a load API to ModuleScope
+- SaveAssembly now serializes the cache keys together with the generated types
+
+- Fixed test issue - PEVerify is now called with a quoted assembly path (to allow for spaces in the path)
+- Fixed test annoyance - PEVerify is now not called in a separate window
+- Changed PersistentProxyBuilder behavior - SaveAssembly is not called by the class generators any more, instead PersistentProxyBuilder.SaveAssemblies
+  must be used. This allows the proxy builder to save multiple proxies at the same time. Test cases have been adapted.
+
+- Fixed issues with CacheKey.Equals and ProxyGenerationOptions.Equals/GetHashCode
+- Added a way to set and retrieve the ModuleScope used by ProxyObjectReference for proxy deserialization; proxies can now be deserialized with
+  the same ModuleScope used by the application (DYNPROXY-71)
+
+- Made BasePEVerifyTestCase only check those assemblies that were actually generated in the test case, see DYNPROXY-68
+- Fixed bug with protected internal constructors, see DYNPROXY-66/DYNPROXY-67
+- Fixed test cases not using the ProxyGenerator supplied by BasePEVerifyTestCase, see DYNPROXY-69
+
+- Added StrongNameUtil, which provides methods for checking whether an assembly is signed/a type comes from a signed assembly
+- Added an additional constructor overload to ClassEmitter, allowing to force it to use an unsigned assembly
+
+- Fixed a bug in ModuleScope: SaveAssembly tried to delete from the current directory if a file with a matching name existed, not from the target
+  directory
+
+- Applied Pawel Pabich's suggestion fixing DYNPROXY-65 
+  "OpCodeUtil.GetUnderlyingTypeOfEnum doesn't handle unsigned integers"
+
+- Fixed bug in ArgumentReference occurring when emitting static methods
+
+- Removed ClsCompliant(false) from all the public types in DynamicProxy
+
+- Added constructors to ClassEmitter, removed "serializable" ctor parameter, it wasn't used
+
+- Fixed bug in ModuleScope, see DYNPROXY-64
+
+- Fixed bug in LoadArrayElementExpression, see DYNPROXY-57
+
+- Changed signing behavior for generated assembly, assembly is now only signed if all involved types (base type, interfaces) are also signed
+
+- Documented ModuleScope, added friendlier API for saving assemblies, added tests for ModuleScope, see DYNPROXY-55
+
+- Applied Adam Tybor's patch fixing DYNPROXY-63
+  "ProxyType not included in CacheKey"
+
+- Reimplemented serialization of ProxyGenerationOptions, see revision 3803, DYNPROXY-59
+
+- Added method signature filtering to MethodFinder (see MethodSignatureComparer) because there were
+  still cases triggering duplicate methods
+
+- Reimplemented serialization without default constructors, see revision 3725, DYNPROXY-53
+- Reimplemented serialization with delegates/events, see revision 3751, DYNPROXY-56
+
+- Renamed InterfaceProxyGeneratorWithoutTarget to InterfaceProxyWithoutTargetGenerator
+
+- Fixed DYNPROXY-62
+  "Some tests in MethodFinderTestCase failed because of culture specific exception messages"
+
+- Implemented cache for System.Type.GetMethods() in order to avoid triggering the duplicate methods bug
+
+- Applied Adam Tybor's patch fixing DYNPROXY-61 
+  "Need GetInterceptors from IProxyTargetAccessor back for NHibernate Trunk"
+
+- Disabled replication of internal constructors on class proxies.
+
+- Moved the UseSingleInterfaceProxy from Core.ComponentModel to ProxyGeneratorOptions. 
+
+- Applied Lee Henson's patch fixing generic parameter definitions
+
+- Applied Jacob Lewallen's patch that introduces ProxyInterfaceWithTargetInterface
+  Quoting
+
+  "I've introduced a new "mode" that is
+   ProxyInterfaceWithTargetInterface, that uses the given interface as
+   the target type, rather than the type of the target (it asserts the
+   target implements the interface) All other modes should remain the
+   same.
+
+  "In this scenario, the IInvocation will also implement
+   IChangeProxyTarget, which can then be used to change the proxy target
+   to another implementation of the target interface."
+
+- Added support for events
+
+- Fixed DYNPROXY-43
+  "DP2 : Missing ParameterInfo 'Name' for Proxied methods"
+
+- Fixed DYNPROXY-41
+  "Invalid state exception on DP2"
+
+- Fixed DYNPROXY-39
+  "Deadlock in DynamicProxy2"
+
+- Fixed DYNPROXY-28
+  "Virtual methods calls from constructors are not working"
+
+- Fixed DYNPROXY-27
+  "Support for non-parameterless constructors"
+
+- Fixed DYNPROXY-25
+  "Chars returns are not properly configured"
+
+- Fixed DYNPROXY-24
+  "DynamicProxy2: missing locks"
+
+- Fixed DYNPROXY-34
+  "Cant proxy generic interfaces"
+
+Alpha Version 1.0.0.0
+=====================
+- First release

data/lib/{net-3.5 → net-20}/Castle.DynamicProxy2.xml

@@ -4,42 +4,42 @@
         <name>Castle.DynamicProxy2</name>
     </assembly>
     <members>
-        <member name="T:Castle.DynamicProxy.Generators.Emitters.SimpleAST.IndirectReference">
+        <member name="M:Castle.DynamicProxy.Contributors.MembersCollector.IsAccessible(System.Reflection.MethodBase)">
             <summary>
-            Wraps a reference that is passed 
-            ByRef and provides indirect load/store support.
+            Checks if the method is public or protected.
             </summary>
+            <param name="method"></param>
+            <returns></returns>
         </member>
-        <member name="T:Castle.DynamicProxy.Generators.Emitters.SimpleAST.NewArrayExpression">
+        <member name="M:Castle.DynamicProxy.Contributors.MembersCollector.AcceptMethod(System.Reflection.MethodInfo,System.Boolean,Castle.DynamicProxy.IProxyGenerationHook)">
             <summary>
-            Summary description for NewArrayExpression.
+            Performs some basic screening and invokes the <see cref="T:Castle.DynamicProxy.IProxyGenerationHook"/>
+            to select methods.
             </summary>
+            <param name="method"></param>
+            <param name="onlyVirtuals"></param>
+            <param name="hook"></param>
+            <returns></returns>
         </member>
-        <member name="T:Castle.DynamicProxy.Generators.Emitters.SimpleAST.ReferencesToObjectArrayExpression">
+        <member name="T:Castle.DynamicProxy.Contributors.ITypeContributor">
             <summary>
-            
+            Interface describing elements composing generated type
             </summary>
         </member>
-        <member name="M:Castle.DynamicProxy.Generators.Emitters.CustomAttributeUtil.InitializeConstructorArgs(System.Type,System.Attribute,System.Object[],System.Reflection.ParameterInfo[])">
+        <member name="T:Castle.DynamicProxy.Generators.Emitters.SimpleAST.IndirectReference">
             <summary>
-            Here we try to match a constructor argument to its value.
-            Since we can't get the values from the assembly, we use some heuristics to get it.
-            a/ we first try to match all the properties on the attributes by name (case insensitive) to the argument
-            b/ if we fail we try to match them by property type, with some smarts about convertions (i,e: can use Guid for string).
+            Wraps a reference that is passed 
+            ByRef and provides indirect load/store support.
             </summary>
         </member>
-        <member name="M:Castle.DynamicProxy.Generators.Emitters.CustomAttributeUtil.ReplaceIfBetterMatch(System.Reflection.ParameterInfo,System.Reflection.PropertyInfo,System.Reflection.PropertyInfo)">
+        <member name="T:Castle.DynamicProxy.Generators.Emitters.SimpleAST.NewArrayExpression">
             <summary>
-            We have the following rules here.
-            Try to find a matching type, failing that, if the parameter is string, get the first property (under the assumption that
-            we can convert it.
+            Summary description for NewArrayExpression.
             </summary>
         </member>
-        <member name="M:Castle.DynamicProxy.Generators.Emitters.CustomAttributeUtil.ConvertValue(System.Object,System.Type)">
+        <member name="T:Castle.DynamicProxy.Generators.Emitters.SimpleAST.ReferencesToObjectArrayExpression">
             <summary>
-            Attributes can only accept simple types, so we return null for null,
-            if the value is passed as string we call to string (should help with converting), 
-            otherwise, we use the value as is (enums, integer, etc).
+            
             </summary>
         </member>
         <member name="T:Castle.DynamicProxy.Generators.Emitters.LdcOpCodesDictionary">
@@ -103,161 +103,138 @@
             for the type of primitive value to be stored indirectly.
             </summary>
         </member>
-        <member name="T:Castle.DynamicProxy.Generators.BaseProxyGenerator">
-            <summary>
-            Base class that exposes the common functionalities
-            to proxy generation.
-            </summary>
-            <remarks>
-            TODO: 
-            - Add tests and fixes for 'leaking this' problem
-            </remarks>
-        </member>
-        <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.GetProxyTargetReference">
+        <member name="M:Castle.DynamicProxy.Generators.Emitters.TypeUtil.GetAllInterfaces(System.Type[])">
             <summary>
-            Used by dinamically implement <see cref="T:Castle.Core.Interceptor.IProxyTargetAccessor"/>
+            Returns list of all unique interfaces implemented given types, including their base interfaces.
             </summary>
+            <param name="types"></param>
             <returns></returns>
         </member>
-        <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.GenerateParameterlessConstructor(Castle.DynamicProxy.Generators.Emitters.ClassEmitter,System.Type,Castle.DynamicProxy.Generators.Emitters.SimpleAST.FieldReference)">
+        <member name="M:Castle.DynamicProxy.Generators.AttributeDisassembler.HandleError(System.Type,System.Exception)">
             <summary>
-            Generates a parameters constructor that initializes the proxy
-            state with <see cref="T:Castle.Core.Interceptor.StandardInterceptor"/> just to make it non-null.
-            <para>
-            This constructor is important to allow proxies to be XML serializable
-            </para>
-            </summary>
-        </member>
-        <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.BuildInvocationNestedType(Castle.DynamicProxy.Generators.Emitters.ClassEmitter,System.Type,System.Type,System.Reflection.MethodInfo,System.Reflection.MethodInfo,Castle.DynamicProxy.Generators.ConstructorVersion)">
-            <summary>
-            If callbackMethod is null the InvokeOnTarget implementation 
-            is just the code to throw an exception
+            Handles error during disassembly process
             </summary>
-            <param name="emitter"></param>
-            <param name="targetType"></param>
-            <param name="targetForInvocation"></param>
-            <param name="methodInfo"></param>
-            <param name="callbackMethod"></param>
-            <param name="version"></param>
-            <returns></returns>
+            <param name="attributeType">Type of the attribute being disassembled</param>
+            <param name="exception">Exception thrown during the process</param>
+            <returns>usually null, or (re)throws the exception</returns>
         </member>
-        <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.BuildInvocationNestedType(Castle.DynamicProxy.Generators.Emitters.ClassEmitter,System.Type,System.Type,System.Reflection.MethodInfo,System.Reflection.MethodInfo,Castle.DynamicProxy.Generators.ConstructorVersion,System.Boolean)">
+        <member name="M:Castle.DynamicProxy.Generators.AttributeDisassembler.InitializeConstructorArgs(System.Type,System.Attribute,System.Object[],System.Reflection.ParameterInfo[])">
             <summary>
-            If callbackMethod is null the InvokeOnTarget implementation
-            is just the code to throw an exception
+            Here we try to match a constructor argument to its value.
+            Since we can't get the values from the assembly, we use some heuristics to get it.
+            a/ we first try to match all the properties on the attributes by name (case insensitive) to the argument
+            b/ if we fail we try to match them by property type, with some smarts about convertions (i,e: can use Guid for string).
             </summary>
-            <param name="emitter"></param>
-            <param name="targetType"></param>
-            <param name="targetForInvocation"></param>
-            <param name="methodInfo"></param>
-            <param name="callbackMethod"></param>
-            <param name="version"></param>
-            <param name="allowChangeTarget">If true the invocation will implement the IChangeProxyTarget interface</param>
-            <returns></returns>
         </member>
-        <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.CreateIInvocationConstructor(System.Type,Castle.DynamicProxy.Generators.Emitters.NestedClassEmitter,Castle.DynamicProxy.Generators.Emitters.SimpleAST.FieldReference,Castle.DynamicProxy.Generators.ConstructorVersion)">
+        <member name="M:Castle.DynamicProxy.Generators.AttributeDisassembler.ReplaceIfBetterMatch(System.Reflection.ParameterInfo,System.Reflection.PropertyInfo,System.Reflection.PropertyInfo)">
             <summary>
-            Generates the constructor for the nested class that extends
-            <see cref="T:Castle.DynamicProxy.AbstractInvocation"/>
+            We have the following rules here.
+            Try to find a matching type, failing that, if the parameter is string, get the first property (under the assumption that
+            we can convert it.
             </summary>
-            <param name="targetFieldType"></param>
-            <param name="nested"></param>
-            <param name="targetField"></param>
-            <param name="version"></param>
         </member>
-        <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.CreateInitializeCacheMethodBody(System.Type,System.Reflection.MethodInfo[],Castle.DynamicProxy.Generators.Emitters.ClassEmitter,Castle.DynamicProxy.Generators.Emitters.ConstructorEmitter)">
+        <member name="M:Castle.DynamicProxy.Generators.AttributeDisassembler.ConvertValue(System.Object,System.Type)">
             <summary>
-            Improvement: this cache should be static. We should generate a
-            type constructor instead
+            Attributes can only accept simple types, so we return null for null,
+            if the value is passed as string we call to string (should help with converting), 
+            otherwise, we use the value as is (enums, integer, etc).
             </summary>
         </member>
-        <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.AcceptMethod(System.Reflection.MethodInfo,System.Boolean)">
+        <member name="T:Castle.DynamicProxy.Generators.BaseProxyGenerator">
             <summary>
-            Performs some basic screening and invokes the <see cref="T:Castle.DynamicProxy.IProxyGenerationHook"/>
-            to select methods.
+            Base class that exposes the common functionalities
+            to proxy generation.
             </summary>
-            <param name="method"></param>
-            <param name="onlyVirtuals"></param>
-            <returns></returns>
         </member>
-        <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.IsAccessible(System.Reflection.MethodInfo)">
+        <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.GenerateParameterlessConstructor(Castle.DynamicProxy.Generators.Emitters.ClassEmitter,System.Type,Castle.DynamicProxy.Generators.Emitters.SimpleAST.FieldReference)">
             <summary>
-            Checks if the method is public or protected.
+            Generates a parameters constructor that initializes the proxy
+            state with <see cref="T:Castle.Core.Interceptor.StandardInterceptor"/> just to make it non-null.
+            <para>
+            This constructor is important to allow proxies to be XML serializable
+            </para>
             </summary>
-            <param name="method"></param>
-            <returns></returns>
         </member>
-        <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.ShouldSkipAttributeReplication(System.Attribute)">
+        <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.AddMappingNoCheck(System.Type,Castle.DynamicProxy.Contributors.ITypeContributor,System.Collections.Generic.IDictionary{System.Type,Castle.DynamicProxy.Contributors.ITypeContributor})">
             <summary>
-            Attributes should be replicated if they are non-inheritable,
-            but there are some special cases where the attributes means
-            something to the CLR, where they should be skipped.
+            It is safe to add mapping (no mapping for the interface exists)
             </summary>
+            <param name="implementer"></param>
+            <param name="interface"></param>
+            <param name="mapping"></param>
         </member>
-        <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.ShouldCreateNewSlot(System.Reflection.MethodInfo)">
+        <member name="M:Castle.DynamicProxy.Generators.CacheKey.#ctor(System.Reflection.MemberInfo,System.Type,System.Type[],Castle.DynamicProxy.ProxyGenerationOptions)">
             <summary>
-            Checks if the method has the same signature as a method that was marked as
-            one that should generate a new vtable slot.
+            Initializes a new instance of the <see cref="T:Castle.DynamicProxy.Generators.CacheKey"/> class.
             </summary>
+            <param name="target">Target element. This is either target type or target method for invocation types.</param>
+            <param name="type">The type of the proxy. This is base type for invocation types.</param>
+            <param name="interfaces">The interfaces.</param>
+            <param name="options">The options.</param>
         </member>
         <member name="M:Castle.DynamicProxy.Generators.CacheKey.#ctor(System.Type,System.Type[],Castle.DynamicProxy.ProxyGenerationOptions)">
             <summary>
             Initializes a new instance of the <see cref="T:Castle.DynamicProxy.Generators.CacheKey"/> class.
             </summary>
-            <param name="targetType">Type of the target.</param>
+            <param name="target">Type of the target.</param>
             <param name="interfaces">The interfaces.</param>
             <param name="options">The options.</param>
         </member>
-        <member name="T:Castle.DynamicProxy.Generators.ClassProxyGenerator">
+        <member name="M:Castle.DynamicProxy.Generators.InvocationTypeGenerator.GetCtorArgumentsAndBaseCtorToCall(System.Type,Castle.DynamicProxy.ProxyGenerationOptions,System.Reflection.ConstructorInfo@)">
             <summary>
-            
+            Generates the constructor for the class that extends
+            <see cref="T:Castle.DynamicProxy.AbstractInvocation"/>
             </summary>
+            <param name="targetFieldType"></param>
+            <param name="proxyGenerationOptions"></param>
+            <param name="baseConstructor"></param>
         </member>
-        <member name="M:Castle.DynamicProxy.Generators.EventToGenerate.#ctor(Castle.DynamicProxy.Generators.Emitters.EventEmitter,System.Reflection.MethodInfo,System.Reflection.MethodInfo,System.Reflection.EventAttributes)">
+        <member name="T:Castle.DynamicProxy.Generators.ClassProxyGenerator">
             <summary>
-            Initializes a new instance of the <see cref="T:Castle.DynamicProxy.Generators.EventToGenerate"/> class.
+            
             </summary>
-            <param name="emitter">The emitter.</param>
-            <param name="addMethod">The add method.</param>
-            <param name="removeMethod">The remove method.</param>
-            <param name="attributes">The attributes.</param>
         </member>
-        <member name="T:Castle.DynamicProxy.Generators.InterfaceProxyWithTargetGenerator">
+        <member name="T:Castle.DynamicProxy.Generators.INamingScope">
             <summary>
-            
+            Represents the scope of uniquenes of names for types and their members
             </summary>
         </member>
-        <member name="M:Castle.DynamicProxy.Generators.InterfaceProxyWithTargetGenerator.FindMethodOnTargetType(System.Reflection.MethodInfo,System.Type,System.Boolean)">
+        <member name="M:Castle.DynamicProxy.Generators.INamingScope.GetUniqueName(System.String)">
             <summary>
-            Finds the type of the method on target.
+            Gets a unique name based on <paramref name="suggestedName"/>
             </summary>
-            <param name="methodOnInterface">The method on interface.</param>
-            <param name="proxyTargetType">Type of the proxy target.</param>
-            /// <param name="checkMixins">if set to <c>true</c> will check implementation on mixins.</param>
-            <returns></returns>
+            <param name="suggestedName">Name suggested by the caller</param>
+            <returns>Unique name based on <paramref name="suggestedName"/>.</returns>
+            <remarks>
+            Implementers should provide name as closely resembling <paramref name="suggestedName"/> as possible.
+            Generally if no collision occurs it is suggested to return suggested name, otherwise append sequential suffix.
+            Implementers must return deterministic names, that is when <see cref="M:Castle.DynamicProxy.Generators.INamingScope.GetUniqueName(System.String)"/> is called twice 
+            with the same suggested name, the same returned name should be provided each time. Non-deterministic return
+            values, like appending random suffices will break serialization of proxies.
+            </remarks>
         </member>
-        <member name="M:Castle.DynamicProxy.Generators.InterfaceProxyWithTargetGenerator.IsTypeEquivalent(System.Type,System.Type)">
+        <member name="M:Castle.DynamicProxy.Generators.INamingScope.SafeSubScope">
             <summary>
-            Checks whether the given types are the same. This is 
-            more complicated than it looks.
+            Returns new, disposable naming scope. It is responsibilty of the caller to make sure that no naming collision
+            with enclosing scope, or other subscopes is possible.
             </summary>
-            <param name="sourceType"></param>
-            <param name="targetType"></param>
-            <returns></returns>
+            <returns>New naming scope.</returns>
         </member>
-        <member name="M:Castle.DynamicProxy.Generators.InterfaceProxyWithTargetGenerator.IsMethodEquivalent(System.Reflection.MethodInfo,System.Reflection.MethodInfo)">
+        <member name="T:Castle.DynamicProxy.Generators.InterfaceProxyWithTargetGenerator">
             <summary>
-            Checks whether the given methods are the same.
+            
             </summary>
-            <param name="methodInfo"></param>
-            <param name="methodOnInterface"></param>
-            <returns>True if the methods are the same.</returns>
         </member>
-        <member name="T:Castle.DynamicProxy.Generators.InterfaceGeneratorType">
+        <member name="M:Castle.DynamicProxy.Generators.MetaEvent.#ctor(System.String,System.Type,System.Type,Castle.DynamicProxy.Generators.MetaMethod,Castle.DynamicProxy.Generators.MetaMethod,System.Reflection.EventAttributes)">
             <summary>
-            This is used by the ProxyObjectReference class durin de-serialiation, to know
-            which generator it should use
+            Initializes a new instance of the <see cref="T:Castle.DynamicProxy.Generators.MetaEvent"/> class.
             </summary>
+            <param name="name">The name.</param>
+            <param name="declaringType">Type declaring the original event being overriten, or null.</param>
+            <param name="eventDelegateType"></param>
+            <param name="adder">The add method.</param>
+            <param name="remover">The remove method.</param>
+            <param name="attributes">The attributes.</param>
         </member>
         <member name="T:Castle.DynamicProxy.Generators.MethodFinder">
             <summary>
@@ -292,6 +269,41 @@
             might use more than one scope at the same time), <see cref="T:Castle.DynamicProxy.Serialization.ProxyObjectReference"/> uses a dedicated scope instance for deserializing proxy
             types. This instance can be reset and set to a specific value via <see cref="M:Castle.DynamicProxy.Serialization.ProxyObjectReference.ResetScope"/> and <see cref="M:Castle.DynamicProxy.Serialization.ProxyObjectReference.SetScope(Castle.DynamicProxy.ModuleScope)"/>.</value>
         </member>
+        <member name="T:Castle.DynamicProxy.Tokens.InvocationMethods">
+            <summary>
+            Holds <see cref="T:System.Reflection.MethodInfo"/> objects representing methods of <see cref="T:Castle.DynamicProxy.AbstractInvocation"/> class.
+            </summary>
+        </member>
+        <member name="T:Castle.DynamicProxy.Tokens.SerializationInfoMethods">
+            <summary>
+            Holds <see cref="T:System.Reflection.MethodInfo"/> objects representing methods of <see cref="T:System.Runtime.Serialization.SerializationInfo"/> class.
+            </summary>
+        </member>
+        <member name="F:Castle.DynamicProxy.Tokens.SerializationInfoMethods.AddValue_Bool">
+            <summary>
+            <see cref="M:System.Runtime.Serialization.SerializationInfo.AddValue(System.String,System.Boolean)"/>
+            </summary>
+        </member>
+        <member name="F:Castle.DynamicProxy.Tokens.SerializationInfoMethods.AddValue_Int32">
+            <summary>
+            <see cref="M:System.Runtime.Serialization.SerializationInfo.AddValue(System.String,System.Int32)"/>
+            </summary>
+        </member>
+        <member name="F:Castle.DynamicProxy.Tokens.SerializationInfoMethods.AddValue_Object">
+            <summary>
+            <see cref="M:System.Runtime.Serialization.SerializationInfo.AddValue(System.String,System.Object)"/>
+            </summary>
+        </member>
+        <member name="F:Castle.DynamicProxy.Tokens.SerializationInfoMethods.GetValue">
+            <summary>
+            <see cref="M:System.Runtime.Serialization.SerializationInfo.GetValue(System.String,System.Type)"/>
+            </summary>
+        </member>
+        <member name="F:Castle.DynamicProxy.Tokens.SerializationInfoMethods.SetType">
+            <summary>
+            <see cref="M:System.Runtime.Serialization.SerializationInfo.SetType(System.Type)"/>
+            </summary>
+        </member>
         <member name="T:Castle.DynamicProxy.IProxyGenerationHook">
             <summary>
             Used during the target type inspection process. Implementors have a chance to customize the
@@ -323,6 +335,24 @@
             Invoked by the generation process to notify that the whole process has completed.
             </summary>
         </member>
+        <member name="M:Castle.DynamicProxy.AttributeUtil.AddDisassembler``1(Castle.DynamicProxy.IAttributeDisassembler)">
+            <summary>
+            Registers custom disassembler to handle disassembly of specified type of attributes.
+            </summary>
+            <typeparam name="TAttribute">Type of attributes to handle</typeparam>
+            <param name="disassembler">Disassembler converting existing instances of Attributes to CustomAttributeBuilders</param>
+            <remarks>
+            When disassembling an attribute Dynamic Proxy will first check if an custom disassembler has been registered to handle attributes of that type, 
+            and if none is found, it'll use the <see cref="P:Castle.DynamicProxy.AttributeUtil.FallbackDisassembler"/>.
+            </remarks>
+        </member>
+        <member name="M:Castle.DynamicProxy.AttributeUtil.ShouldSkipAttributeReplication(System.Type)">
+            <summary>
+            Attributes should be replicated if they are non-inheritable,
+            but there are some special cases where the attributes means
+            something to the CLR, where they should be skipped.
+            </summary>
+        </member>
         <member name="T:Castle.DynamicProxy.CacheMappingsAttribute">
             <summary>
             Applied to the assemblies saved by <see cref="T:Castle.DynamicProxy.ModuleScope"/> in order to persist the cache data included in the persisted assembly.
@@ -369,6 +399,24 @@
             pointing to Castle Dynamic Proxy assembly, in assembly containing that type, if this is appropriate.</exception>
             <seealso cref="T:Castle.DynamicProxy.Generators.ClassProxyGenerator"/>
         </member>
+        <member name="M:Castle.DynamicProxy.IProxyBuilder.CreateClassProxyType(System.Type,System.Type[],Castle.DynamicProxy.ProxyGenerationOptions)">
+            <summary>
+            Creates a proxy type for given <paramref name="classToProxy"/>, implementing <paramref name="additionalInterfacesToProxy"/>, using <paramref name="options"/> provided.
+            </summary>
+            <param name="classToProxy">The class type to proxy.</param>
+            <param name="additionalInterfacesToProxy">Additional interface types to proxy.</param>
+            <param name="options">The proxy generation options.</param>
+            <returns>The generated proxy type.</returns>
+            <remarks>
+            Implementers should return a proxy type for the specified class and interfaces.
+            Additional interfaces should be only 'mark' interfaces, that is, they should work like interface proxy without target. (See <see cref="M:Castle.DynamicProxy.IProxyBuilder.CreateInterfaceProxyTypeWithoutTarget(System.Type,System.Type[],Castle.DynamicProxy.ProxyGenerationOptions)"/> method.)
+            </remarks>
+            <exception cref="T:Castle.DynamicProxy.Generators.GeneratorException">Thrown when <paramref name="classToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is a generic type definition.</exception>
+            <exception cref="T:Castle.DynamicProxy.Generators.GeneratorException">Thrown when <paramref name="classToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is not public.
+            Note that to avoid this exception, you can mark offending type internal, and define <see cref="T:System.Runtime.CompilerServices.InternalsVisibleToAttribute"/> 
+            pointing to Castle Dynamic Proxy assembly, in assembly containing that type, if this is appropriate.</exception>
+            <seealso cref="T:Castle.DynamicProxy.Generators.ClassProxyGenerator"/>
+        </member>
         <member name="M:Castle.DynamicProxy.IProxyBuilder.CreateInterfaceProxyTypeWithTarget(System.Type,System.Type[],System.Type,Castle.DynamicProxy.ProxyGenerationOptions)">
             <summary>
             Creates a proxy type that proxies calls to <paramref name="interfaceToProxy"/> members on <paramref name="targetType"/>, implementing <paramref name="additionalInterfacesToProxy"/>, using <paramref name="options"/> provided.
@@ -424,6 +472,11 @@
             pointing to Castle Dynamic Proxy assembly, in assembly containing that type, if this is appropriate.</exception>
             <seealso cref="T:Castle.DynamicProxy.Generators.InterfaceProxyWithTargetInterfaceGenerator"/>
         </member>
+        <member name="P:Castle.DynamicProxy.IProxyBuilder.Logger">
+            <summary>
+            Gets or sets the <see cref="T:Castle.Core.Logging.ILogger"/> that this <see cref="T:Castle.DynamicProxy.ProxyGenerator"/> logs to.
+            </summary>
+        </member>
         <member name="P:Castle.DynamicProxy.IProxyBuilder.ModuleScope">
             <summary>
             Gets the <see cref="P:Castle.DynamicProxy.IProxyBuilder.ModuleScope"/> associated with this builder.
@@ -441,33 +494,6 @@
             </summary>
             <param name="scope">The module scope for generated proxy types.</param>
         </member>
-        <member name="T:Castle.DynamicProxy.IInterceptorSelector">
-            <summary>
-            Provides an extension point that allows proxies to choose specific interceptors on
-            a per method basis.
-            </summary>
-        </member>
-        <member name="M:Castle.DynamicProxy.IInterceptorSelector.SelectInterceptors(System.Type,System.Reflection.MethodInfo,Castle.Core.Interceptor.IInterceptor[])">
-            <summary>
-            Selects the interceptors that should intercept calls to the given <paramref name="method"/>.
-            </summary>
-            <param name="type">The type declaring the method to intercept.</param>
-            <param name="method">The method that will be intercepted.</param>
-            <param name="interceptors">All interceptors registered with the proxy.</param>
-            <returns>An array of interceptors to invoke upon calling the <paramref name="method"/>.</returns>
-            <remarks>
-            This method is called only once per proxy instance, upon the first call to the
-            <paramref name="method"/>. Either an empty array or null are valid return values to indicate
-            that no interceptor should intercept calls to the method. Although it is not advised, it is
-            legal to return other <see cref="T:Castle.Core.Interceptor.IInterceptor"/> implementations than these provided in
-            <paramref name="interceptors"/>. A better way to do this, is by passing all the required
-            interceptors to the appropriate method of <see cref="T:Castle.DynamicProxy.ProxyGenerator"/>. You can use this
-            method to influence the order in which interceptors will be called, by reordering the array.
-            Returning an array containing null references (Nothing in Visual Basic) is not legal,
-            and will result in a runtime exception.
-            </remarks>
-            <seealso cref="T:Castle.DynamicProxy.ProxyGenerationOptions"/>
-        </member>
         <member name="M:Castle.DynamicProxy.InternalsHelper.IsInternalToDynamicProxy(System.Reflection.Assembly)">
             <summary>
             Determines whether this assembly has internals visible to dynamic proxy.
@@ -532,6 +558,18 @@
             <param name="weakAssemblyName">The simple name of the weak-named assembly generated by this <see cref="T:Castle.DynamicProxy.ModuleScope"/>.</param>
             <param name="weakModulePath">The path and file name of the manifest module of the weak-named assembly generated by this <see cref="T:Castle.DynamicProxy.ModuleScope"/>.</param>
         </member>
+        <member name="M:Castle.DynamicProxy.ModuleScope.#ctor(System.Boolean,Castle.DynamicProxy.Generators.INamingScope,System.String,System.String,System.String,System.String)">
+            <summary>
+            Initializes a new instance of the <see cref="T:Castle.DynamicProxy.ModuleScope"/> class, allowing to specify whether the assemblies generated by this instance
+            should be saved and what simple names are to be assigned to them.
+            </summary>
+            <param name="savePhysicalAssembly">If set to <c>true</c> saves the generated module.</param>
+            <param name="namingScope">Naming scope used to provide unique names to generated types and their members (usually via sub-scopes).</param>
+            <param name="strongAssemblyName">The simple name of the strong-named assembly generated by this <see cref="T:Castle.DynamicProxy.ModuleScope"/>.</param>
+            <param name="strongModulePath">The path and file name of the manifest module of the strong-named assembly generated by this <see cref="T:Castle.DynamicProxy.ModuleScope"/>.</param>
+            <param name="weakAssemblyName">The simple name of the weak-named assembly generated by this <see cref="T:Castle.DynamicProxy.ModuleScope"/>.</param>
+            <param name="weakModulePath">The path and file name of the manifest module of the weak-named assembly generated by this <see cref="T:Castle.DynamicProxy.ModuleScope"/>.</param>
+        </member>
         <member name="M:Castle.DynamicProxy.ModuleScope.GetFromCache(Castle.DynamicProxy.Generators.CacheKey)">
             <summary>
             Returns a type from this scope's type cache, or null if the key cannot be found.
@@ -619,7 +657,7 @@
             to avoid the performance hit associated with proxy generation.
             </remarks>
         </member>
-        <member name="P:Castle.DynamicProxy.ModuleScope.RWLock">
+        <member name="P:Castle.DynamicProxy.ModuleScope.Lock">
             <summary>
             Users of this <see cref="T:Castle.DynamicProxy.ModuleScope"/> should use this lock when accessing the cache.
             </summary>
@@ -726,11 +764,13 @@
             <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
             <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
             <remarks>
+            This method generates new proxy type for each type of <paramref name="target"/>, which affects performance. If you don't want to proxy types differently depending on the type of the target
+            use <see cref="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTargetInterface``1(``0,Castle.Core.Interceptor.IInterceptor[])"/> method.
             This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
             As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
             </remarks>
         </member>
-        <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTarget``1(System.Object,Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])">
+        <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTarget``1(``0,Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])">
             <summary>
             Creates proxy object intercepting calls to members of interface <typeparamref name="TInterface"/> on <paramref name="target"/> object with given <paramref name="interceptors"/>.
             </summary>
@@ -747,6 +787,8 @@
             <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
             <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
             <remarks>
+            This method generates new proxy type for each type of <paramref name="target"/>, which affects performance. If you don't want to proxy types differently depending on the type of the target
+            use <see cref="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTargetInterface``1(``0,Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])"/> method.
             This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
             As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
             </remarks>
@@ -770,6 +812,8 @@
             <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
             <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
             <remarks>
+            This method generates new proxy type for each type of <paramref name="target"/>, which affects performance. If you don't want to proxy types differently depending on the type of the target
+            use <see cref="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTargetInterface(System.Type,System.Object,Castle.Core.Interceptor.IInterceptor[])"/> method.
             This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
             As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
             </remarks>
@@ -794,6 +838,8 @@
             <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
             <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
             <remarks>
+            This method generates new proxy type for each type of <paramref name="target"/>, which affects performance. If you don't want to proxy types differently depending on the type of the target
+            use <see cref="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTargetInterface(System.Type,System.Object,Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])"/> method.
             This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
             As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
             </remarks>
@@ -818,6 +864,8 @@
             <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
             <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
             <remarks>
+            This method generates new proxy type for each type of <paramref name="target"/>, which affects performance. If you don't want to proxy types differently depending on the type of the target
+            use <see cref="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTargetInterface(System.Type,System.Type[],System.Object,Castle.Core.Interceptor.IInterceptor[])"/> method.
             This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
             As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
             </remarks>
@@ -843,6 +891,8 @@
             <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
             <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
             <remarks>
+            This method generates new proxy type for each type of <paramref name="target"/>, which affects performance. If you don't want to proxy types differently depending on the type of the target
+            use <see cref="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTargetInterface(System.Type,System.Type[],System.Object,Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])"/> method.
             This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
             As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
             </remarks>
@@ -871,6 +921,74 @@
             As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
             </remarks>
         </member>
+        <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTargetInterface``1(``0,Castle.Core.Interceptor.IInterceptor[])">
+            <summary>
+            Creates proxy object intercepting calls to members of interface <typeparamref name="TInterface"/> on <paramref name="target"/> object with given <paramref name="interceptors"/>.
+            Interceptors can use <see cref="T:Castle.Core.Interceptor.IChangeProxyTarget"/> interface to provide other target for method invocation than default <paramref name="target"/>.
+            </summary>
+            <typeparam name="TInterface">Type of the interface implemented by <paramref name="target"/> which will be proxied.</typeparam>
+            <param name="target">The target object, calls to which will be intercepted.</param>
+            <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
+            <returns>
+            Object proxying calls to members of <typeparamref name="TInterface"/> type on <paramref name="target"/> object or alternative implementation swapped at runtime by an interceptor.
+            </returns>
+            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="target"/> object is a null reference (Nothing in Visual Basic).</exception>
+            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
+            <exception cref="T:System.ArgumentException">Thrown when given <typeparamref name="TInterface"/> is not an interface type.</exception>
+            <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
+            <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
+            <remarks>
+            This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
+            As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
+            </remarks>
+        </member>
+        <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTargetInterface``1(``0,Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])">
+            <summary>
+            Creates proxy object intercepting calls to members of interface <typeparamref name="TInterface"/> on <paramref name="target"/> object with given <paramref name="interceptors"/>.
+            Interceptors can use <see cref="T:Castle.Core.Interceptor.IChangeProxyTarget"/> interface to provide other target for method invocation than default <paramref name="target"/>.
+            </summary>
+            <typeparam name="TInterface">Type of the interface implemented by <paramref name="target"/> which will be proxied.</typeparam>
+            <param name="target">The target object, calls to which will be intercepted.</param>
+            <param name="options">The proxy generation options used to influence generated proxy type and object.</param>
+            <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
+            <returns>
+            Object proxying calls to members of <typeparamref name="TInterface"/> type on <paramref name="target"/> object or alternative implementation swapped at runtime by an interceptor.
+            </returns>
+            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="target"/> object is a null reference (Nothing in Visual Basic).</exception>
+            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
+            <exception cref="T:System.ArgumentException">Thrown when given <typeparamref name="TInterface"/> is not an interface type.</exception>
+            <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
+            <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
+            <remarks>
+            This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
+            As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
+            </remarks>
+        </member>
+        <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTargetInterface(System.Type,System.Type[],System.Object,Castle.Core.Interceptor.IInterceptor[])">
+            <summary>
+            Creates proxy object intercepting calls to members of interface <paramref name="interfaceToProxy"/> on <paramref name="target"/> object with given <paramref name="interceptors"/>.
+            Interceptors can use <see cref="T:Castle.Core.Interceptor.IChangeProxyTarget"/> interface to provide other target for method invocation than default <paramref name="target"/>.
+            </summary>
+            <param name="interfaceToProxy">Type of the interface implemented by <paramref name="target"/> which will be proxied.</param>
+            <param name="target">The target object, calls to which will be intercepted.</param>
+            <param name="additionalInterfacesToProxy">Additional interface types. Calls to their members will be proxied as well.</param>
+            <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
+            <returns>
+            Object proxying calls to members of <paramref name="interfaceToProxy"/> and <paramref name="additionalInterfacesToProxy"/> types on <paramref name="target"/> object or alternative implementation swapped at runtime by an interceptor.
+            </returns>
+            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interfaceToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
+            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="target"/> object is a null reference (Nothing in Visual Basic).</exception>
+            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
+            <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is a generic type definition.</exception>
+            <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is not an interface type.</exception>
+            <exception cref="T:System.ArgumentException">Thrown when given <paramref name="target"/> does not implement <paramref name="interfaceToProxy"/> interface.</exception>
+            <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
+            <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
+            <remarks>
+            This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
+            As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
+            </remarks>
+        </member>
         <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTargetInterface(System.Type,System.Object,Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])">
             <summary>
             Creates proxy object intercepting calls to members of interface <paramref name="interfaceToProxy"/> on <paramref name="target"/> object with given <paramref name="interceptors"/>.
@@ -931,11 +1049,12 @@
             <returns>
             Object proxying calls to members of <typeparamref name="TInterface"/> types on generated target object.
             </returns>
-            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptor"/> object is a null reference (Nothing in Visual Basic).</exception>
+            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptor"/> array is a null reference (Nothing in Visual Basic).</exception>
             <exception cref="T:System.ArgumentException">Thrown when given <typeparamref name="TInterface"/> is not an interface type.</exception>
             <remarks>
             Since this method uses an empty-shell implementation of interfaces to proxy generated at runtime, the actual implementation of proxied methods must be provided by given <see cref="T:Castle.Core.Interceptor.IInterceptor"/> implementations.
             They are responsible for setting return value (and out parameters) on proxied methods. It is also illegal for an interceptor to call <see cref="M:Castle.Core.Interceptor.IInvocation.Proceed"/>, since there's no actual implementation to proceed with.
+            As a result of that also at least one <see cref="T:Castle.Core.Interceptor.IInterceptor"/> implementation must be provided.
             This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
             As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
             </remarks>
@@ -959,17 +1078,37 @@
             As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
             </remarks>
         </member>
+        <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithoutTarget``1(Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])">
+            <summary>
+            Creates proxy object intercepting calls to members of interface <typeparamref name="TInterface"/> on target object generated at runtime with given <paramref name="interceptors"/>.
+            </summary>
+            <typeparam name="TInterface">Type of the interface which will be proxied.</typeparam>
+            <param name="options">The proxy generation options used to influence generated proxy type and object.</param>
+            <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
+            <returns>
+            Object proxying calls to members of <typeparamref name="TInterface"/> types on generated target object.
+            </returns>
+            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
+            <exception cref="T:System.ArgumentException">Thrown when given <typeparamref name="TInterface"/> is not an interface type.</exception>
+            <remarks>
+            Since this method uses an empty-shell implementation of interfaces to proxy generated at runtime, the actual implementation of proxied methods must be provided by given <see cref="T:Castle.Core.Interceptor.IInterceptor"/> implementations.
+            They are responsible for setting return value (and out parameters) on proxied methods. It is also illegal for an interceptor to call <see cref="M:Castle.Core.Interceptor.IInvocation.Proceed"/>, since there's no actual implementation to proceed with.
+            As a result of that also at least one <see cref="T:Castle.Core.Interceptor.IInterceptor"/> implementation must be provided.
+            This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
+            As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
+            </remarks>
+        </member>
         <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithoutTarget(System.Type,Castle.Core.Interceptor.IInterceptor)">
             <summary>
             Creates proxy object intercepting calls to members of interface <paramref name="interfaceToProxy"/> on target object generated at runtime with given <paramref name="interceptor"/>.
             </summary>
             <param name="interfaceToProxy">Type of the interface which will be proxied.</param>
-            <param name="interceptor">The interceptor called during the invocation of proxied methods.</param>
+            <param name="interceptor">The interceptors called during the invocation of proxied methods.</param>
             <returns>
             Object proxying calls to members of <paramref name="interfaceToProxy"/> type on generated target object.
             </returns>
             <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interfaceToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
-            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptor"/> object is a null reference (Nothing in Visual Basic).</exception>
+            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptor"/> array is a null reference (Nothing in Visual Basic).</exception>
             <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is a generic type definition.</exception>
             <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is not an interface type.</exception>
             <remarks>
@@ -1020,6 +1159,26 @@
             As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
             </remarks>
         </member>
+        <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithoutTarget(System.Type,Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])">
+            <summary>
+            Creates proxy object intercepting calls to members of interface <paramref name="interfaceToProxy"/> on target object generated at runtime with given <paramref name="interceptors"/>.
+            </summary>
+            <param name="interfaceToProxy">Type of the interface which will be proxied.</param>
+            <param name="options">The proxy generation options used to influence generated proxy type and object.</param>
+            <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
+            <returns>
+            Object proxying calls to members of <paramref name="interfaceToProxy"/> on generated target object.
+            </returns>
+            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interfaceToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
+            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
+            <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/>  is a generic type definition.</exception>
+            <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is not an interface type.</exception>
+            <remarks>
+            They are responsible for setting return value (and out parameters) on proxied methods. It is also illegal for an interceptor to call <see cref="M:Castle.Core.Interceptor.IInvocation.Proceed"/>, since there's no actual implementation to proceed with.
+            This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
+            As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
+            </remarks>
+        </member>
         <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithoutTarget(System.Type,System.Type[],Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])">
             <summary>
             Creates proxy object intercepting calls to members of interface <paramref name="interfaceToProxy"/> on target object generated at runtime with given <paramref name="interceptors"/>.
@@ -1052,27 +1211,26 @@
             New object of type <typeparamref name="TClass"/> proxying calls to virtual members of <typeparamref name="TClass"/> type.
             </returns>
             <exception cref="T:System.ArgumentException">Thrown when given <typeparamref name="TClass"/> is not a class type.</exception>
-            <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on type <typeparamref name="TClass"/>.</exception>
+            <exception cref="T:System.ArgumentException">Thrown when no default constructor exists on type <typeparamref name="TClass"/>.</exception>
             <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of type <typeparamref name="TClass"/> throws an exception.</exception>
             <remarks>
             This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
             As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
             </remarks>
         </member>
-        <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateClassProxy(System.Type,Castle.Core.Interceptor.IInterceptor[])">
+        <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateClassProxy``1(Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])">
             <summary>
-            Creates proxy object intercepting calls to virtual members of type <paramref name="classToProxy"/> on newly created instance of that type with given <paramref name="interceptors"/>.
+            Creates proxy object intercepting calls to virtual members of type <typeparamref name="TClass"/> on newly created instance of that type with given <paramref name="interceptors"/>.
             </summary>
-            <param name="classToProxy">Type of class which will be proxied.</param>
+            <typeparam name="TClass">Type of class which will be proxied.</typeparam>
+            <param name="options">The proxy generation options used to influence generated proxy type and object.</param>
             <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
             <returns>
-            New object of type <paramref name="classToProxy"/> proxying calls to virtual members of <paramref name="classToProxy"/> type.
+            New object of type <typeparamref name="TClass"/> proxying calls to virtual members of <typeparamref name="TClass"/> type.
             </returns>
-            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="classToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
-            <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is a generic type definition.</exception>
-            <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is not a class type.</exception>
-            <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on type <paramref name="classToProxy"/>.</exception>
-            <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of type <paramref name="classToProxy"/> throws an exception.</exception>
+            <exception cref="T:System.ArgumentException">Thrown when given <typeparamref name="TClass"/> is not a class type.</exception>
+            <exception cref="T:System.ArgumentException">Thrown when no default constructor exists on type <typeparamref name="TClass"/>.</exception>
+            <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of type <typeparamref name="TClass"/> throws an exception.</exception>
             <remarks>
             This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
             As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
@@ -1091,7 +1249,7 @@
             <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="classToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
             <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is a generic type definition.</exception>
             <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is not a class type.</exception>
-            <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on type <paramref name="classToProxy"/>.</exception>
+            <exception cref="T:System.ArgumentException">Thrown when no default constructor exists on type <paramref name="classToProxy"/>.</exception>
             <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of type <paramref name="classToProxy"/> throws an exception.</exception>
             <remarks>
             This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
@@ -1111,7 +1269,67 @@
             <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="classToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
             <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is a generic type definition.</exception>
             <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is not a class type.</exception>
-            <exception cref="T:System.MissingMethodException">Thrown when no constructor exists on type <paramref name="classToProxy"/> with parameters matching <paramref name="constructorArguments"/>.</exception>
+            <exception cref="T:System.ArgumentException">Thrown when no constructor exists on type <paramref name="classToProxy"/> with parameters matching <paramref name="constructorArguments"/>.</exception>
+            <exception cref="T:System.Reflection.TargetInvocationException">Thrown when constructor of type <paramref name="classToProxy"/> throws an exception.</exception>
+            <remarks>
+            This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
+            As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
+            </remarks>
+        </member>
+        <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateClassProxy(System.Type,Castle.DynamicProxy.ProxyGenerationOptions,System.Object[],Castle.Core.Interceptor.IInterceptor[])">
+            <summary>
+            Creates proxy object intercepting calls to virtual members of type <paramref name="classToProxy"/> on newly created instance of that type with given <paramref name="interceptors"/>.
+            </summary>
+            <param name="classToProxy">Type of class which will be proxied.</param>
+            <param name="options">The proxy generation options used to influence generated proxy type and object.</param>
+            <param name="constructorArguments">Arguments of constructor of type <paramref name="classToProxy"/> which should be used to create a new instance of that type.</param>
+            <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
+            <returns>
+            New object of type <paramref name="classToProxy"/> proxying calls to virtual members of <paramref name="classToProxy"/> type.
+            </returns>
+            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="classToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
+            <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is a generic type definition.</exception>
+            <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is not a class type.</exception>
+            <exception cref="T:System.ArgumentException">Thrown when no constructor exists on type <paramref name="classToProxy"/> with parameters matching <paramref name="constructorArguments"/>.</exception>
+            <exception cref="T:System.Reflection.TargetInvocationException">Thrown when constructor of type <paramref name="classToProxy"/> throws an exception.</exception>
+            <remarks>
+            This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
+            As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
+            </remarks>
+        </member>
+        <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateClassProxy(System.Type,System.Object[],Castle.Core.Interceptor.IInterceptor[])">
+            <summary>
+            Creates proxy object intercepting calls to virtual members of type <paramref name="classToProxy"/> on newly created instance of that type with given <paramref name="interceptors"/>.
+            </summary>
+            <param name="classToProxy">Type of class which will be proxied.</param>
+            <param name="constructorArguments">Arguments of constructor of type <paramref name="classToProxy"/> which should be used to create a new instance of that type.</param>
+            <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
+            <returns>
+            New object of type <paramref name="classToProxy"/> proxying calls to virtual members of <paramref name="classToProxy"/> type.
+            </returns>
+            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="classToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
+            <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is a generic type definition.</exception>
+            <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is not a class type.</exception>
+            <exception cref="T:System.ArgumentException">Thrown when no constructor exists on type <paramref name="classToProxy"/> with parameters matching <paramref name="constructorArguments"/>.</exception>
+            <exception cref="T:System.Reflection.TargetInvocationException">Thrown when constructor of type <paramref name="classToProxy"/> throws an exception.</exception>
+            <remarks>
+            This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
+            As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
+            </remarks>
+        </member>
+        <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateClassProxy(System.Type,Castle.Core.Interceptor.IInterceptor[])">
+            <summary>
+            Creates proxy object intercepting calls to virtual members of type <paramref name="classToProxy"/> on newly created instance of that type with given <paramref name="interceptors"/>.
+            </summary>
+            <param name="classToProxy">Type of class which will be proxied.</param>
+            <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
+            <returns>
+            New object of type <paramref name="classToProxy"/> proxying calls to virtual members of <paramref name="classToProxy"/> type.
+            </returns>
+            <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="classToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
+            <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is a generic type definition.</exception>
+            <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is not a class type.</exception>
+            <exception cref="T:System.ArgumentException">Thrown when no parameterless constructor exists on type <paramref name="classToProxy"/>.</exception>
             <exception cref="T:System.Reflection.TargetInvocationException">Thrown when constructor of type <paramref name="classToProxy"/> throws an exception.</exception>
             <remarks>
             This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
@@ -1132,7 +1350,7 @@
             <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="options"/> object is a null reference (Nothing in Visual Basic).</exception>
             <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is a generic type definition.</exception>
             <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is not a class type.</exception>
-            <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on type <paramref name="classToProxy"/>.</exception>
+            <exception cref="T:System.ArgumentException">Thrown when no default constructor exists on type <paramref name="classToProxy"/>.</exception>
             <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of type <paramref name="classToProxy"/> throws an exception.</exception>
             <remarks>
             This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
@@ -1154,7 +1372,7 @@
             <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="options"/> object is a null reference (Nothing in Visual Basic).</exception>
             <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is a generic type definition.</exception>
             <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is not a class type.</exception>
-            <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on type <paramref name="classToProxy"/>.</exception>
+            <exception cref="T:System.ArgumentException">Thrown when no default constructor exists on type <paramref name="classToProxy"/>.</exception>
             <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of type <paramref name="classToProxy"/> throws an exception.</exception>
             <remarks>
             This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
@@ -1177,7 +1395,7 @@
             <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="options"/> object is a null reference (Nothing in Visual Basic).</exception>
             <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is a generic type definition.</exception>
             <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is not a class type.</exception>
-            <exception cref="T:System.MissingMethodException">Thrown when no constructor exists on type <paramref name="classToProxy"/> with parameters matching <paramref name="constructorArguments"/>.</exception>
+            <exception cref="T:System.ArgumentException">Thrown when no constructor exists on type <paramref name="classToProxy"/> with parameters matching <paramref name="constructorArguments"/>.</exception>
             <exception cref="T:System.Reflection.TargetInvocationException">Thrown when constructor of type <paramref name="classToProxy"/> throws an exception.</exception>
             <remarks>
             This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
@@ -1203,13 +1421,12 @@
             <param name="options">The options for proxy generation process.</param>
             <returns><see cref="T:System.Type"/> of proxy.</returns>
         </member>
-        <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyTypeWithTargetInterface(System.Type,System.Type[],System.Type,Castle.DynamicProxy.ProxyGenerationOptions)">
+        <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyTypeWithTargetInterface(System.Type,System.Type[],Castle.DynamicProxy.ProxyGenerationOptions)">
             <summary>
             Creates the proxy type for interface proxy with target interface for given <paramref name="interfaceToProxy"/> interface, implementing given <paramref name="additionalInterfacesToProxy"/> on given <paramref name="targetType"/> and using provided <paramref name="options"/>.
             </summary>
             <param name="interfaceToProxy">The interface proxy type should implement.</param>
             <param name="additionalInterfacesToProxy">The additional interfaces proxy type should implement.</param>
-            <param name="targetType">Actual type that the proxy type will encompass.</param>
             <param name="options">The options for proxy generation process.</param>
             <returns><see cref="T:System.Type"/> of proxy.</returns>
         </member>
@@ -1222,6 +1439,11 @@
             <param name="options">The options for proxy generation process.</param>
             <returns><see cref="T:System.Type"/> of proxy.</returns>
         </member>
+        <member name="P:Castle.DynamicProxy.ProxyGenerator.Logger">
+            <summary>
+            Gets or sets the <see cref="T:Castle.Core.Logging.ILogger"/> that this <see cref="T:Castle.DynamicProxy.ProxyGenerator"/> log to.
+            </summary>
+        </member>
         <member name="P:Castle.DynamicProxy.ProxyGenerator.ProxyBuilder">
             <summary>
             Gets the proxy builder instance used to generate proxy types.