-
Notifications
You must be signed in to change notification settings - Fork 111
/
Castle.Windsor.xml
7746 lines (7724 loc) · 382 KB
/
Castle.Windsor.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<?xml version="1.0"?>
<doc>
<assembly>
<name>Castle.Windsor</name>
</assembly>
<members>
<member name="T:Castle.MicroKernel.ComponentActivator.WebUserControlComponentActivator">
<summary>
Attempts to dynamically load a UserControl by invoking Page.LoadControl.
There are two uses of this class.
<para>
1) Add a component to the Kernel and add a VirtualPath attribute specifying
the relative path of the .ascx file for the associated UserControl. (easy)
</para>
<example>
<code>
<component id="BasketView"
service="Castle.ShoppingCart.IBasketView, Castle.ShoppingCart"
type="Castle.ShoppingCart.BasketView, Castle.ShoppingCart"
lifestyle="transient"
virtualPath="~/Views/BasketView.ascx"
/>
</code>
</example>
<para>
2) Precompile a UserControl and add the pre-compiled class to the Kernel. (hard)
Has not been tested with proxies.
</para>
</summary>
</member>
<member name="T:Castle.MicroKernel.ComponentActivator.DefaultComponentActivator">
<summary>
Standard implementation of <see cref="T:Castle.MicroKernel.IComponentActivator"/>.
Handles the selection of the best constructor, fills the
writable properties the component exposes, run the commission
and decommission lifecycles, etc.
</summary>
<remarks>
Custom implementors can just override the <c>CreateInstance</c> method.
Please note however that the activator is responsible for the proxy creation
when needed.
</remarks>
</member>
<member name="T:Castle.MicroKernel.ComponentActivator.AbstractComponentActivator">
<summary>
Abstract implementation of <see cref="T:Castle.MicroKernel.IComponentActivator"/>.
The implementors must only override the InternalCreate and
InternalDestroy methods in order to perform their creation and
destruction logic.
</summary>
</member>
<member name="T:Castle.MicroKernel.IComponentActivator">
<summary>
Implements the instance creation logic. The default
implementation should rely on an ordinary call to
Activator.CreateInstance().
</summary>
<remarks>
This interface is provided in order to allow custom components
to be created using a different logic, such as using a specific factory
or builder.
<para>
The constructor for implementation has the following signature:
</para>
<code>
ComponentModel model, IKernel kernel,
ComponentInstanceDelegate onCreation,
ComponentInstanceDelegate onDestruction
</code>
<para>
The Activator should raise the events onCreation and onDestruction
in order to correctly implement the contract. Usually the best
way of creating a custom activator is by extending the existing ones.
</para>
<seealso cref="T:Castle.MicroKernel.ComponentActivator.AbstractComponentActivator"/>
<seealso cref="T:Castle.MicroKernel.ComponentActivator.DefaultComponentActivator"/>
</remarks>
</member>
<member name="M:Castle.MicroKernel.IComponentActivator.Create(Castle.MicroKernel.Context.CreationContext)">
<summary>
Should return a new component instance.
</summary>
<returns></returns>
</member>
<member name="M:Castle.MicroKernel.IComponentActivator.Destroy(System.Object)">
<summary>
Should perform all necessary work to dispose the instance
and/or any resource related to it.
</summary>
<param name="instance"></param>
</member>
<member name="M:Castle.MicroKernel.ComponentActivator.AbstractComponentActivator.#ctor(Castle.Core.ComponentModel,Castle.MicroKernel.IKernel,Castle.MicroKernel.ComponentInstanceDelegate,Castle.MicroKernel.ComponentInstanceDelegate)">
<summary>
Constructs an AbstractComponentActivator
</summary>
</member>
<member name="M:Castle.MicroKernel.ComponentActivator.DefaultComponentActivator.#ctor(Castle.Core.ComponentModel,Castle.MicroKernel.IKernel,Castle.MicroKernel.ComponentInstanceDelegate,Castle.MicroKernel.ComponentInstanceDelegate)">
<summary>
Initializes a new instance of the <see cref="T:Castle.MicroKernel.ComponentActivator.DefaultComponentActivator"/> class.
</summary>
<param name="model"></param>
<param name="kernel"></param>
<param name="onCreation"></param>
<param name="onDestruction"></param>
</member>
<member name="M:Castle.MicroKernel.ComponentActivator.WebUserControlComponentActivator.#ctor(Castle.Core.ComponentModel,Castle.MicroKernel.IKernel,Castle.MicroKernel.ComponentInstanceDelegate,Castle.MicroKernel.ComponentInstanceDelegate)">
<summary>
Initializes a new instance of the <see cref="T:Castle.MicroKernel.ComponentActivator.WebUserControlComponentActivator"/> class.
</summary>
<param name="model">The model.</param>
<param name="kernel">The kernel.</param>
<param name="onCreation">The on creation.</param>
<param name="onDestruction">The on destruction.</param>
</member>
<member name="M:Castle.MicroKernel.ComponentActivator.WebUserControlComponentActivator.CreateInstance(Castle.MicroKernel.Context.CreationContext,System.Object[],System.Type[])">
<summary>
Creates the instance.
</summary>
<param name="context">The context.</param>
<param name="arguments">The arguments.</param>
<param name="signature">The signature.</param>
<returns></returns>
</member>
<member name="T:Castle.MicroKernel.Lifestyle.PerWebRequestLifestyleManager">
<summary>
Implements a Lifestyle Manager for Web Apps that
create at most one object per web request.
</summary>
</member>
<member name="T:Castle.MicroKernel.Lifestyle.AbstractLifestyleManager">
<summary>
Summary description for AbstractLifestyleManager.
</summary>
</member>
<member name="T:Castle.MicroKernel.ILifestyleManager">
<summary>
The <c>ILifestyleManager</c> implements
a strategy for a given lifestyle, like singleton, per-thread
and transient.
</summary>
<remarks>
The responsibility of <c>ILifestyleManager</c>
is only the management of lifestyle. It should rely on
<see cref="T:Castle.MicroKernel.IComponentActivator"/> to obtain a new component instance
</remarks>
</member>
<member name="M:Castle.MicroKernel.ILifestyleManager.Init(Castle.MicroKernel.IComponentActivator,Castle.MicroKernel.IKernel,Castle.Core.ComponentModel)">
<summary>
Initializes the <c>ILifestyleManager</c> with the
<see cref="T:Castle.MicroKernel.IComponentActivator"/>
</summary>
<param name="componentActivator"></param>
<param name="kernel"></param>
<param name="model"></param>
</member>
<member name="M:Castle.MicroKernel.ILifestyleManager.Resolve(Castle.MicroKernel.Context.CreationContext)">
<summary>
Implementors should return the component instance based
on the lifestyle semantic.
</summary>
<returns></returns>
</member>
<member name="M:Castle.MicroKernel.ILifestyleManager.Release(System.Object)">
<summary>
Implementors should release the component instance based
on the lifestyle semantic, for example, singleton components
should not be released on a call for release, instead they should
release them when disposed is invoked.
</summary>
<param name="instance"></param>
</member>
<member name="T:Castle.Core.CastleComponentAttribute">
<summary>
This attribute is useful only when you want to register all components
on an assembly as a batch process.
By doing so, the batch register will look
for this attribute to distinguish components from other classes.
</summary>
</member>
<member name="T:Castle.Core.LifestyleAttribute">
<summary>
Base for Attributes that want to express lifestyle
chosen by the component.
</summary>
</member>
<member name="M:Castle.Core.LifestyleAttribute.#ctor(Castle.Core.LifestyleType)">
<summary>
Initializes a new instance of the <see cref="T:Castle.Core.LifestyleAttribute"/> class.
</summary>
<param name="type">The type.</param>
</member>
<member name="P:Castle.Core.LifestyleAttribute.Lifestyle">
<summary>
Gets or sets the lifestyle.
</summary>
<value>The lifestyle.</value>
</member>
<member name="T:Castle.Core.ComponentActivatorAttribute">
<summary>
Associates a custom component with a component
</summary>
</member>
<member name="M:Castle.Core.ComponentActivatorAttribute.#ctor(System.Type)">
<summary>
Initializes a new instance of the <see cref="T:Castle.Core.ComponentActivatorAttribute"/> class.
</summary>
<param name="componentActivatorType">Type of the component activator.</param>
</member>
<member name="P:Castle.Core.ComponentActivatorAttribute.ComponentActivatorType">
<summary>
Gets the type of the component activator.
</summary>
<value>The type of the component activator.</value>
</member>
<member name="T:Castle.Core.ComponentProxyBehaviorAttribute">
<summary>
Specifies the proxying behavior for a component.
</summary>
</member>
<member name="P:Castle.Core.ComponentProxyBehaviorAttribute.UseMarshalByRefProxy">
<summary>
Gets or sets a value indicating whether the generated
interface proxy should inherit from <see cref="T:System.MarshalByRefObject"/>.
</summary>
</member>
<member name="P:Castle.Core.ComponentProxyBehaviorAttribute.UseSingleInterfaceProxy">
<summary>
Determines if the component requires a single interface proxy.
</summary>
<value><c>true</c> if the component requires a single interface proxy.</value>
</member>
<member name="P:Castle.Core.ComponentProxyBehaviorAttribute.AdditionalInterfaces">
<summary>
Gets or sets the additional interfaces used during proxy generation.
</summary>
</member>
<member name="T:Castle.Core.DoNotWireAttribute">
<summary>
Marks as property to be skipped and not be wired
by the IoC container
</summary>
</member>
<member name="T:Castle.Core.ILifecycleConcern">
<summary>
Represents a concern that will be applied to a component instance
during commission or decommission phase.
</summary>
</member>
<member name="M:Castle.Core.ILifecycleConcern.Apply(Castle.Core.ComponentModel,System.Object)">
<summary>
Implementors should act on the instance in response to
a decommission or commission phase.
</summary>
<param name="model">The model.</param>
<param name="component">The component.</param>
</member>
<member name="T:Castle.Core.IInitializable">
<summary>
Lifecycle interface. If implemented by a component,
the method Initialized will be invoked by the container
before making the component available to the external world.
</summary>
</member>
<member name="M:Castle.Core.IInitializable.Initialize">
<summary>
Implementors should perform any initialization logic.
</summary>
</member>
<member name="T:Castle.Core.InterceptorAttribute">
<summary>
Used to declare that a component wants interceptors acting on it.
</summary>
</member>
<member name="M:Castle.Core.InterceptorAttribute.#ctor(System.String)">
<summary>
Constructs the InterceptorAttribute pointing to
a key to a interceptor
</summary>
<param name = "componentKey"></param>
</member>
<member name="M:Castle.Core.InterceptorAttribute.#ctor(System.Type)">
<summary>
Constructs the InterceptorAttribute pointing to
a service
</summary>
<param name = "interceptorType"></param>
</member>
<member name="T:Castle.Core.Internal.LateBoundComponent">
<summary>
Marker class used to denote components that have late bound type
That is the actual type is not known exactly at the time when <see cref="T:Castle.Core.ComponentModel"/>
is created. Those are for example components instantiated via abstract factory.
</summary>
</member>
<member name="M:Castle.Core.Internal.ReflectionUtil.GetCompatibleArrayItemType(System.Type)">
<summary>
If the extended type is a Foo[] or IEnumerable{Foo} which is assignable from Foo[] this method will return typeof(Foo)
otherwise <c>null</c>.
</summary>
<param name="type"></param>
<returns></returns>
</member>
<member name="T:Castle.Core.SingletonAttribute">
<summary>
Indicates that the target components wants a
singleton lifestyle.
</summary>
</member>
<member name="M:Castle.Core.SingletonAttribute.#ctor">
<summary>
Initializes a new instance of the <see cref="T:Castle.Core.SingletonAttribute"/> class.
</summary>
</member>
<member name="T:Castle.Core.TransientAttribute">
<summary>
Indicates that the target components wants a
transient lifestyle.
</summary>
</member>
<member name="M:Castle.Core.TransientAttribute.#ctor">
<summary>
Initializes a new instance of the <see cref="T:Castle.Core.TransientAttribute"/> class.
</summary>
</member>
<member name="T:Castle.Core.PerThreadAttribute">
<summary>
Indicates that the target components wants a
per thread lifestyle.
</summary>
</member>
<member name="M:Castle.Core.PerThreadAttribute.#ctor">
<summary>
Initializes a new instance of the <see cref="T:Castle.Core.PerThreadAttribute"/> class.
</summary>
</member>
<member name="T:Castle.Core.PerWebRequestAttribute">
<summary>
Indicates that the target components wants a
per web request lifestyle.
</summary>
</member>
<member name="T:Castle.Core.PooledAttribute">
<summary>
Indicates that the target components wants a
pooled lifestyle.
</summary>
</member>
<member name="M:Castle.Core.PooledAttribute.#ctor">
<summary>
Initializes a new instance of the <see cref="T:Castle.Core.PooledAttribute"/> class
using the default initial pool size (5) and the max pool size (15).
</summary>
</member>
<member name="M:Castle.Core.PooledAttribute.#ctor(System.Int32,System.Int32)">
<summary>
Initializes a new instance of the <see cref="T:Castle.Core.PooledAttribute"/> class.
</summary>
<param name="initialPoolSize">Initial size of the pool.</param>
<param name="maxPoolSize">Max pool size.</param>
</member>
<member name="P:Castle.Core.PooledAttribute.InitialPoolSize">
<summary>
Gets the initial size of the pool.
</summary>
<value>The initial size of the pool.</value>
</member>
<member name="P:Castle.Core.PooledAttribute.MaxPoolSize">
<summary>
Gets the maximum pool size.
</summary>
<value>The size of the max pool.</value>
</member>
<member name="T:Castle.Core.CustomLifestyleAttribute">
<summary>
Indicates that the target components wants a
custom lifestyle.
</summary>
</member>
<member name="M:Castle.Core.CustomLifestyleAttribute.#ctor(System.Type)">
<summary>
Initializes a new instance of the <see cref="T:Castle.Core.CustomLifestyleAttribute"/> class.
</summary>
<param name="lifestyleHandlerType">The lifestyle handler.</param>
</member>
<member name="P:Castle.Core.CustomLifestyleAttribute.LifestyleHandlerType">
<summary>
Gets the type of the lifestyle handler.
</summary>
<value>The type of the lifestyle handler.</value>
</member>
<member name="T:Castle.Core.LifestyleType">
<summary>
Enumeration used to mark the component's lifestyle.
</summary>
</member>
<member name="F:Castle.Core.LifestyleType.Undefined">
<summary>
No lifestyle specified.
</summary>
</member>
<member name="F:Castle.Core.LifestyleType.Singleton">
<summary>
Singleton components are instantiated once, and shared
between all clients.
</summary>
</member>
<member name="F:Castle.Core.LifestyleType.Thread">
<summary>
Thread components have a unique instance per thread.
</summary>
</member>
<member name="F:Castle.Core.LifestyleType.Transient">
<summary>
Transient components are created on demand.
</summary>
</member>
<member name="F:Castle.Core.LifestyleType.Pooled">
<summary>
Optimization of transient components that keeps
instance in a pool instead of always creating them.
</summary>
</member>
<member name="F:Castle.Core.LifestyleType.PerWebRequest">
<summary>
PerWebRequest components are created once per Http Request
</summary>
</member>
<member name="F:Castle.Core.LifestyleType.Custom">
<summary>
Any other logic to create/release components.
</summary>
</member>
<member name="T:Castle.Facilities.EventWiring.EventSubscribers">
<summary>
Collects information about subscribers for given event
</summary>
</member>
<member name="T:Castle.Facilities.EventWiring.NaiveMethodNameExtractor">
<summary>
Extracts MethodInfo of metho invoked in delegate. Based on ILReader class from http://www.gocosmos.org project
</summary>
</member>
<member name="T:Castle.MicroKernel.ModelBuilder.IContributeComponentModelConstruction">
<summary>
Implementors must inspect the component for
a given information or parameter.
</summary>
</member>
<member name="M:Castle.MicroKernel.ModelBuilder.IContributeComponentModelConstruction.ProcessModel(Castle.MicroKernel.IKernel,Castle.Core.ComponentModel)">
<summary>
Usually the implementation will look in the configuration property
of the model or the service interface, or the implementation looking for
something.
</summary>
<param name="kernel">The kernel instance</param>
<param name="model">The component model</param>
</member>
<member name="M:Castle.Facilities.TypedFactory.ITypedFactoryComponentSelector.SelectComponent(System.Reflection.MethodInfo,System.Type,System.Object[])">
<summary>
Selects one or both of component name and type, for given method
called on given typed factory type.
When component should be requested by type only,
componentName should be null.
When component should be requested by name only,
componentType should be null.
</summary>
<param name="method"></param>
<param name="type"></param>
<param name="arguments"></param>
<returns></returns>
</member>
<member name="M:Castle.Facilities.TypedFactory.DefaultTypedFactoryComponentSelector.BuildFactoryComponent(System.Reflection.MethodInfo,System.String,System.Type,System.Collections.IDictionary)">
<summary>
Builds <see cref="T:Castle.Facilities.TypedFactory.TypedFactoryComponent"/> for given call.
By default if <paramref name="componentType"/> is a collection
returns <see cref="T:Castle.Facilities.TypedFactory.TypedFactoryComponentCollection"/> for the collection's item type,
otherwise standard <see cref="T:Castle.Facilities.TypedFactory.TypedFactoryComponent"/>.
</summary>
<param name="method"></param>
<param name="componentName"></param>
<param name="componentType"></param>
<param name="additionalArguments"></param>
<returns></returns>
</member>
<member name="M:Castle.Facilities.TypedFactory.DefaultTypedFactoryComponentSelector.GetArguments(System.Reflection.MethodInfo,System.Object[])">
<summary>
Selects arguments to be passed to resolution pipeline.
By default passes all given <paramref name = "arguments" />
keyed by names of their corresponding <paramref name = "method" /> parameters.
</summary>
<param name = "method"></param>
<param name = "arguments"></param>
<returns></returns>
</member>
<member name="M:Castle.Facilities.TypedFactory.DefaultTypedFactoryComponentSelector.GetComponentName(System.Reflection.MethodInfo,System.Object[])">
<summary>
Selects name of the component to resolve.
If <paramref name = "method" /> Name is GetFoo returns "Foo", otherwise <c>null</c>.
</summary>
<param name = "method"></param>
<param name = "arguments"></param>
<returns></returns>
</member>
<member name="M:Castle.Facilities.TypedFactory.DefaultTypedFactoryComponentSelector.GetComponentType(System.Reflection.MethodInfo,System.Object[])">
<summary>
Selects type of the component to resolve. Uses <paramref name = "method" /> return type.
</summary>
<param name = "method"></param>
<param name = "arguments"></param>
<returns></returns>
</member>
<member name="T:Castle.MicroKernel.Resolvers.ILazyComponentLoader">
<summary>
Provides lazy registration capabilities to the container.
</summary>
<remarks>
When a component is requested from a container and it was not registered,
container loads up all registered implementers of this interface and asks
them in turn whether they can provide that component, until it finds one that will.
</remarks>
</member>
<member name="M:Castle.MicroKernel.Resolvers.ILazyComponentLoader.Load(System.String,System.Type,System.Collections.IDictionary)">
<summary>
Used by container to allow the loader to register component for given <paramref name="key"/> and <paramref name="service"/> to the container at the time when it is requested
</summary>
<param name="key">Key of the requested component or null</param>
<param name="service">Type of requested service or null</param>
<param name="arguments">User supplied arguments or null</param>
<returns>Registration that registers component for given key and/or service or null.</returns>
<remarks>
While either key or service can be null reference it is guaranteed that at least one of them will not be null.
When implementer opts in to provide the requested component (by returning not-null registration) it is required
to register component for requested key/service combination (when one of the elements is null, it should be ignored as well).
When implementer does not want to register the requested component it must return null.
</remarks>
</member>
<member name="T:Castle.MicroKernel.ComponentActivator.ComponentActivatorException">
<summary>
Summary description for ComponentActivatorException.
</summary>
</member>
<member name="T:Castle.MicroKernel.Burden">
<summary>
</summary>
</member>
<member name="T:Castle.MicroKernel.Arguments">
<summary>
Represents collection of arguments used when resolving a component.
</summary>
</member>
<member name="T:Castle.MicroKernel.ComponentActivator.NoResolvableConstructorFoundException">
<summary>
Exception thrown when component has no resolvable constructor that can be used to create an instance.
</summary>
</member>
<member name="T:Castle.MicroKernel.Context.FallbackArgumentsStore">
<summary>
Default arguments store used to store items where no specialized store exists
</summary>
</member>
<member name="T:Castle.MicroKernel.Context.DependencyTrackingScope.DependencyModelExtended">
<summary>
Extends <see cref="T:Castle.Core.DependencyModel"/> adding <see cref="T:System.Reflection.MemberInfo"/> and <see cref="T:Castle.Core.ComponentModel"/>
information. The MemberInfo is only useful to provide detailed information
on exceptions.
The ComponentModel is required so we can get resolve an object that takes as a parameter itself, but
with difference model. (See IoC 51 for the details)
</summary>
</member>
<member name="T:Castle.Core.DependencyModel">
<summary>
Represents a dependency (other component or a
fixed value available through external configuration).
</summary>
</member>
<member name="M:Castle.Core.DependencyModel.#ctor(Castle.Core.DependencyType,System.String,System.Type,System.Boolean)">
<summary>
Initializes a new instance of the <see cref="T:Castle.Core.DependencyModel"/> class.
</summary>
<param name="dependencyType">The type.</param>
<param name="dependencyKey">The dependency key.</param>
<param name="targetType">Type of the target.</param>
<param name="isOptional">if set to <c>true</c> [is optional].</param>
</member>
<member name="M:Castle.Core.DependencyModel.ToString">
<summary>
Returns a <see cref = "T:System.String" /> that represents the current <see cref = "T:System.Object" />.
</summary>
<returns>
A <see cref = "T:System.String" /> that represents the current <see cref = "T:System.Object" />.
</returns>
</member>
<member name="P:Castle.Core.DependencyModel.DependencyKey">
<summary>
Gets or sets the dependency key.
</summary>
<value>The dependency key.</value>
</member>
<member name="P:Castle.Core.DependencyModel.DependencyType">
<summary>
Gets or sets the type of the dependency.
</summary>
<value>The type of the dependency.</value>
</member>
<member name="P:Castle.Core.DependencyModel.IsOptional">
<summary>
Gets or sets whether this dependency is optional.
</summary>
<value>
<c>true</c> if this dependency is optional; otherwise, <c>false</c>.
</value>
</member>
<member name="P:Castle.Core.DependencyModel.TargetItemType">
<summary>
Gets the service type of the dependency.
This is the same type as <see cref="P:Castle.Core.DependencyModel.TargetType"/> or if <see cref="P:Castle.Core.DependencyModel.TargetType"/> is by ref,
then it's the element type of the reference. (in other words if dependency
is <c>out IFoo foo</c> this will be <c>IFoo</c>, while <see cref="P:Castle.Core.DependencyModel.TargetType"/> will be <c>&IFoo</c>);
</summary>
</member>
<member name="P:Castle.Core.DependencyModel.TargetType">
<summary>
Gets the type of the target.
</summary>
<value>The type of the target.</value>
</member>
<member name="T:Castle.MicroKernel.Handlers.DefaultHandler">
<summary>
Summary description for DefaultHandler.
</summary>
</member>
<member name="T:Castle.MicroKernel.Handlers.AbstractHandler">
<summary>
Implements the basis of
<see cref="T:Castle.MicroKernel.IHandler"/>
</summary>
</member>
<member name="T:Castle.MicroKernel.IHandler">
<summary>
Contract for the IHandler, which manages an
component state and coordinates its creation
and destruction (dispatching to activators, lifestyle managers)
</summary>
</member>
<member name="T:Castle.MicroKernel.ISubDependencyResolver">
<summary>
Implementors should use a strategy to obtain
valid references to properties and/or services
requested in the dependency model.
</summary>
</member>
<member name="M:Castle.MicroKernel.ISubDependencyResolver.Resolve(Castle.MicroKernel.Context.CreationContext,Castle.MicroKernel.ISubDependencyResolver,Castle.Core.ComponentModel,Castle.Core.DependencyModel)">
<summary>
Should return an instance of a service or property values as
specified by the dependency model instance.
It is also the responsibility of <see cref="T:Castle.MicroKernel.IDependencyResolver"/>
to throw an exception in the case a non-optional dependency
could not be resolved.
</summary>
<param name="context">Creation context, which is a resolver itself</param>
<param name="contextHandlerResolver">Parent resolver - normally the IHandler implementation</param>
<param name="model">Model of the component that is requesting the dependency</param>
<param name="dependency">The dependency model</param>
<returns>The dependency resolved value or null</returns>
</member>
<member name="M:Castle.MicroKernel.ISubDependencyResolver.CanResolve(Castle.MicroKernel.Context.CreationContext,Castle.MicroKernel.ISubDependencyResolver,Castle.Core.ComponentModel,Castle.Core.DependencyModel)">
<summary>
Returns true if the resolver is able to satisfy this dependency.
</summary>
<param name="context">Creation context, which is a resolver itself</param>
<param name="contextHandlerResolver">Parent resolver - normally the IHandler implementation</param>
<param name="model">Model of the component that is requesting the dependency</param>
<param name="dependency">The dependency model</param>
<returns><c>true</c> if the dependency can be satisfied</returns>
</member>
<member name="M:Castle.MicroKernel.IHandler.Init(Castle.MicroKernel.IKernel)">
<summary>
Initializes the handler with a reference to the
kernel.
</summary>
<param name="kernel"></param>
</member>
<member name="M:Castle.MicroKernel.IHandler.Resolve(Castle.MicroKernel.Context.CreationContext)">
<summary>
Implementors should return a valid instance
for the component the handler is responsible.
It should throw an exception in the case the component
can't be created for some reason
</summary>
<returns></returns>
</member>
<member name="M:Castle.MicroKernel.IHandler.TryResolve(Castle.MicroKernel.Context.CreationContext)">
<summary>
Implementors should return a valid instance
for the component the handler is responsible.
It should return null in the case the component
can't be created for some reason
</summary>
<returns></returns>
</member>
<member name="M:Castle.MicroKernel.IHandler.Release(System.Object)">
<summary>
Implementors should dispose the component instance
</summary>
<param name="instance"></param>
<returns>true if destroyed.</returns>
</member>
<member name="M:Castle.MicroKernel.IHandler.AddCustomDependencyValue(System.Object,System.Object)">
<summary>
Dictionary of String/object used to
associate data with a component dependency.
For example, if you component SmtpServer depends on
host and port, you can add those to this
dictionary and the handler will be able to use them.
</summary>
<remarks>
TODO: Document this
</remarks>
</member>
<member name="M:Castle.MicroKernel.IHandler.RemoveCustomDependencyValue(System.Object)">
<summary>
TODO: Document this
</summary>
<param name="key"></param>
</member>
<member name="M:Castle.MicroKernel.IHandler.HasCustomParameter(System.Object)">
<summary>
TODO: Document this
</summary>
<param name="key"></param>
<returns></returns>
</member>
<member name="M:Castle.MicroKernel.IHandler.IsBeingResolvedInContext(Castle.MicroKernel.Context.CreationContext)">
<summary>
Tests whether the handler is already being resolved in given context.
</summary>
</member>
<member name="P:Castle.MicroKernel.IHandler.CurrentState">
<summary>
Gets the state of the handler
</summary>
</member>
<member name="P:Castle.MicroKernel.IHandler.ComponentModel">
<summary>
Gets the model of the component being
managed by this handler.
</summary>
</member>
<member name="P:Castle.MicroKernel.IHandler.Service">
<summary>
The service that this handler handles
</summary>
</member>
<member name="E:Castle.MicroKernel.IHandler.OnHandlerStateChanged">
<summary>
Allow to track state changes of a handler that is modified directly.
This can happen if the client calls AddCustomDependencyValue or
RemoveCustomDependencyValue
</summary>
</member>
<member name="T:Castle.MicroKernel.Handlers.IExposeDependencyInfo">
<summary>
Might be implemented by a handler
so it can expose access to dependency information
which is used to construct meaningful error messages
</summary>
</member>
<member name="M:Castle.MicroKernel.Handlers.IExposeDependencyInfo.ObtainDependencyDetails(System.Collections.IList)">
<summary>
Returns human readable list of dependencies
this handler is waiting for.
<param name="dependenciesChecked">list of the dependencies that was already checked, used to avoid cycles.</param>
</summary>
</member>
<member name="F:Castle.MicroKernel.Handlers.AbstractHandler.lifestyleManager">
<summary>
Lifestyle manager instance
</summary>
</member>
<member name="F:Castle.MicroKernel.Handlers.AbstractHandler.customParameters">
<summary>
Custom dependencies values associated with the handler
</summary>
</member>
<member name="F:Castle.MicroKernel.Handlers.AbstractHandler.dependenciesByKey">
<summary>
Dictionary of key (string) to
<see cref="T:Castle.Core.DependencyModel"/>
</summary>
</member>
<member name="F:Castle.MicroKernel.Handlers.AbstractHandler.dependenciesByService">
<summary>
Dictionary of Type to a list of
<see cref="T:Castle.Core.DependencyModel"/>
</summary>
</member>
<member name="M:Castle.MicroKernel.Handlers.AbstractHandler.#ctor(Castle.Core.ComponentModel)">
<summary>
Constructs and initializes the handler
</summary>
<param name = "model"></param>
</member>
<member name="M:Castle.MicroKernel.Handlers.AbstractHandler.ReleaseCore(System.Object)">
<summary>
Should be implemented by derived classes:
disposes the component instance (or recycle it)
</summary>
<param name = "instance"></param>
<returns>true if destroyed.</returns>
</member>
<member name="M:Castle.MicroKernel.Handlers.AbstractHandler.ResolveCore(Castle.MicroKernel.Context.CreationContext,System.Boolean,System.Boolean)">
<summary>
Should be implemented by derived classes:
returns an instance of the component this handler
is responsible for
</summary>
<param name = "context"></param>
<param name = "requiresDecommission"></param>
<param name = "instanceRequired">When <c>false</c>, handler can not create valid instance and return <c>null</c> instead.</param>
<returns></returns>
</member>
<member name="M:Castle.MicroKernel.Handlers.AbstractHandler.ObtainDependencyDetails(System.Collections.IList)">
<summary>
Returns human readable list of dependencies
this handler is waiting for.
</summary>
<returns></returns>
</member>
<member name="M:Castle.MicroKernel.Handlers.AbstractHandler.Init(Castle.MicroKernel.IKernel)">
<summary>
Saves the kernel instance, subscribes to
<see cref="E:Castle.MicroKernel.IKernelEvents.AddedAsChildKernel"/>
event,
creates the lifestyle manager instance and computes
the handler state.
</summary>
<param name="kernel"></param>
</member>
<member name="M:Castle.MicroKernel.Handlers.AbstractHandler.Release(System.Object)">
<summary>
disposes the component instance (or recycle it).
</summary>
<param name = "instance"></param>
<returns></returns>
</member>
<member name="M:Castle.MicroKernel.Handlers.AbstractHandler.Resolve(Castle.MicroKernel.Context.CreationContext)">
<summary>
Returns an instance of the component this handler
is responsible for
</summary>
<param name = "context"></param>
<returns></returns>
</member>
<member name="M:Castle.MicroKernel.Handlers.AbstractHandler.AddDependency(Castle.Core.DependencyModel)">
<summary>
Invoked by
<see cref="M:Castle.MicroKernel.Handlers.AbstractHandler.EnsureDependenciesCanBeSatisfied(Castle.MicroKernel.ComponentActivator.IDependencyAwareActivator)"/>
in order to check if a dependency can be satisfied.
If not, the handler is set to a 'waiting dependency' state.
</summary>
<remarks>
This method registers the dependencies within the correct collection
or dictionary and changes the handler state to
<see cref="F:Castle.MicroKernel.HandlerState.WaitingDependency"/>
</remarks>
<param name="dependency"></param>
</member>
<member name="M:Castle.MicroKernel.Handlers.AbstractHandler.CreateLifestyleManager(Castle.MicroKernel.IComponentActivator)">
<summary>
Creates an implementation of
<see cref="T:Castle.MicroKernel.ILifestyleManager"/>
based
on
<see cref="T:Castle.Core.LifestyleType"/>
and invokes
<see cref="M:Castle.MicroKernel.ILifestyleManager.Init(Castle.MicroKernel.IComponentActivator,Castle.MicroKernel.IKernel,Castle.Core.ComponentModel)"/>
to initialize the newly created manager.
</summary>
<param name="activator"></param>
<returns></returns>
</member>
<member name="M:Castle.MicroKernel.Handlers.AbstractHandler.DependencySatisfied(System.Boolean@)">
<summary>
Invoked by the kernel
when one of registered dependencies were satisfied by
new components registered.
</summary>
<remarks>
Handler for the event
<see cref="E:Castle.MicroKernel.IKernelEvents.HandlerRegistered"/>
</remarks>
<param name="stateChanged"></param>
</member>
<member name="M:Castle.MicroKernel.Handlers.AbstractHandler.EnsureDependenciesCanBeSatisfied(Castle.MicroKernel.ComponentActivator.IDependencyAwareActivator)">
<summary>
Checks if the handler is able to, at very least, satisfy
the dependencies for the constructor with less parameters
</summary>
<remarks>
For each non*optional dependency, the implementation will invoke
<see cref="M:Castle.MicroKernel.Handlers.AbstractHandler.AddDependency(Castle.Core.DependencyModel)"/>
</remarks>
</member>
<member name="M:Castle.MicroKernel.Handlers.AbstractHandler.OnAddedAsChildKernel(System.Object,System.EventArgs)">
<summary>
Invoked when the container receives a parent container reference.
</summary>
<remarks>
This method implementation checks whether the parent container
is able to supply the dependencies for this handler.
</remarks>
<param name = "sender"></param>
<param name = "e"></param>
</member>
<member name="M:Castle.MicroKernel.Handlers.AbstractHandler.Resolve(Castle.MicroKernel.Context.CreationContext,System.Boolean)">
<summary>
Returns an instance of the component this handler
is responsible for
</summary>
<param name = "context"></param>
<param name = "instanceRequired">when <c>false</c>, handler can not create valid instance and return <c>null</c> instead </param>
<returns></returns>
</member>
<member name="M:Castle.MicroKernel.Handlers.AbstractHandler.HandlerStateChanged(System.Object,System.EventArgs)">
<summary>
Handler for the event
<see cref="E:Castle.MicroKernel.Handlers.AbstractHandler.OnHandlerStateChanged"/>
</summary>
<param name="source"></param>
<param name="args"></param>
</member>
<member name="P:Castle.MicroKernel.Handlers.AbstractHandler.ComponentModel">
<summary>
Gets the component model.
</summary>
</member>
<member name="P:Castle.MicroKernel.Handlers.AbstractHandler.CurrentState">
<summary>
Gets the handler state.
</summary>
</member>
<member name="M:Castle.MicroKernel.Handlers.DefaultHandler.#ctor(Castle.Core.ComponentModel)">
<summary>
Initializes a new instance of the <see cref="T:Castle.MicroKernel.Handlers.DefaultHandler"/> class.
</summary>
<param name="model"></param>
</member>
<member name="M:Castle.MicroKernel.Handlers.DefaultHandler.ResolveCore(Castle.MicroKernel.Context.CreationContext,System.Boolean,System.Boolean)">
<summary>
Returns an instance of the component this handler
is responsible for
</summary>
<param name="context"></param>
<param name="requiresDecommission"></param>
<param name="instanceRequired"></param>
<returns></returns>
</member>
<member name="M:Castle.MicroKernel.Handlers.DefaultHandler.ReleaseCore(System.Object)">
<summary>
disposes the component instance (or recycle it)
</summary>
<param name="instance"></param>
<returns>true if destroyed</returns>
</member>
<member name="T:Castle.MicroKernel.Context.CreationContext">
<summary>
Used during a component request, passed along to the whole process.
This allow some data to be passed along the process, which is used
to detected cycled dependency graphs and now it's also being used
to provide arguments to components.
</summary>
</member>
<member name="F:Castle.MicroKernel.Context.CreationContext.dependencies">
<summary>
Holds the scoped dependencies being resolved.
If a dependency appears twice on the same scope, we'd have a cycle.
</summary>
</member>
<member name="F:Castle.MicroKernel.Context.CreationContext.handlerStack">
<summary>
The list of handlers that are used to resolve
the component.
We track that in order to try to avoid attempts to resolve a service
with itself.
</summary>
</member>
<member name="M:Castle.MicroKernel.Context.CreationContext.#ctor(System.Type,Castle.MicroKernel.Context.CreationContext,System.Boolean)">
<summary>
Initializes a new instance of the <see cref="T:Castle.MicroKernel.Context.CreationContext"/> class.
</summary>
<param name="typeToExtractGenericArguments">The type to extract generic arguments.</param>
<param name="parentContext">The parent context.</param>
<param name="propagateInlineDependencies">When set to <c>true</c> will clone <paramref name="parentContext"/> <see cref="P:Castle.MicroKernel.Context.CreationContext.AdditionalParameters"/>.</param>
</member>
<member name="M:Castle.MicroKernel.Context.CreationContext.#ctor(Castle.MicroKernel.IHandler,Castle.MicroKernel.IReleasePolicy,System.Type,System.Collections.IDictionary,Castle.MicroKernel.SubSystems.Conversion.ITypeConverter,Castle.MicroKernel.Context.CreationContext)">
<summary>
Initializes a new instance of the <see cref="T:Castle.MicroKernel.Context.CreationContext"/> class.
</summary>
<param name="handler">The handler.</param>