castle.dynamicproxy2 2.0.3.0 → 2.1.0.0

Sign up to get free protection for your applications and to get access to all the features.
@@ -0,0 +1,85 @@
1
+ 1.1.0 (2009-05-04)
2
+ ==================
3
+
4
+ - Applied Eric Hauser's patch fixing CORE-ISSUE-22
5
+ "Support for environment variables in resource URI"
6
+
7
+ - Applied Gauthier Segay's patch fixing CORE-ISSUE-20
8
+ "Castle.Core.Tests won't build via nant because it use TraceContext without referencing System.Web.dll"
9
+
10
+ - Added simple interface to ComponentModel to make optional properties required.
11
+
12
+ - Applied Mark's -- <mwatts42@gmail.com> -- patch that changes
13
+ the Core to support being compiled for Silverlight 2
14
+
15
+ - Applied Louis DeJardin's patch adding TraceLogger as a new logger implementation
16
+
17
+ - Applied Chris Bilson's patch fixing CORE-15
18
+ "WebLogger Throws When Logging Outside of an HttpContext"
19
+
20
+ Release Candidate 3
21
+ ===================
22
+
23
+ - Added IServiceProviderEx which extends IServiceProvider
24
+
25
+ - Added Pair<T,S> class.
26
+
27
+ - Applied Bill Pierce's patch fixing CORE-9
28
+ "Allow CastleComponent Attribute to Specify Lifestyle in Constructor"
29
+
30
+ - Added UseSingleInterfaceProxy to CompomentModel to control the proxying
31
+ behavior while maintaining backward compatibility.
32
+ Added the corresponding ComponentProxyBehaviorAttribute.
33
+
34
+ - Made NullLogger and IExtnededLogger
35
+
36
+ - Enabled a new format on ILogger interface, with 6 overloads for each method:
37
+ Debug(string)
38
+ Debug(string, Exception)
39
+ Debug(string, params object[])
40
+ DebugFormat(string, params object[])
41
+ DebugFormat(Exception, string, params object[])
42
+ DebugFormat(IFormatProvider, string, params object[])
43
+ DebugFormat(IFormatProvider, Exception, string, params object[])
44
+
45
+ The "FatalError" overloads where marked as [Obsolete], replaced by "Fatal" and "FatalFormat".
46
+
47
+ 0.0.1.0
48
+ =======
49
+
50
+ - Included IProxyTargetAccessor
51
+
52
+ - Removed IMethodInterceptor and IMethodInvocation, that have been replaced
53
+ by IInterceptor and IInvocation
54
+
55
+ - Added FindByPropertyInfo to PropertySetCollection
56
+
57
+ - Made the DependencyModel.IsOptional property writable
58
+
59
+ - Applied Curtis Schlak's patch fixing IOC-27
60
+ "assembly resource format only works for resources where the assemblies name and default namespace are the same."
61
+
62
+ Quoting:
63
+
64
+ "I chose to preserve backwards compatibility by implementing the code in the
65
+ reverse order as suggested by the reporter. Given the following URI for a resource:
66
+
67
+ assembly://my.cool.assembly/context/moo/file.xml
68
+
69
+ It will initially look for an embedded resource with the manifest name of
70
+ "my.cool.assembly.context.moo.file.xml" in the loaded assembly my.cool.assembly.dll.
71
+ If it does not find it, then it looks for the embedded resource with the manifest name
72
+ of "context.moo.file.xml".
73
+
74
+ - IServiceEnabledComponent Introduced to be used across the project as
75
+ a standard way to have access to common services, for example, logger factories
76
+
77
+ - Added missing log factories
78
+
79
+ - Refactor StreamLogger and DiagnosticLogger to be more consistent behavior-wise
80
+
81
+ - Refactored WebLogger to extend LevelFilteredLogger (removed duplication)
82
+
83
+ - Refactored LoggerLevel order
84
+
85
+ - Project started
@@ -0,0 +1,163 @@
1
+ Unreleased Changes
2
+ ==================
3
+ - N/A
4
+
5
+ 2.1.0 (2009-05-04)
6
+ ==================
7
+ - Fixed DYNPROXY-87: "Mixin takes precedence over target object"
8
+ changed DP to throw exceptions when two mixins implement the same interface or a mixin implements the same interface as its target class/object
9
+
10
+ - Applied Krzysztof Kozmic's patch improving the XML documentation of IInterceptorSelector
11
+ and IProxyGenerationHook.
12
+
13
+ 2.1.0 RC1 (2009-03-10)
14
+ ======================
15
+ - Applied Krzysztof Kozmic's patch improving the XML documentation and parameter names of IProxyBuilder, DefaultProxyBuilder and ProxyGenerator.
16
+
17
+ - Applied Krzysztof Kozmic's patch heavily improving the XML documentation of ProxyGenerator.
18
+
19
+ - Fixed DYNPROXY-ISSUE-84: "UseSingleInterfaceProxy on ProxyGenerationOptions is never used and should be removed"
20
+
21
+ - Fixed DYNPROXY-ISSUE-58/DYNPROXY-ISSUE-77: "Inherited interface seems not to work"
22
+ using Dimitri Goethals' test case and Ayende Rahien/Andrey Shchekin's patch.
23
+
24
+ - Fixed DYNPROXY-ISSUE-52: "DynamicProxy 1.1.5 doesn't work on Medium Trust"
25
+ uses the assembly's fullname instead of calling GetName()
26
+
27
+ - Fixed DYNPROXY-ISSUE-82: "Not allow generics & NoGeneric methods with same signature"
28
+ using Fabio Maulo's test case and Krzysztof Kozmic patch.
29
+
30
+ - Applied Neil Bourgeois's patch fixing DYNPROXY-ISSUE-78
31
+ "Custom attributes of virtual properties absent on proxy"
32
+
33
+ - Applied Craig Vermeer's patch fixing an issue with generating default constructors for DYNPROXY-ISSUE-81
34
+ "No Default Constructor in generated Class Proxy"
35
+
36
+ - Added support for IInterceptorSelector (patch provided by Krzysztof Kozmic).
37
+ - Removed ProxyGenerationOptions.UseSelector.
38
+
39
+ - Added support for generic methods when specifying additional interfaces to CreateInterfaceProxyWithoutTarget (reported by Craig Neuwirth, cause
40
+ found by Krzysztof Kozmic)
41
+
42
+ - Added support for provide additional interfaces for target interface proxies.
43
+
44
+ - Added workarounds for dictionary deserialization scenarios (reported by Gr�gory C�let)
45
+
46
+ - Fixed mixin-related bug with serialization (per Rogelio again)
47
+ - Made interface proxies without target and with target interface support mixins
48
+
49
+ - Fixed ProxyGenerationOptions equality issues with ordering and different instances of the same mixin types (thanks for finding
50
+ the bug, Rogelio)
51
+
52
+ - Readded mixin support (via Rogelio J. Baucells)
53
+
54
+ - ClassEmitter now supports emitting fields with specific attributes
55
+
56
+ - Added a load API to ModuleScope
57
+ - SaveAssembly now serializes the cache keys together with the generated types
58
+
59
+ - Fixed test issue - PEVerify is now called with a quoted assembly path (to allow for spaces in the path)
60
+ - Fixed test annoyance - PEVerify is now not called in a separate window
61
+ - Changed PersistentProxyBuilder behavior - SaveAssembly is not called by the class generators any more, instead PersistentProxyBuilder.SaveAssemblies
62
+ must be used. This allows the proxy builder to save multiple proxies at the same time. Test cases have been adapted.
63
+
64
+ - Fixed issues with CacheKey.Equals and ProxyGenerationOptions.Equals/GetHashCode
65
+ - Added a way to set and retrieve the ModuleScope used by ProxyObjectReference for proxy deserialization; proxies can now be deserialized with
66
+ the same ModuleScope used by the application (DYNPROXY-71)
67
+
68
+ - Made BasePEVerifyTestCase only check those assemblies that were actually generated in the test case, see DYNPROXY-68
69
+ - Fixed bug with protected internal constructors, see DYNPROXY-66/DYNPROXY-67
70
+ - Fixed test cases not using the ProxyGenerator supplied by BasePEVerifyTestCase, see DYNPROXY-69
71
+
72
+ - Added StrongNameUtil, which provides methods for checking whether an assembly is signed/a type comes from a signed assembly
73
+ - Added an additional constructor overload to ClassEmitter, allowing to force it to use an unsigned assembly
74
+
75
+ - 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
76
+ directory
77
+
78
+ - Applied Pawel Pabich's suggestion fixing DYNPROXY-65
79
+ "OpCodeUtil.GetUnderlyingTypeOfEnum doesn't handle unsigned integers"
80
+
81
+ - Fixed bug in ArgumentReference occurring when emitting static methods
82
+
83
+ - Removed ClsCompliant(false) from all the public types in DynamicProxy
84
+
85
+ - Added constructors to ClassEmitter, removed "serializable" ctor parameter, it wasn't used
86
+
87
+ - Fixed bug in ModuleScope, see DYNPROXY-64
88
+
89
+ - Fixed bug in LoadArrayElementExpression, see DYNPROXY-57
90
+
91
+ - Changed signing behavior for generated assembly, assembly is now only signed if all involved types (base type, interfaces) are also signed
92
+
93
+ - Documented ModuleScope, added friendlier API for saving assemblies, added tests for ModuleScope, see DYNPROXY-55
94
+
95
+ - Applied Adam Tybor's patch fixing DYNPROXY-63
96
+ "ProxyType not included in CacheKey"
97
+
98
+ - Reimplemented serialization of ProxyGenerationOptions, see revision 3803, DYNPROXY-59
99
+
100
+ - Added method signature filtering to MethodFinder (see MethodSignatureComparer) because there were
101
+ still cases triggering duplicate methods
102
+
103
+ - Reimplemented serialization without default constructors, see revision 3725, DYNPROXY-53
104
+ - Reimplemented serialization with delegates/events, see revision 3751, DYNPROXY-56
105
+
106
+ - Renamed InterfaceProxyGeneratorWithoutTarget to InterfaceProxyWithoutTargetGenerator
107
+
108
+ - Fixed DYNPROXY-62
109
+ "Some tests in MethodFinderTestCase failed because of culture specific exception messages"
110
+
111
+ - Implemented cache for System.Type.GetMethods() in order to avoid triggering the duplicate methods bug
112
+
113
+ - Applied Adam Tybor's patch fixing DYNPROXY-61
114
+ "Need GetInterceptors from IProxyTargetAccessor back for NHibernate Trunk"
115
+
116
+ - Disabled replication of internal constructors on class proxies.
117
+
118
+ - Moved the UseSingleInterfaceProxy from Core.ComponentModel to ProxyGeneratorOptions.
119
+
120
+ - Applied Lee Henson's patch fixing generic parameter definitions
121
+
122
+ - Applied Jacob Lewallen's patch that introduces ProxyInterfaceWithTargetInterface
123
+ Quoting
124
+
125
+ "I've introduced a new "mode" that is
126
+ ProxyInterfaceWithTargetInterface, that uses the given interface as
127
+ the target type, rather than the type of the target (it asserts the
128
+ target implements the interface) All other modes should remain the
129
+ same.
130
+
131
+ "In this scenario, the IInvocation will also implement
132
+ IChangeProxyTarget, which can then be used to change the proxy target
133
+ to another implementation of the target interface."
134
+
135
+ - Added support for events
136
+
137
+ - Fixed DYNPROXY-43
138
+ "DP2 : Missing ParameterInfo 'Name' for Proxied methods"
139
+
140
+ - Fixed DYNPROXY-41
141
+ "Invalid state exception on DP2"
142
+
143
+ - Fixed DYNPROXY-39
144
+ "Deadlock in DynamicProxy2"
145
+
146
+ - Fixed DYNPROXY-28
147
+ "Virtual methods calls from constructors are not working"
148
+
149
+ - Fixed DYNPROXY-27
150
+ "Support for non-parameterless constructors"
151
+
152
+ - Fixed DYNPROXY-25
153
+ "Chars returns are not properly configured"
154
+
155
+ - Fixed DYNPROXY-24
156
+ "DynamicProxy2: missing locks"
157
+
158
+ - Fixed DYNPROXY-34
159
+ "Cant proxy generic interfaces"
160
+
161
+ Alpha Version 1.0.0.0
162
+ =====================
163
+ - First release
@@ -0,0 +1,1249 @@
1
+ <?xml version="1.0"?>
2
+ <doc>
3
+ <assembly>
4
+ <name>Castle.DynamicProxy2</name>
5
+ </assembly>
6
+ <members>
7
+ <member name="T:Castle.DynamicProxy.Generators.Emitters.SimpleAST.IndirectReference">
8
+ <summary>
9
+ Wraps a reference that is passed
10
+ ByRef and provides indirect load/store support.
11
+ </summary>
12
+ </member>
13
+ <member name="T:Castle.DynamicProxy.Generators.Emitters.SimpleAST.NewArrayExpression">
14
+ <summary>
15
+ Summary description for NewArrayExpression.
16
+ </summary>
17
+ </member>
18
+ <member name="T:Castle.DynamicProxy.Generators.Emitters.SimpleAST.ReferencesToObjectArrayExpression">
19
+ <summary>
20
+
21
+ </summary>
22
+ </member>
23
+ <member name="M:Castle.DynamicProxy.Generators.Emitters.CustomAttributeUtil.InitializeConstructorArgs(System.Type,System.Attribute,System.Object[],System.Reflection.ParameterInfo[])">
24
+ <summary>
25
+ Here we try to match a constructor argument to its value.
26
+ Since we can't get the values from the assembly, we use some heuristics to get it.
27
+ a/ we first try to match all the properties on the attributes by name (case insensitive) to the argument
28
+ b/ if we fail we try to match them by property type, with some smarts about convertions (i,e: can use Guid for string).
29
+ </summary>
30
+ </member>
31
+ <member name="M:Castle.DynamicProxy.Generators.Emitters.CustomAttributeUtil.ReplaceIfBetterMatch(System.Reflection.ParameterInfo,System.Reflection.PropertyInfo,System.Reflection.PropertyInfo)">
32
+ <summary>
33
+ We have the following rules here.
34
+ Try to find a matching type, failing that, if the parameter is string, get the first property (under the assumption that
35
+ we can convert it.
36
+ </summary>
37
+ </member>
38
+ <member name="M:Castle.DynamicProxy.Generators.Emitters.CustomAttributeUtil.ConvertValue(System.Object,System.Type)">
39
+ <summary>
40
+ Attributes can only accept simple types, so we return null for null,
41
+ if the value is passed as string we call to string (should help with converting),
42
+ otherwise, we use the value as is (enums, integer, etc).
43
+ </summary>
44
+ </member>
45
+ <member name="T:Castle.DynamicProxy.Generators.Emitters.LdcOpCodesDictionary">
46
+ <summary>s
47
+ Provides appropriate Ldc.X opcode for the type of primitive value to be loaded.
48
+ </summary>
49
+ </member>
50
+ <member name="T:Castle.DynamicProxy.Generators.Emitters.LdindOpCodesDictionary">
51
+ <summary>
52
+ Provides appropriate Ldind.X opcode for
53
+ the type of primitive value to be loaded indirectly.
54
+ </summary>
55
+ </member>
56
+ <member name="M:Castle.DynamicProxy.Generators.Emitters.MethodEmitter.CopyParametersAndReturnTypeFrom(System.Reflection.MethodInfo,Castle.DynamicProxy.Generators.Emitters.AbstractTypeEmitter)">
57
+ <summary>
58
+ Inspect the base method for generic definitions
59
+ and set the return type and the parameters
60
+ accordingly
61
+ </summary>
62
+ </member>
63
+ <member name="M:Castle.DynamicProxy.Generators.Emitters.OpCodeUtil.EmitLoadOpCodeForConstantValue(System.Reflection.Emit.ILGenerator,System.Object)">
64
+ <summary>
65
+ Emits a load opcode of the appropriate kind for a constant string or
66
+ primitive value.
67
+ </summary>
68
+ <param name="gen"></param>
69
+ <param name="value"></param>
70
+ </member>
71
+ <member name="M:Castle.DynamicProxy.Generators.Emitters.OpCodeUtil.EmitLoadOpCodeForDefaultValueOfType(System.Reflection.Emit.ILGenerator,System.Type)">
72
+ <summary>
73
+ Emits a load opcode of the appropriate kind for the constant default value of a
74
+ type, such as 0 for value types and null for reference types.
75
+ </summary>
76
+ </member>
77
+ <member name="M:Castle.DynamicProxy.Generators.Emitters.OpCodeUtil.EmitLoadIndirectOpCodeForType(System.Reflection.Emit.ILGenerator,System.Type)">
78
+ <summary>
79
+ Emits a load indirect opcode of the appropriate type for a value or object reference.
80
+ Pops a pointer off the evaluation stack, dereferences it and loads
81
+ a value of the specified type.
82
+ </summary>
83
+ <param name="gen"></param>
84
+ <param name="type"></param>
85
+ </member>
86
+ <member name="M:Castle.DynamicProxy.Generators.Emitters.OpCodeUtil.EmitStoreIndirectOpCodeForType(System.Reflection.Emit.ILGenerator,System.Type)">
87
+ <summary>
88
+ Emits a store indirectopcode of the appropriate type for a value or object reference.
89
+ Pops a value of the specified type and a pointer off the evaluation stack, and
90
+ stores the value.
91
+ </summary>
92
+ <param name="gen"></param>
93
+ <param name="type"></param>
94
+ </member>
95
+ <member name="T:Castle.DynamicProxy.Generators.Emitters.PropertiesCollection">
96
+ <summary>
97
+ Summary description for PropertiesCollection.
98
+ </summary>
99
+ </member>
100
+ <member name="T:Castle.DynamicProxy.Generators.Emitters.StindOpCodesDictionary">
101
+ <summary>
102
+ Provides appropriate Stind.X opcode
103
+ for the type of primitive value to be stored indirectly.
104
+ </summary>
105
+ </member>
106
+ <member name="T:Castle.DynamicProxy.Generators.BaseProxyGenerator">
107
+ <summary>
108
+ Base class that exposes the common functionalities
109
+ to proxy generation.
110
+ </summary>
111
+ <remarks>
112
+ TODO:
113
+ - Add tests and fixes for 'leaking this' problem
114
+ </remarks>
115
+ </member>
116
+ <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.GetProxyTargetReference">
117
+ <summary>
118
+ Used by dinamically implement <see cref="T:Castle.Core.Interceptor.IProxyTargetAccessor"/>
119
+ </summary>
120
+ <returns></returns>
121
+ </member>
122
+ <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.GenerateParameterlessConstructor(Castle.DynamicProxy.Generators.Emitters.ClassEmitter,System.Type,Castle.DynamicProxy.Generators.Emitters.SimpleAST.FieldReference)">
123
+ <summary>
124
+ Generates a parameters constructor that initializes the proxy
125
+ state with <see cref="T:Castle.Core.Interceptor.StandardInterceptor"/> just to make it non-null.
126
+ <para>
127
+ This constructor is important to allow proxies to be XML serializable
128
+ </para>
129
+ </summary>
130
+ </member>
131
+ <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)">
132
+ <summary>
133
+ If callbackMethod is null the InvokeOnTarget implementation
134
+ is just the code to throw an exception
135
+ </summary>
136
+ <param name="emitter"></param>
137
+ <param name="targetType"></param>
138
+ <param name="targetForInvocation"></param>
139
+ <param name="methodInfo"></param>
140
+ <param name="callbackMethod"></param>
141
+ <param name="version"></param>
142
+ <returns></returns>
143
+ </member>
144
+ <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)">
145
+ <summary>
146
+ If callbackMethod is null the InvokeOnTarget implementation
147
+ is just the code to throw an exception
148
+ </summary>
149
+ <param name="emitter"></param>
150
+ <param name="targetType"></param>
151
+ <param name="targetForInvocation"></param>
152
+ <param name="methodInfo"></param>
153
+ <param name="callbackMethod"></param>
154
+ <param name="version"></param>
155
+ <param name="allowChangeTarget">If true the invocation will implement the IChangeProxyTarget interface</param>
156
+ <returns></returns>
157
+ </member>
158
+ <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)">
159
+ <summary>
160
+ Generates the constructor for the nested class that extends
161
+ <see cref="T:Castle.DynamicProxy.AbstractInvocation"/>
162
+ </summary>
163
+ <param name="targetFieldType"></param>
164
+ <param name="nested"></param>
165
+ <param name="targetField"></param>
166
+ <param name="version"></param>
167
+ </member>
168
+ <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.CreateInitializeCacheMethodBody(System.Type,System.Reflection.MethodInfo[],Castle.DynamicProxy.Generators.Emitters.ClassEmitter,Castle.DynamicProxy.Generators.Emitters.ConstructorEmitter)">
169
+ <summary>
170
+ Improvement: this cache should be static. We should generate a
171
+ type constructor instead
172
+ </summary>
173
+ </member>
174
+ <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.AcceptMethod(System.Reflection.MethodInfo,System.Boolean)">
175
+ <summary>
176
+ Performs some basic screening and invokes the <see cref="T:Castle.DynamicProxy.IProxyGenerationHook"/>
177
+ to select methods.
178
+ </summary>
179
+ <param name="method"></param>
180
+ <param name="onlyVirtuals"></param>
181
+ <returns></returns>
182
+ </member>
183
+ <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.IsAccessible(System.Reflection.MethodInfo)">
184
+ <summary>
185
+ Checks if the method is public or protected.
186
+ </summary>
187
+ <param name="method"></param>
188
+ <returns></returns>
189
+ </member>
190
+ <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.ShouldSkipAttributeReplication(System.Attribute)">
191
+ <summary>
192
+ Attributes should be replicated if they are non-inheritable,
193
+ but there are some special cases where the attributes means
194
+ something to the CLR, where they should be skipped.
195
+ </summary>
196
+ </member>
197
+ <member name="M:Castle.DynamicProxy.Generators.BaseProxyGenerator.ShouldCreateNewSlot(System.Reflection.MethodInfo)">
198
+ <summary>
199
+ Checks if the method has the same signature as a method that was marked as
200
+ one that should generate a new vtable slot.
201
+ </summary>
202
+ </member>
203
+ <member name="M:Castle.DynamicProxy.Generators.CacheKey.#ctor(System.Type,System.Type[],Castle.DynamicProxy.ProxyGenerationOptions)">
204
+ <summary>
205
+ Initializes a new instance of the <see cref="T:Castle.DynamicProxy.Generators.CacheKey"/> class.
206
+ </summary>
207
+ <param name="targetType">Type of the target.</param>
208
+ <param name="interfaces">The interfaces.</param>
209
+ <param name="options">The options.</param>
210
+ </member>
211
+ <member name="T:Castle.DynamicProxy.Generators.ClassProxyGenerator">
212
+ <summary>
213
+
214
+ </summary>
215
+ </member>
216
+ <member name="M:Castle.DynamicProxy.Generators.EventToGenerate.#ctor(Castle.DynamicProxy.Generators.Emitters.EventEmitter,System.Reflection.MethodInfo,System.Reflection.MethodInfo,System.Reflection.EventAttributes)">
217
+ <summary>
218
+ Initializes a new instance of the <see cref="T:Castle.DynamicProxy.Generators.EventToGenerate"/> class.
219
+ </summary>
220
+ <param name="emitter">The emitter.</param>
221
+ <param name="addMethod">The add method.</param>
222
+ <param name="removeMethod">The remove method.</param>
223
+ <param name="attributes">The attributes.</param>
224
+ </member>
225
+ <member name="T:Castle.DynamicProxy.Generators.InterfaceProxyWithTargetGenerator">
226
+ <summary>
227
+
228
+ </summary>
229
+ </member>
230
+ <member name="M:Castle.DynamicProxy.Generators.InterfaceProxyWithTargetGenerator.FindMethodOnTargetType(System.Reflection.MethodInfo,System.Type,System.Boolean)">
231
+ <summary>
232
+ Finds the type of the method on target.
233
+ </summary>
234
+ <param name="methodOnInterface">The method on interface.</param>
235
+ <param name="proxyTargetType">Type of the proxy target.</param>
236
+ /// <param name="checkMixins">if set to <c>true</c> will check implementation on mixins.</param>
237
+ <returns></returns>
238
+ </member>
239
+ <member name="M:Castle.DynamicProxy.Generators.InterfaceProxyWithTargetGenerator.IsTypeEquivalent(System.Type,System.Type)">
240
+ <summary>
241
+ Checks whether the given types are the same. This is
242
+ more complicated than it looks.
243
+ </summary>
244
+ <param name="sourceType"></param>
245
+ <param name="targetType"></param>
246
+ <returns></returns>
247
+ </member>
248
+ <member name="M:Castle.DynamicProxy.Generators.InterfaceProxyWithTargetGenerator.IsMethodEquivalent(System.Reflection.MethodInfo,System.Reflection.MethodInfo)">
249
+ <summary>
250
+ Checks whether the given methods are the same.
251
+ </summary>
252
+ <param name="methodInfo"></param>
253
+ <param name="methodOnInterface"></param>
254
+ <returns>True if the methods are the same.</returns>
255
+ </member>
256
+ <member name="T:Castle.DynamicProxy.Generators.InterfaceGeneratorType">
257
+ <summary>
258
+ This is used by the ProxyObjectReference class durin de-serialiation, to know
259
+ which generator it should use
260
+ </summary>
261
+ </member>
262
+ <member name="T:Castle.DynamicProxy.Generators.MethodFinder">
263
+ <summary>
264
+ Returns the methods implemented by a type. Use this instead of Type.GetMethods() to work around a CLR issue
265
+ where duplicate MethodInfos are returned by Type.GetMethods() after a token of a generic type's method was loaded.
266
+ </summary>
267
+ </member>
268
+ <member name="T:Castle.DynamicProxy.Serialization.ProxyObjectReference">
269
+ <summary>
270
+ Handles the deserialization of proxies.
271
+ </summary>
272
+ </member>
273
+ <member name="M:Castle.DynamicProxy.Serialization.ProxyObjectReference.ResetScope">
274
+ <summary>
275
+ Resets the <see cref="P:Castle.DynamicProxy.Serialization.ProxyObjectReference.ModuleScope"/> used for deserialization to a new scope.
276
+ </summary>
277
+ <remarks>This is useful for test cases.</remarks>
278
+ </member>
279
+ <member name="M:Castle.DynamicProxy.Serialization.ProxyObjectReference.SetScope(Castle.DynamicProxy.ModuleScope)">
280
+ <summary>
281
+ Resets the <see cref="P:Castle.DynamicProxy.Serialization.ProxyObjectReference.ModuleScope"/> used for deserialization to a given <paramref name="scope"/>.
282
+ </summary>
283
+ <param name="scope">The scope to be used for deserialization.</param>
284
+ <remarks>By default, the deserialization process uses a different scope than the rest of the application, which can lead to multiple proxies
285
+ being generated for the same type. By explicitly setting the deserialization scope to the application's scope, this can be avoided.</remarks>
286
+ </member>
287
+ <member name="P:Castle.DynamicProxy.Serialization.ProxyObjectReference.ModuleScope">
288
+ <summary>
289
+ Gets the <see cref="T:Castle.DynamicProxy.ModuleScope"/> used for deserialization.
290
+ </summary>
291
+ <value>As <see cref="T:Castle.DynamicProxy.Serialization.ProxyObjectReference"/> has no way of automatically determining the scope used by the application (and the application
292
+ 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
293
+ 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>
294
+ </member>
295
+ <member name="T:Castle.DynamicProxy.IProxyGenerationHook">
296
+ <summary>
297
+ Used during the target type inspection process. Implementors have a chance to customize the
298
+ proxy generation process.
299
+ </summary>
300
+ </member>
301
+ <member name="M:Castle.DynamicProxy.IProxyGenerationHook.ShouldInterceptMethod(System.Type,System.Reflection.MethodInfo)">
302
+ <summary>
303
+ Invoked by the generation process to determine if the specified method should be proxied.
304
+ </summary>
305
+ <param name="type">The type which declares the given method.</param>
306
+ <param name="methodInfo">The method to inspect.</param>
307
+ <returns>True if the given method should be proxied; false otherwise.</returns>
308
+ </member>
309
+ <member name="M:Castle.DynamicProxy.IProxyGenerationHook.NonVirtualMemberNotification(System.Type,System.Reflection.MemberInfo)">
310
+ <summary>
311
+ Invoked by the generation process to notify that a member was not marked as virtual.
312
+ </summary>
313
+ <param name="type">The type which declares the non-virtual member.</param>
314
+ <param name="memberInfo">The non-virtual member.</param>
315
+ <remarks>
316
+ Non-virtual members cannot be proxied. This method gives an opportunity to inspect
317
+ any non-virtual member of a type that has been requested to be proxied, and if
318
+ appropriate - throw an exception to notify the caller.
319
+ </remarks>
320
+ </member>
321
+ <member name="M:Castle.DynamicProxy.IProxyGenerationHook.MethodsInspected">
322
+ <summary>
323
+ Invoked by the generation process to notify that the whole process has completed.
324
+ </summary>
325
+ </member>
326
+ <member name="T:Castle.DynamicProxy.CacheMappingsAttribute">
327
+ <summary>
328
+ Applied to the assemblies saved by <see cref="T:Castle.DynamicProxy.ModuleScope"/> in order to persist the cache data included in the persisted assembly.
329
+ </summary>
330
+ </member>
331
+ <member name="T:Castle.DynamicProxy.DefaultProxyBuilder">
332
+ <summary>
333
+ Default implementation of <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> interface producing in-memory proxy assemblies.
334
+ </summary>
335
+ </member>
336
+ <member name="T:Castle.DynamicProxy.IProxyBuilder">
337
+ <summary>
338
+ Abstracts the implementation of proxy type construction.
339
+ </summary>
340
+ </member>
341
+ <member name="M:Castle.DynamicProxy.IProxyBuilder.CreateClassProxy(System.Type,Castle.DynamicProxy.ProxyGenerationOptions)">
342
+ <summary>
343
+ Creates a proxy type for given <paramref name="classToProxy"/>, using <paramref name="options"/> provided.
344
+ </summary>
345
+ <param name="classToProxy">The class type to proxy.</param>
346
+ <param name="options">The proxy generation options.</param>
347
+ <returns>The generated proxy type.</returns>
348
+ <exception cref="T:Castle.DynamicProxy.Generators.GeneratorException">Thrown when <paramref name="classToProxy"/> is a generic type definition.</exception>
349
+ <exception cref="T:Castle.DynamicProxy.Generators.GeneratorException">Thrown when <paramref name="classToProxy"/> is not public.
350
+ Note that to avoid this exception, you can mark offending type internal, and define <see cref="T:System.Runtime.CompilerServices.InternalsVisibleToAttribute"/>
351
+ pointing to Castle Dynamic Proxy assembly, in assembly containing that type, if this is appropriate.</exception>
352
+ <seealso cref="T:Castle.DynamicProxy.Generators.ClassProxyGenerator"/>
353
+ </member>
354
+ <member name="M:Castle.DynamicProxy.IProxyBuilder.CreateClassProxy(System.Type,System.Type[],Castle.DynamicProxy.ProxyGenerationOptions)">
355
+ <summary>
356
+ Creates a proxy type for given <paramref name="classToProxy"/>, implementing <paramref name="additionalInterfacesToProxy"/>, using <paramref name="options"/> provided.
357
+ </summary>
358
+ <param name="classToProxy">The class type to proxy.</param>
359
+ <param name="additionalInterfacesToProxy">Additional interface types to proxy.</param>
360
+ <param name="options">The proxy generation options.</param>
361
+ <returns>The generated proxy type.</returns>
362
+ <remarks>
363
+ Implementers should return a proxy type for the specified class and interfaces.
364
+ 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.)
365
+ </remarks>
366
+ <exception cref="T:Castle.DynamicProxy.Generators.GeneratorException">Thrown when <paramref name="classToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is a generic type definition.</exception>
367
+ <exception cref="T:Castle.DynamicProxy.Generators.GeneratorException">Thrown when <paramref name="classToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is not public.
368
+ Note that to avoid this exception, you can mark offending type internal, and define <see cref="T:System.Runtime.CompilerServices.InternalsVisibleToAttribute"/>
369
+ pointing to Castle Dynamic Proxy assembly, in assembly containing that type, if this is appropriate.</exception>
370
+ <seealso cref="T:Castle.DynamicProxy.Generators.ClassProxyGenerator"/>
371
+ </member>
372
+ <member name="M:Castle.DynamicProxy.IProxyBuilder.CreateInterfaceProxyTypeWithTarget(System.Type,System.Type[],System.Type,Castle.DynamicProxy.ProxyGenerationOptions)">
373
+ <summary>
374
+ 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.
375
+ </summary>
376
+ <param name="interfaceToProxy">The interface type to proxy.</param>
377
+ <param name="additionalInterfacesToProxy">Additional interface types to proxy.</param>
378
+ <param name="targetType">Type implementing <paramref name="interfaceToProxy"/> on which calls to the interface members should be intercepted.</param>
379
+ <param name="options">The proxy generation options.</param>
380
+ <returns>The generated proxy type.</returns>
381
+ <remarks>
382
+ Implementers should return a proxy type for the specified interface that 'proceeds' executions to the specified target.
383
+ 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.)
384
+ </remarks>
385
+ <exception cref="T:Castle.DynamicProxy.Generators.GeneratorException">Thrown when <paramref name="interfaceToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is a generic type definition.</exception>
386
+ <exception cref="T:Castle.DynamicProxy.Generators.GeneratorException">Thrown when <paramref name="interfaceToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is not public.
387
+ Note that to avoid this exception, you can mark offending type internal, and define <see cref="T:System.Runtime.CompilerServices.InternalsVisibleToAttribute"/>
388
+ pointing to Castle Dynamic Proxy assembly, in assembly containing that type, if this is appropriate.</exception>
389
+ <seealso cref="T:Castle.DynamicProxy.Generators.InterfaceProxyWithTargetGenerator"/>
390
+ </member>
391
+ <member name="M:Castle.DynamicProxy.IProxyBuilder.CreateInterfaceProxyTypeWithoutTarget(System.Type,System.Type[],Castle.DynamicProxy.ProxyGenerationOptions)">
392
+ <summary>
393
+ Creates a proxy type for given <paramref name="interfaceToProxy"/> that delegates all calls to the provided interceptors.
394
+ </summary>
395
+ <param name="interfaceToProxy">The interface type to proxy.</param>
396
+ <param name="additionalInterfacesToProxy">Additional interface types to proxy.</param>
397
+ <param name="options">The proxy generation options.</param>
398
+ <returns>The generated proxy type.</returns>
399
+ <remarks>
400
+ Implementers should return a proxy type for the specified interface and additional interfaces that delegate all executions to the specified interceptors.
401
+ </remarks>
402
+ <exception cref="T:Castle.DynamicProxy.Generators.GeneratorException">Thrown when <paramref name="interfaceToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is a generic type definition.</exception>
403
+ <exception cref="T:Castle.DynamicProxy.Generators.GeneratorException">Thrown when <paramref name="interfaceToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is not public.
404
+ Note that to avoid this exception, you can mark offending type internal, and define <see cref="T:System.Runtime.CompilerServices.InternalsVisibleToAttribute"/>
405
+ pointing to Castle Dynamic Proxy assembly, in assembly containing that type, if this is appropriate.</exception>
406
+ <seealso cref="T:Castle.DynamicProxy.Generators.InterfaceProxyWithoutTargetGenerator"/>
407
+ </member>
408
+ <member name="M:Castle.DynamicProxy.IProxyBuilder.CreateInterfaceProxyTypeWithTargetInterface(System.Type,System.Type[],Castle.DynamicProxy.ProxyGenerationOptions)">
409
+ <summary>
410
+ Creates a proxy type for given <paramref name="interfaceToProxy"/> and <parmaref name="additionalInterfacesToProxy"/> that delegates all calls to the provided interceptors and allows interceptors to switch the actual target of invocation.
411
+ </summary>
412
+ <param name="interfaceToProxy">The interface type to proxy.</param>
413
+ <param name="additionalInterfacesToProxy">Additional interface types to proxy.</param>
414
+ <param name="options">The proxy generation options.</param>
415
+ <returns>The generated proxy type.</returns>
416
+ <remarks>
417
+ Implementers should return a proxy type for the specified interface(s) that delegate all executions to the specified interceptors
418
+ and uses an instance of the interface as their targets (i.e. <see cref="P:Castle.Core.Interceptor.IInvocation.InvocationTarget"/>), rather than a class. All <see cref="T:Castle.Core.Interceptor.IInvocation"/> classes should then implement <see cref="T:Castle.Core.Interceptor.IChangeProxyTarget"/> interface,
419
+ to allow interceptors to switch invocation target with instance of another type implementing called interface.
420
+ </remarks>
421
+ <exception cref="T:Castle.DynamicProxy.Generators.GeneratorException">Thrown when <paramref name="interfaceToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is a generic type definition.</exception>
422
+ <exception cref="T:Castle.DynamicProxy.Generators.GeneratorException">Thrown when <paramref name="interfaceToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is not public.
423
+ Note that to avoid this exception, you can mark offending type internal, and define <see cref="T:System.Runtime.CompilerServices.InternalsVisibleToAttribute"/>
424
+ pointing to Castle Dynamic Proxy assembly, in assembly containing that type, if this is appropriate.</exception>
425
+ <seealso cref="T:Castle.DynamicProxy.Generators.InterfaceProxyWithTargetInterfaceGenerator"/>
426
+ </member>
427
+ <member name="P:Castle.DynamicProxy.IProxyBuilder.ModuleScope">
428
+ <summary>
429
+ Gets the <see cref="P:Castle.DynamicProxy.IProxyBuilder.ModuleScope"/> associated with this builder.
430
+ </summary>
431
+ <value>The module scope associated with this builder.</value>
432
+ </member>
433
+ <member name="M:Castle.DynamicProxy.DefaultProxyBuilder.#ctor">
434
+ <summary>
435
+ Initializes a new instance of the <see cref="T:Castle.DynamicProxy.DefaultProxyBuilder"/> class with new <see cref="T:Castle.DynamicProxy.ModuleScope"/>.
436
+ </summary>
437
+ </member>
438
+ <member name="M:Castle.DynamicProxy.DefaultProxyBuilder.#ctor(Castle.DynamicProxy.ModuleScope)">
439
+ <summary>
440
+ Initializes a new instance of the <see cref="T:Castle.DynamicProxy.DefaultProxyBuilder"/> class.
441
+ </summary>
442
+ <param name="scope">The module scope for generated proxy types.</param>
443
+ </member>
444
+ <member name="T:Castle.DynamicProxy.IInterceptorSelector">
445
+ <summary>
446
+ Provides an extension point that allows proxies to choose specific interceptors on
447
+ a per method basis.
448
+ </summary>
449
+ </member>
450
+ <member name="M:Castle.DynamicProxy.IInterceptorSelector.SelectInterceptors(System.Type,System.Reflection.MethodInfo,Castle.Core.Interceptor.IInterceptor[])">
451
+ <summary>
452
+ Selects the interceptors that should intercept calls to the given <paramref name="method"/>.
453
+ </summary>
454
+ <param name="type">The type declaring the method to intercept.</param>
455
+ <param name="method">The method that will be intercepted.</param>
456
+ <param name="interceptors">All interceptors registered with the proxy.</param>
457
+ <returns>An array of interceptors to invoke upon calling the <paramref name="method"/>.</returns>
458
+ <remarks>
459
+ This method is called only once per proxy instance, upon the first call to the
460
+ <paramref name="method"/>. Either an empty array or null are valid return values to indicate
461
+ that no interceptor should intercept calls to the method. Although it is not advised, it is
462
+ legal to return other <see cref="T:Castle.Core.Interceptor.IInterceptor"/> implementations than these provided in
463
+ <paramref name="interceptors"/>. A better way to do this, is by passing all the required
464
+ interceptors to the appropriate method of <see cref="T:Castle.DynamicProxy.ProxyGenerator"/>. You can use this
465
+ method to influence the order in which interceptors will be called, by reordering the array.
466
+ Returning an array containing null references (Nothing in Visual Basic) is not legal,
467
+ and will result in a runtime exception.
468
+ </remarks>
469
+ <seealso cref="T:Castle.DynamicProxy.ProxyGenerationOptions"/>
470
+ </member>
471
+ <member name="M:Castle.DynamicProxy.InternalsHelper.IsInternalToDynamicProxy(System.Reflection.Assembly)">
472
+ <summary>
473
+ Determines whether this assembly has internals visible to dynamic proxy.
474
+ </summary>
475
+ <param name="asm">The assembly to inspect.</param>
476
+ </member>
477
+ <member name="M:Castle.DynamicProxy.InternalsHelper.IsInternal(System.Reflection.MethodInfo)">
478
+ <summary>
479
+ Determines whether the specified method is internal.
480
+ </summary>
481
+ <param name="method">The method.</param>
482
+ <returns>
483
+ <c>true</c> if the specified method is internal; otherwise, <c>false</c>.
484
+ </returns>
485
+ </member>
486
+ <member name="M:Castle.DynamicProxy.MixinData.#ctor(System.Collections.Generic.IEnumerable{System.Object})">
487
+ <summary>
488
+ Because we need to cache the types based on the mixed in mixins, we do the following here:
489
+ - Get all the mixin interfaces
490
+ - Sort them by full name
491
+ - Return them by position
492
+
493
+ The idea is to have reproducable behavior for the case that mixins are registered in different orders.
494
+ This method is here because it is required
495
+ </summary>
496
+ </member>
497
+ <member name="T:Castle.DynamicProxy.ModuleScope">
498
+ <summary>
499
+ Summary description for ModuleScope.
500
+ </summary>
501
+ </member>
502
+ <member name="F:Castle.DynamicProxy.ModuleScope.DEFAULT_FILE_NAME">
503
+ <summary>
504
+ The default file name used when the assembly is saved using <see cref="F:Castle.DynamicProxy.ModuleScope.DEFAULT_FILE_NAME"/>.
505
+ </summary>
506
+ </member>
507
+ <member name="F:Castle.DynamicProxy.ModuleScope.DEFAULT_ASSEMBLY_NAME">
508
+ <summary>
509
+ The default assembly (simple) name used for the assemblies generated by a <see cref="T:Castle.DynamicProxy.ModuleScope"/> instance.
510
+ </summary>
511
+ </member>
512
+ <member name="M:Castle.DynamicProxy.ModuleScope.#ctor">
513
+ <summary>
514
+ Initializes a new instance of the <see cref="T:Castle.DynamicProxy.ModuleScope"/> class; assemblies created by this instance will not be saved.
515
+ </summary>
516
+ </member>
517
+ <member name="M:Castle.DynamicProxy.ModuleScope.#ctor(System.Boolean)">
518
+ <summary>
519
+ Initializes a new instance of the <see cref="T:Castle.DynamicProxy.ModuleScope"/> class, allowing to specify whether the assemblies generated by this instance
520
+ should be saved.
521
+ </summary>
522
+ <param name="savePhysicalAssembly">If set to <c>true</c> saves the generated module.</param>
523
+ </member>
524
+ <member name="M:Castle.DynamicProxy.ModuleScope.#ctor(System.Boolean,System.String,System.String,System.String,System.String)">
525
+ <summary>
526
+ Initializes a new instance of the <see cref="T:Castle.DynamicProxy.ModuleScope"/> class, allowing to specify whether the assemblies generated by this instance
527
+ should be saved and what simple names are to be assigned to them.
528
+ </summary>
529
+ <param name="savePhysicalAssembly">If set to <c>true</c> saves the generated module.</param>
530
+ <param name="strongAssemblyName">The simple name of the strong-named assembly generated by this <see cref="T:Castle.DynamicProxy.ModuleScope"/>.</param>
531
+ <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>
532
+ <param name="weakAssemblyName">The simple name of the weak-named assembly generated by this <see cref="T:Castle.DynamicProxy.ModuleScope"/>.</param>
533
+ <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>
534
+ </member>
535
+ <member name="M:Castle.DynamicProxy.ModuleScope.GetFromCache(Castle.DynamicProxy.Generators.CacheKey)">
536
+ <summary>
537
+ Returns a type from this scope's type cache, or null if the key cannot be found.
538
+ </summary>
539
+ <param name="key">The key to be looked up in the cache.</param>
540
+ <returns>The type from this scope's type cache matching the key, or null if the key cannot be found</returns>
541
+ </member>
542
+ <member name="M:Castle.DynamicProxy.ModuleScope.RegisterInCache(Castle.DynamicProxy.Generators.CacheKey,System.Type)">
543
+ <summary>
544
+ Registers a type in this scope's type cache.
545
+ </summary>
546
+ <param name="key">The key to be associated with the type.</param>
547
+ <param name="type">The type to be stored in the cache.</param>
548
+ </member>
549
+ <member name="M:Castle.DynamicProxy.ModuleScope.GetKeyPair">
550
+ <summary>
551
+ Gets the key pair used to sign the strong-named assembly generated by this <see cref="T:Castle.DynamicProxy.ModuleScope"/>.
552
+ </summary>
553
+ <returns></returns>
554
+ </member>
555
+ <member name="M:Castle.DynamicProxy.ModuleScope.ObtainDynamicModule(System.Boolean)">
556
+ <summary>
557
+ Gets the specified module generated by this scope, creating a new one if none has yet been generated.
558
+ </summary>
559
+ <param name="isStrongNamed">If set to true, a strong-named module is returned; otherwise, a weak-named module is returned.</param>
560
+ <returns>A strong-named or weak-named module generated by this scope, as specified by the <paramref name="isStrongNamed"/> parameter.</returns>
561
+ </member>
562
+ <member name="M:Castle.DynamicProxy.ModuleScope.ObtainDynamicModuleWithStrongName">
563
+ <summary>
564
+ Gets the strong-named module generated by this scope, creating a new one if none has yet been generated.
565
+ </summary>
566
+ <returns>A strong-named module generated by this scope.</returns>
567
+ </member>
568
+ <member name="M:Castle.DynamicProxy.ModuleScope.ObtainDynamicModuleWithWeakName">
569
+ <summary>
570
+ Gets the weak-named module generated by this scope, creating a new one if none has yet been generated.
571
+ </summary>
572
+ <returns>A weak-named module generated by this scope.</returns>
573
+ </member>
574
+ <member name="M:Castle.DynamicProxy.ModuleScope.SaveAssembly">
575
+ <summary>
576
+ Saves the generated assembly with the name and directory information given when this <see cref="T:Castle.DynamicProxy.ModuleScope"/> instance was created (or with
577
+ the <see cref="F:Castle.DynamicProxy.ModuleScope.DEFAULT_FILE_NAME"/> and current directory if none was given).
578
+ </summary>
579
+ <remarks>
580
+ <para>
581
+ This method stores the generated assembly in the directory passed as part of the module information specified when this instance was
582
+ constructed (if any, else the current directory is used). If both a strong-named and a weak-named assembly
583
+ have been generated, it will throw an exception; in this case, use the <see cref="M:Castle.DynamicProxy.ModuleScope.SaveAssembly(System.Boolean)"/> overload.
584
+ </para>
585
+ <para>
586
+ If this <see cref="T:Castle.DynamicProxy.ModuleScope"/> was created without indicating that the assembly should be saved, this method does nothing.
587
+ </para></remarks>
588
+ <exception cref="T:System.InvalidOperationException">Both a strong-named and a weak-named assembly have been generated.</exception>
589
+ <returns>The path of the generated assembly file, or null if no file has been generated.</returns>
590
+ </member>
591
+ <member name="M:Castle.DynamicProxy.ModuleScope.SaveAssembly(System.Boolean)">
592
+ <summary>
593
+ Saves the specified generated assembly with the name and directory information given when this <see cref="T:Castle.DynamicProxy.ModuleScope"/> instance was created
594
+ (or with the <see cref="F:Castle.DynamicProxy.ModuleScope.DEFAULT_FILE_NAME"/> and current directory if none was given).
595
+ </summary>
596
+ <param name="strongNamed">True if the generated assembly with a strong name should be saved (see <see cref="P:Castle.DynamicProxy.ModuleScope.StrongNamedModule"/>);
597
+ false if the generated assembly without a strong name should be saved (see <see cref="P:Castle.DynamicProxy.ModuleScope.WeakNamedModule"/>.</param>
598
+ <remarks>
599
+ <para>
600
+ This method stores the specified generated assembly in the directory passed as part of the module information specified when this instance was
601
+ constructed (if any, else the current directory is used).
602
+ </para>
603
+ <para>
604
+ If this <see cref="T:Castle.DynamicProxy.ModuleScope"/> was created without indicating that the assembly should be saved, this method does nothing.
605
+ </para>
606
+ </remarks>
607
+ <exception cref="T:System.InvalidOperationException">No assembly has been generated that matches the <paramref name="strongNamed"/> parameter.
608
+ </exception>
609
+ <returns>The path of the generated assembly file, or null if no file has been generated.</returns>
610
+ </member>
611
+ <member name="M:Castle.DynamicProxy.ModuleScope.LoadAssemblyIntoCache(System.Reflection.Assembly)">
612
+ <summary>
613
+ Loads the generated types from the given assembly into this <see cref="T:Castle.DynamicProxy.ModuleScope"/>'s cache.
614
+ </summary>
615
+ <param name="assembly">The assembly to load types from. This assembly must have been saved via <see cref="M:Castle.DynamicProxy.ModuleScope.SaveAssembly(System.Boolean)"/> or
616
+ <see cref="M:Castle.DynamicProxy.ModuleScope.SaveAssembly"/>, or it must have the <see cref="T:Castle.DynamicProxy.CacheMappingsAttribute"/> manually applied.</param>
617
+ <remarks>
618
+ This method can be used to load previously generated and persisted proxy types from disk into this scope's type cache, eg. in order
619
+ to avoid the performance hit associated with proxy generation.
620
+ </remarks>
621
+ </member>
622
+ <member name="P:Castle.DynamicProxy.ModuleScope.RWLock">
623
+ <summary>
624
+ Users of this <see cref="T:Castle.DynamicProxy.ModuleScope"/> should use this lock when accessing the cache.
625
+ </summary>
626
+ </member>
627
+ <member name="P:Castle.DynamicProxy.ModuleScope.StrongNamedModule">
628
+ <summary>
629
+ Gets the strong-named module generated by this scope, or <see langword="null"/> if none has yet been generated.
630
+ </summary>
631
+ <value>The strong-named module generated by this scope, or <see langword="null"/> if none has yet been generated.</value>
632
+ </member>
633
+ <member name="P:Castle.DynamicProxy.ModuleScope.StrongNamedModuleName">
634
+ <summary>
635
+ Gets the file name of the strongly named module generated by this scope.
636
+ </summary>
637
+ <value>The file name of the strongly named module generated by this scope.</value>
638
+ </member>
639
+ <member name="P:Castle.DynamicProxy.ModuleScope.StrongNamedModuleDirectory">
640
+ <summary>
641
+ Gets the directory where the strongly named module generated by this scope will be saved, or <see langword="null"/> if the current directory
642
+ is used.
643
+ </summary>
644
+ <value>The directory where the strongly named module generated by this scope will be saved when <see cref="M:Castle.DynamicProxy.ModuleScope.SaveAssembly"/> is called
645
+ (if this scope was created to save modules).</value>
646
+ </member>
647
+ <member name="P:Castle.DynamicProxy.ModuleScope.WeakNamedModule">
648
+ <summary>
649
+ Gets the weak-named module generated by this scope, or <see langword="null"/> if none has yet been generated.
650
+ </summary>
651
+ <value>The weak-named module generated by this scope, or <see langword="null"/> if none has yet been generated.</value>
652
+ </member>
653
+ <member name="P:Castle.DynamicProxy.ModuleScope.WeakNamedModuleName">
654
+ <summary>
655
+ Gets the file name of the weakly named module generated by this scope.
656
+ </summary>
657
+ <value>The file name of the weakly named module generated by this scope.</value>
658
+ </member>
659
+ <member name="P:Castle.DynamicProxy.ModuleScope.WeakNamedModuleDirectory">
660
+ <summary>
661
+ Gets the directory where the weakly named module generated by this scope will be saved, or <see langword="null"/> if the current directory
662
+ is used.
663
+ </summary>
664
+ <value>The directory where the weakly named module generated by this scope will be saved when <see cref="M:Castle.DynamicProxy.ModuleScope.SaveAssembly"/> is called
665
+ (if this scope was created to save modules).</value>
666
+ </member>
667
+ <member name="T:Castle.DynamicProxy.PersistentProxyBuilder">
668
+ <summary>
669
+ ProxyBuilder that persists the generated type.
670
+ </summary>
671
+ <remarks>
672
+ The saved assembly contains just the last generated type.
673
+ </remarks>
674
+ </member>
675
+ <member name="M:Castle.DynamicProxy.PersistentProxyBuilder.#ctor">
676
+ <summary>
677
+ Initializes a new instance of the <see cref="T:Castle.DynamicProxy.PersistentProxyBuilder"/> class.
678
+ </summary>
679
+ </member>
680
+ <member name="M:Castle.DynamicProxy.PersistentProxyBuilder.SaveAssembly">
681
+ <summary>
682
+ Saves the generated assembly to a physical file. Note that this renders the <see cref="T:Castle.DynamicProxy.PersistentProxyBuilder"/> unusable.
683
+ </summary>
684
+ <returns>The path of the generated assembly file, or null if no assembly has been generated.</returns>
685
+ <remarks>This method does not support saving multiple files. If both a signed and an unsigned module have been generated, use the
686
+ respective methods of the <see cref="T:Castle.DynamicProxy.ModuleScope"/>.</remarks>
687
+ </member>
688
+ <member name="M:Castle.DynamicProxy.ProxyGenerationOptions.#ctor(Castle.DynamicProxy.IProxyGenerationHook)">
689
+ <summary>
690
+ Initializes a new instance of the <see cref="T:Castle.DynamicProxy.ProxyGenerationOptions"/> class.
691
+ </summary>
692
+ <param name="hook">The hook.</param>
693
+ </member>
694
+ <member name="M:Castle.DynamicProxy.ProxyGenerationOptions.#ctor">
695
+ <summary>
696
+ Initializes a new instance of the <see cref="T:Castle.DynamicProxy.ProxyGenerationOptions"/> class.
697
+ </summary>
698
+ </member>
699
+ <member name="T:Castle.DynamicProxy.ProxyGenerator">
700
+ <summary>
701
+ Provides proxy objects for classes and interfaces.
702
+ </summary>
703
+ </member>
704
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.#ctor(Castle.DynamicProxy.IProxyBuilder)">
705
+ <summary>
706
+ Initializes a new instance of the <see cref="T:Castle.DynamicProxy.ProxyGenerator"/> class.
707
+ </summary>
708
+ <param name="builder">Proxy types builder.</param>
709
+ </member>
710
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.#ctor">
711
+ <summary>
712
+ Initializes a new instance of the <see cref="T:Castle.DynamicProxy.ProxyGenerator"/> class.
713
+ </summary>
714
+ </member>
715
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTarget``1(``0,Castle.Core.Interceptor.IInterceptor[])">
716
+ <summary>
717
+ Creates proxy object intercepting calls to members of interface <typeparamref name="TInterface"/> on <paramref name="target"/> object with given <paramref name="interceptors"/>.
718
+ </summary>
719
+ <typeparam name="TInterface">Type of the interface implemented by <paramref name="target"/> which will be proxied.</typeparam>
720
+ <param name="target">The target object, calls to which will be intercepted.</param>
721
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
722
+ <returns>Object proxying calls to members of <typeparamref name="TInterface"/> on <paramref name="target"/> object.</returns>
723
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="target"/> object is a null reference (Nothing in Visual Basic).</exception>
724
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
725
+ <exception cref="T:System.ArgumentException">Thrown when given <typeparamref name="TInterface"/>is not an interface type.</exception>
726
+ <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
727
+ <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
728
+ <remarks>
729
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
730
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
731
+ </remarks>
732
+ </member>
733
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTarget``1(System.Object,Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])">
734
+ <summary>
735
+ Creates proxy object intercepting calls to members of interface <typeparamref name="TInterface"/> on <paramref name="target"/> object with given <paramref name="interceptors"/>.
736
+ </summary>
737
+ <typeparam name="TInterface">Type of the interface implemented by <paramref name="target"/> which will be proxied.</typeparam>
738
+ <param name="target">The target object, calls to which will be intercepted.</param>
739
+ <param name="options">The proxy generation options used to influence generated proxy type and object.</param>
740
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
741
+ <returns>
742
+ Object proxying calls to members of <typeparamref name="TInterface"/> on <paramref name="target"/> object.
743
+ </returns>
744
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="target"/> object is a null reference (Nothing in Visual Basic).</exception>
745
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
746
+ <exception cref="T:System.ArgumentException">Thrown when given <typeparamref name="TInterface"/>is not an interface type.</exception>
747
+ <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
748
+ <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
749
+ <remarks>
750
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
751
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
752
+ </remarks>
753
+ </member>
754
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTarget(System.Type,System.Object,Castle.Core.Interceptor.IInterceptor[])">
755
+ <summary>
756
+ Creates proxy object intercepting calls to members of interface <paramref name="interfaceToProxy"/> on <paramref name="target"/> object with given <paramref name="interceptors"/>.
757
+ </summary>
758
+ <param name="interfaceToProxy">Type of the interface implemented by <paramref name="target"/> which will be proxied.</param>
759
+ <param name="target">The target object, calls to which will be intercepted.</param>
760
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
761
+ <returns>
762
+ Object proxying calls to members of <paramref name="interfaceToProxy"/> type on <paramref name="target"/> object.
763
+ </returns>
764
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interfaceToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
765
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="target"/> object is a null reference (Nothing in Visual Basic).</exception>
766
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
767
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is a generic type definition.</exception>
768
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is not an interface type.</exception>
769
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="target"/> does not implement <paramref name="interfaceToProxy"/> interface.</exception>
770
+ <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
771
+ <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
772
+ <remarks>
773
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
774
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
775
+ </remarks>
776
+ </member>
777
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTarget(System.Type,System.Object,Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])">
778
+ <summary>
779
+ Creates proxy object intercepting calls to members of interface <paramref name="interfaceToProxy"/> on <paramref name="target"/> object with given <paramref name="interceptors"/>.
780
+ </summary>
781
+ <param name="interfaceToProxy">Type of the interface implemented by <paramref name="target"/> which will be proxied.</param>
782
+ <param name="target">The target object, calls to which will be intercepted.</param>
783
+ <param name="options">The proxy generation options used to influence generated proxy type and object.</param>
784
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
785
+ <returns>
786
+ Object proxying calls to members of <paramref name="interfaceToProxy"/> type on <paramref name="target"/> object.
787
+ </returns>
788
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interfaceToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
789
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="target"/> object is a null reference (Nothing in Visual Basic).</exception>
790
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
791
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is a generic type definition.</exception>
792
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is not an interface type.</exception>
793
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="target"/> does not implement <paramref name="interfaceToProxy"/> interface.</exception>
794
+ <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
795
+ <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
796
+ <remarks>
797
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
798
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
799
+ </remarks>
800
+ </member>
801
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTarget(System.Type,System.Type[],System.Object,Castle.Core.Interceptor.IInterceptor[])">
802
+ <summary>
803
+ Creates proxy object intercepting calls to members of interface <paramref name="interfaceToProxy"/> on <paramref name="target"/> object with given <paramref name="interceptors"/>.
804
+ </summary>
805
+ <param name="interfaceToProxy">Type of the interface implemented by <paramref name="target"/> which will be proxied.</param>
806
+ <param name="target">The target object, calls to which will be intercepted.</param>
807
+ <param name="additionalInterfacesToProxy">Additional interface types. Calls to their members will be proxied as well.</param>
808
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
809
+ <returns>
810
+ Object proxying calls to members of <paramref name="interfaceToProxy"/> and <paramref name="additionalInterfacesToProxy"/> types on <paramref name="target"/> object.
811
+ </returns>
812
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interfaceToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
813
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="target"/> object is a null reference (Nothing in Visual Basic).</exception>
814
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
815
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is a generic type definition.</exception>
816
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is not an interface type.</exception>
817
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="target"/> does not implement <paramref name="interfaceToProxy"/> interface.</exception>
818
+ <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
819
+ <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
820
+ <remarks>
821
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
822
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
823
+ </remarks>
824
+ </member>
825
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTarget(System.Type,System.Type[],System.Object,Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])">
826
+ <summary>
827
+ Creates proxy object intercepting calls to members of interface <paramref name="interfaceToProxy"/> on <paramref name="target"/> object with given <paramref name="interceptors"/>.
828
+ </summary>
829
+ <param name="interfaceToProxy">Type of the interface implemented by <paramref name="target"/> which will be proxied.</param>
830
+ <param name="target">The target object, calls to which will be intercepted.</param>
831
+ <param name="options">The proxy generation options used to influence generated proxy type and object.</param>
832
+ <param name="additionalInterfacesToProxy">Additional interface types. Calls to their members will be proxied as well.</param>
833
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
834
+ <returns>
835
+ Object proxying calls to members of <paramref name="interfaceToProxy"/> and <paramref name="additionalInterfacesToProxy"/> types on <paramref name="target"/> object.
836
+ </returns>
837
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interfaceToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
838
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="target"/> object is a null reference (Nothing in Visual Basic).</exception>
839
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
840
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is a generic type definition.</exception>
841
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is not an interface type.</exception>
842
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="target"/> does not implement <paramref name="interfaceToProxy"/> interface.</exception>
843
+ <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
844
+ <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
845
+ <remarks>
846
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
847
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
848
+ </remarks>
849
+ </member>
850
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTargetInterface(System.Type,System.Object,Castle.Core.Interceptor.IInterceptor[])">
851
+ <summary>
852
+ Creates proxy object intercepting calls to members of interface <paramref name="interfaceToProxy"/> on <paramref name="target"/> object with given <paramref name="interceptors"/>.
853
+ Interceptors can use <see cref="T:Castle.Core.Interceptor.IChangeProxyTarget"/> interface to provide other target for method invocation than default <paramref name="target"/>.
854
+ </summary>
855
+ <param name="interfaceToProxy">Type of the interface implemented by <paramref name="target"/> which will be proxied.</param>
856
+ <param name="target">The target object, calls to which will be intercepted.</param>
857
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
858
+ <returns>
859
+ Object proxying calls to members of <paramref name="interfaceToProxy"/> type on <paramref name="target"/> object or alternative implementation swapped at runtime by an interceptor.
860
+ </returns>
861
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interfaceToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
862
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="target"/> object is a null reference (Nothing in Visual Basic).</exception>
863
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
864
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is a generic type definition.</exception>
865
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is not an interface type.</exception>
866
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="target"/> does not implement <paramref name="interfaceToProxy"/> interface.</exception>
867
+ <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
868
+ <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
869
+ <remarks>
870
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
871
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
872
+ </remarks>
873
+ </member>
874
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTargetInterface(System.Type,System.Object,Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])">
875
+ <summary>
876
+ Creates proxy object intercepting calls to members of interface <paramref name="interfaceToProxy"/> on <paramref name="target"/> object with given <paramref name="interceptors"/>.
877
+ Interceptors can use <see cref="T:Castle.Core.Interceptor.IChangeProxyTarget"/> interface to provide other target for method invocation than default <paramref name="target"/>.
878
+ </summary>
879
+ <param name="interfaceToProxy">Type of the interface implemented by <paramref name="target"/> which will be proxied.</param>
880
+ <param name="target">The target object, calls to which will be intercepted.</param>
881
+ <param name="options">The proxy generation options used to influence generated proxy type and object.</param>
882
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
883
+ <returns>
884
+ Object proxying calls to members of <paramref name="interfaceToProxy"/> type on <paramref name="target"/> object or alternative implementation swapped at runtime by an interceptor.
885
+ </returns>
886
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interfaceToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
887
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="target"/> object is a null reference (Nothing in Visual Basic).</exception>
888
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
889
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is a generic type definition.</exception>
890
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is not an interface type.</exception>
891
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="target"/> does not implement <paramref name="interfaceToProxy"/> interface.</exception>
892
+ <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
893
+ <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
894
+ <remarks>
895
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
896
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
897
+ </remarks>
898
+ </member>
899
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithTargetInterface(System.Type,System.Type[],System.Object,Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])">
900
+ <summary>
901
+ Creates proxy object intercepting calls to members of interface <paramref name="interfaceToProxy"/> on <paramref name="target"/> object with given <paramref name="interceptors"/>.
902
+ Interceptors can use <see cref="T:Castle.Core.Interceptor.IChangeProxyTarget"/> interface to provide other target for method invocation than default <paramref name="target"/>.
903
+ </summary>
904
+ <param name="interfaceToProxy">Type of the interface implemented by <paramref name="target"/> which will be proxied.</param>
905
+ <param name="target">The target object, calls to which will be intercepted.</param>
906
+ <param name="options">The proxy generation options used to influence generated proxy type and object.</param>
907
+ <param name="additionalInterfacesToProxy">Additional interface types. Calls to their members will be proxied as well.</param>
908
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
909
+ <returns>
910
+ 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.
911
+ </returns>
912
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interfaceToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
913
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="target"/> object is a null reference (Nothing in Visual Basic).</exception>
914
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
915
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is a generic type definition.</exception>
916
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is not an interface type.</exception>
917
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="target"/> does not implement <paramref name="interfaceToProxy"/> interface.</exception>
918
+ <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on actual type of <paramref name="target"/> object.</exception>
919
+ <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of actual type of <paramref name="target"/> throws an exception.</exception>
920
+ <remarks>
921
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
922
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
923
+ </remarks>
924
+ </member>
925
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithoutTarget``1(Castle.Core.Interceptor.IInterceptor)">
926
+ <summary>
927
+ Creates proxy object intercepting calls to members of interface <typeparamref name="TInterface"/> on target object generated at runtime with given <paramref name="interceptor"/>.
928
+ </summary>
929
+ <typeparam name="TInterface">Type of the interface which will be proxied.</typeparam>
930
+ <param name="interceptor">The interceptors called during the invocation of proxied methods.</param>
931
+ <returns>
932
+ Object proxying calls to members of <typeparamref name="TInterface"/> types on generated target object.
933
+ </returns>
934
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptor"/> object is a null reference (Nothing in Visual Basic).</exception>
935
+ <exception cref="T:System.ArgumentException">Thrown when given <typeparamref name="TInterface"/> is not an interface type.</exception>
936
+ <remarks>
937
+ 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.
938
+ 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.
939
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
940
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
941
+ </remarks>
942
+ </member>
943
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithoutTarget``1(Castle.Core.Interceptor.IInterceptor[])">
944
+ <summary>
945
+ Creates proxy object intercepting calls to members of interface <typeparamref name="TInterface"/> on target object generated at runtime with given <paramref name="interceptors"/>.
946
+ </summary>
947
+ <typeparam name="TInterface">Type of the interface which will be proxied.</typeparam>
948
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
949
+ <returns>
950
+ Object proxying calls to members of <typeparamref name="TInterface"/> types on generated target object.
951
+ </returns>
952
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
953
+ <exception cref="T:System.ArgumentException">Thrown when given <typeparamref name="TInterface"/> is not an interface type.</exception>
954
+ <remarks>
955
+ 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.
956
+ 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.
957
+ As a result of that also at least one <see cref="T:Castle.Core.Interceptor.IInterceptor"/> implementation must be provided.
958
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
959
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
960
+ </remarks>
961
+ </member>
962
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithoutTarget(System.Type,Castle.Core.Interceptor.IInterceptor)">
963
+ <summary>
964
+ Creates proxy object intercepting calls to members of interface <paramref name="interfaceToProxy"/> on target object generated at runtime with given <paramref name="interceptor"/>.
965
+ </summary>
966
+ <param name="interfaceToProxy">Type of the interface which will be proxied.</param>
967
+ <param name="interceptor">The interceptor called during the invocation of proxied methods.</param>
968
+ <returns>
969
+ Object proxying calls to members of <paramref name="interfaceToProxy"/> type on generated target object.
970
+ </returns>
971
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interfaceToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
972
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptor"/> object is a null reference (Nothing in Visual Basic).</exception>
973
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is a generic type definition.</exception>
974
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is not an interface type.</exception>
975
+ <remarks>
976
+ 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.
977
+ 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.
978
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
979
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
980
+ </remarks>
981
+ </member>
982
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithoutTarget(System.Type,Castle.Core.Interceptor.IInterceptor[])">
983
+ <summary>
984
+ Creates proxy object intercepting calls to members of interface <paramref name="interfaceToProxy"/> on target object generated at runtime with given <paramref name="interceptors"/>.
985
+ </summary>
986
+ <param name="interfaceToProxy">Type of the interface which will be proxied.</param>
987
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
988
+ <returns>
989
+ Object proxying calls to members of <paramref name="interfaceToProxy"/> type on generated target object.
990
+ </returns>
991
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interfaceToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
992
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
993
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is a generic type definition.</exception>
994
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is not an interface type.</exception>
995
+ <remarks>
996
+ 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.
997
+ 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.
998
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
999
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
1000
+ </remarks>
1001
+ </member>
1002
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithoutTarget(System.Type,System.Type[],Castle.Core.Interceptor.IInterceptor[])">
1003
+ <summary>
1004
+ Creates proxy object intercepting calls to members of interface <paramref name="interfaceToProxy"/> on target object generated at runtime with given <paramref name="interceptors"/>.
1005
+ </summary>
1006
+ <param name="interfaceToProxy">Type of the interface which will be proxied.</param>
1007
+ <param name="additionalInterfacesToProxy">Additional interface types. Calls to their members will be proxied as well.</param>
1008
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
1009
+ <returns>
1010
+ Object proxying calls to members of <paramref name="interfaceToProxy"/> and <paramref name="additionalInterfacesToProxy"/> types on generated target object.
1011
+ </returns>
1012
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interfaceToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
1013
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
1014
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is a generic type definition.</exception>
1015
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is not an interface type.</exception>
1016
+ <remarks>
1017
+ 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.
1018
+ 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.
1019
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
1020
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
1021
+ </remarks>
1022
+ </member>
1023
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyWithoutTarget(System.Type,System.Type[],Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])">
1024
+ <summary>
1025
+ Creates proxy object intercepting calls to members of interface <paramref name="interfaceToProxy"/> on target object generated at runtime with given <paramref name="interceptors"/>.
1026
+ </summary>
1027
+ <param name="interfaceToProxy">Type of the interface which will be proxied.</param>
1028
+ <param name="options">The proxy generation options used to influence generated proxy type and object.</param>
1029
+ <param name="additionalInterfacesToProxy">Additional interface types. Calls to their members will be proxied as well.</param>
1030
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
1031
+ <returns>
1032
+ Object proxying calls to members of <paramref name="interfaceToProxy"/> and <paramref name="additionalInterfacesToProxy"/> types on generated target object.
1033
+ </returns>
1034
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interfaceToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
1035
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="interceptors"/> array is a null reference (Nothing in Visual Basic).</exception>
1036
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is a generic type definition.</exception>
1037
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="interfaceToProxy"/> is not an interface type.</exception>
1038
+ <remarks>
1039
+ Since this method uses an empty-shell implementation of <paramref name="additionalInterfacesToProxy"/> to proxy generated at runtime, the actual implementation of proxied methods must be provided by given <see cref="T:Castle.Core.Interceptor.IInterceptor"/> implementations.
1040
+ 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.
1041
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
1042
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
1043
+ </remarks>
1044
+ </member>
1045
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateClassProxy``1(Castle.Core.Interceptor.IInterceptor[])">
1046
+ <summary>
1047
+ 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"/>.
1048
+ </summary>
1049
+ <typeparam name="TClass">Type of class which will be proxied.</typeparam>
1050
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
1051
+ <returns>
1052
+ New object of type <typeparamref name="TClass"/> proxying calls to virtual members of <typeparamref name="TClass"/> type.
1053
+ </returns>
1054
+ <exception cref="T:System.ArgumentException">Thrown when given <typeparamref name="TClass"/> is not a class type.</exception>
1055
+ <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on type <typeparamref name="TClass"/>.</exception>
1056
+ <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of type <typeparamref name="TClass"/> throws an exception.</exception>
1057
+ <remarks>
1058
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
1059
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
1060
+ </remarks>
1061
+ </member>
1062
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateClassProxy(System.Type,Castle.Core.Interceptor.IInterceptor[])">
1063
+ <summary>
1064
+ 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"/>.
1065
+ </summary>
1066
+ <param name="classToProxy">Type of class which will be proxied.</param>
1067
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
1068
+ <returns>
1069
+ New object of type <paramref name="classToProxy"/> proxying calls to virtual members of <paramref name="classToProxy"/> type.
1070
+ </returns>
1071
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="classToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
1072
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is a generic type definition.</exception>
1073
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is not a class type.</exception>
1074
+ <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on type <paramref name="classToProxy"/>.</exception>
1075
+ <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of type <paramref name="classToProxy"/> throws an exception.</exception>
1076
+ <remarks>
1077
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
1078
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
1079
+ </remarks>
1080
+ </member>
1081
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateClassProxy(System.Type,System.Type[],Castle.Core.Interceptor.IInterceptor[])">
1082
+ <summary>
1083
+ 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"/>.
1084
+ </summary>
1085
+ <param name="classToProxy">Type of class which will be proxied.</param>
1086
+ <param name="additionalInterfacesToProxy">Additional interface types. Calls to their members will be proxied as well.</param>
1087
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
1088
+ <returns>
1089
+ New object of type <paramref name="classToProxy"/> proxying calls to virtual members of <paramref name="classToProxy"/> and <paramref name="additionalInterfacesToProxy"/> types.
1090
+ </returns>
1091
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="classToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
1092
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is a generic type definition.</exception>
1093
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is not a class type.</exception>
1094
+ <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on type <paramref name="classToProxy"/>.</exception>
1095
+ <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of type <paramref name="classToProxy"/> throws an exception.</exception>
1096
+ <remarks>
1097
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
1098
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
1099
+ </remarks>
1100
+ </member>
1101
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateClassProxy(System.Type,Castle.Core.Interceptor.IInterceptor[],System.Object[])">
1102
+ <summary>
1103
+ 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"/>.
1104
+ </summary>
1105
+ <param name="classToProxy">Type of class which will be proxied.</param>
1106
+ <param name="constructorArguments">Arguments of constructor of type <paramref name="classToProxy"/> which should be used to create a new instance of that type.</param>
1107
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
1108
+ <returns>
1109
+ New object of type <paramref name="classToProxy"/> proxying calls to virtual members of <paramref name="classToProxy"/> type.
1110
+ </returns>
1111
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="classToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
1112
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is a generic type definition.</exception>
1113
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is not a class type.</exception>
1114
+ <exception cref="T:System.MissingMethodException">Thrown when no constructor exists on type <paramref name="classToProxy"/> with parameters matching <paramref name="constructorArguments"/>.</exception>
1115
+ <exception cref="T:System.Reflection.TargetInvocationException">Thrown when constructor of type <paramref name="classToProxy"/> throws an exception.</exception>
1116
+ <remarks>
1117
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
1118
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
1119
+ </remarks>
1120
+ </member>
1121
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateClassProxy(System.Type,Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])">
1122
+ <summary>
1123
+ 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"/>.
1124
+ </summary>
1125
+ <param name="classToProxy">Type of class which will be proxied.</param>
1126
+ <param name="options">The proxy generation options used to influence generated proxy type and object.</param>
1127
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
1128
+ <returns>
1129
+ New object of type <paramref name="classToProxy"/> proxying calls to virtual members of <paramref name="classToProxy"/> type.
1130
+ </returns>
1131
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="classToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
1132
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="options"/> object is a null reference (Nothing in Visual Basic).</exception>
1133
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is a generic type definition.</exception>
1134
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is not a class type.</exception>
1135
+ <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on type <paramref name="classToProxy"/>.</exception>
1136
+ <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of type <paramref name="classToProxy"/> throws an exception.</exception>
1137
+ <remarks>
1138
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
1139
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
1140
+ </remarks>
1141
+ </member>
1142
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateClassProxy(System.Type,System.Type[],Castle.DynamicProxy.ProxyGenerationOptions,Castle.Core.Interceptor.IInterceptor[])">
1143
+ <summary>
1144
+ 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"/>.
1145
+ </summary>
1146
+ <param name="classToProxy">Type of class which will be proxied.</param>
1147
+ <param name="additionalInterfacesToProxy">Additional interface types. Calls to their members will be proxied as well.</param>
1148
+ <param name="options">The proxy generation options used to influence generated proxy type and object.</param>
1149
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
1150
+ <returns>
1151
+ New object of type <paramref name="classToProxy"/> proxying calls to virtual members of <paramref name="classToProxy"/> and <paramref name="additionalInterfacesToProxy"/> types.
1152
+ </returns>
1153
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="classToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
1154
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="options"/> object is a null reference (Nothing in Visual Basic).</exception>
1155
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is a generic type definition.</exception>
1156
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is not a class type.</exception>
1157
+ <exception cref="T:System.MissingMethodException">Thrown when no default constructor exists on type <paramref name="classToProxy"/>.</exception>
1158
+ <exception cref="T:System.Reflection.TargetInvocationException">Thrown when default constructor of type <paramref name="classToProxy"/> throws an exception.</exception>
1159
+ <remarks>
1160
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
1161
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
1162
+ </remarks>
1163
+ </member>
1164
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateClassProxy(System.Type,System.Type[],Castle.DynamicProxy.ProxyGenerationOptions,System.Object[],Castle.Core.Interceptor.IInterceptor[])">
1165
+ <summary>
1166
+ 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"/>.
1167
+ </summary>
1168
+ <param name="classToProxy">Type of class which will be proxied.</param>
1169
+ <param name="additionalInterfacesToProxy">Additional interface types. Calls to their members will be proxied as well.</param>
1170
+ <param name="options">The proxy generation options used to influence generated proxy type and object.</param>
1171
+ <param name="constructorArguments">Arguments of constructor of type <paramref name="classToProxy"/> which should be used to create a new instance of that type.</param>
1172
+ <param name="interceptors">The interceptors called during the invocation of proxied methods.</param>
1173
+ <returns>
1174
+ New object of type <paramref name="classToProxy"/> proxying calls to virtual members of <paramref name="classToProxy"/> and <paramref name="additionalInterfacesToProxy"/> types.
1175
+ </returns>
1176
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="classToProxy"/> object is a null reference (Nothing in Visual Basic).</exception>
1177
+ <exception cref="T:System.ArgumentNullException">Thrown when given <paramref name="options"/> object is a null reference (Nothing in Visual Basic).</exception>
1178
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> or any of <paramref name="additionalInterfacesToProxy"/> is a generic type definition.</exception>
1179
+ <exception cref="T:System.ArgumentException">Thrown when given <paramref name="classToProxy"/> is not a class type.</exception>
1180
+ <exception cref="T:System.MissingMethodException">Thrown when no constructor exists on type <paramref name="classToProxy"/> with parameters matching <paramref name="constructorArguments"/>.</exception>
1181
+ <exception cref="T:System.Reflection.TargetInvocationException">Thrown when constructor of type <paramref name="classToProxy"/> throws an exception.</exception>
1182
+ <remarks>
1183
+ This method uses <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation to generate a proxy type.
1184
+ As such caller should expect any type of exception that given <see cref="T:Castle.DynamicProxy.IProxyBuilder"/> implementation may throw.
1185
+ </remarks>
1186
+ </member>
1187
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateClassProxyType(System.Type,System.Type[],Castle.DynamicProxy.ProxyGenerationOptions)">
1188
+ <summary>
1189
+ Creates the proxy type for class proxy with given <paramref name="classToProxy"/> class, implementing given <paramref name="additionalInterfacesToProxy"/> and using provided <paramref name="options"/>.
1190
+ </summary>
1191
+ <param name="classToProxy">The base class for proxy type.</param>
1192
+ <param name="additionalInterfacesToProxy">The interfaces that proxy type should implement.</param>
1193
+ <param name="options">The options for proxy generation process.</param>
1194
+ <returns><see cref="T:System.Type"/> of proxy.</returns>
1195
+ </member>
1196
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyTypeWithTarget(System.Type,System.Type[],System.Type,Castle.DynamicProxy.ProxyGenerationOptions)">
1197
+ <summary>
1198
+ Creates the proxy type for interface proxy with target for given <paramref name="interfaceToProxy"/> interface, implementing given <paramref name="additionalInterfacesToProxy"/> on given <paramref name="targetType"/> and using provided <paramref name="options"/>.
1199
+ </summary>
1200
+ <param name="interfaceToProxy">The interface proxy type should implement.</param>
1201
+ <param name="additionalInterfacesToProxy">The additional interfaces proxy type should implement.</param>
1202
+ <param name="targetType">Actual type that the proxy type will encompass.</param>
1203
+ <param name="options">The options for proxy generation process.</param>
1204
+ <returns><see cref="T:System.Type"/> of proxy.</returns>
1205
+ </member>
1206
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyTypeWithTargetInterface(System.Type,System.Type[],System.Type,Castle.DynamicProxy.ProxyGenerationOptions)">
1207
+ <summary>
1208
+ 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"/>.
1209
+ </summary>
1210
+ <param name="interfaceToProxy">The interface proxy type should implement.</param>
1211
+ <param name="additionalInterfacesToProxy">The additional interfaces proxy type should implement.</param>
1212
+ <param name="targetType">Actual type that the proxy type will encompass.</param>
1213
+ <param name="options">The options for proxy generation process.</param>
1214
+ <returns><see cref="T:System.Type"/> of proxy.</returns>
1215
+ </member>
1216
+ <member name="M:Castle.DynamicProxy.ProxyGenerator.CreateInterfaceProxyTypeWithoutTarget(System.Type,System.Type[],Castle.DynamicProxy.ProxyGenerationOptions)">
1217
+ <summary>
1218
+ Creates the proxy type for interface proxy without target for given <paramref name="interfaceToProxy"/> interface, implementing given <paramref name="additionalInterfacesToProxy"/> and using provided <paramref name="options"/>.
1219
+ </summary>
1220
+ <param name="interfaceToProxy">The interface proxy type should implement.</param>
1221
+ <param name="additionalInterfacesToProxy">The additional interfaces proxy type should implement.</param>
1222
+ <param name="options">The options for proxy generation process.</param>
1223
+ <returns><see cref="T:System.Type"/> of proxy.</returns>
1224
+ </member>
1225
+ <member name="P:Castle.DynamicProxy.ProxyGenerator.ProxyBuilder">
1226
+ <summary>
1227
+ Gets the proxy builder instance used to generate proxy types.
1228
+ </summary>
1229
+ <value>The proxy builder.</value>
1230
+ </member>
1231
+ <member name="M:Castle.DynamicProxy.RemotableInvocation.Proceed">
1232
+ <summary>
1233
+
1234
+ </summary>
1235
+ <returns></returns>
1236
+ </member>
1237
+ <member name="P:Castle.DynamicProxy.RemotableInvocation.Method">
1238
+ <summary>
1239
+
1240
+ </summary>
1241
+ </member>
1242
+ <member name="P:Castle.DynamicProxy.RemotableInvocation.MethodInvocationTarget">
1243
+ <summary>
1244
+ For interface proxies, this will point to the
1245
+ <see cref="T:System.Reflection.MethodInfo"/> on the target class
1246
+ </summary>
1247
+ </member>
1248
+ </members>
1249
+ </doc>